1456 lines
54 KiB
C++
1456 lines
54 KiB
C++
#include <iostream>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <optional>
|
|
#include <variant>
|
|
#include <cctype>
|
|
#include <complex>
|
|
#include <sstream>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <algorithm>
|
|
|
|
#include "../libs/linenoise.hpp"
|
|
|
|
enum class ValueTypes {
|
|
Identifier, Int, Double, String, List, Function, Type, Nil, Auto
|
|
};
|
|
|
|
enum class ParserErrorType {
|
|
UnexpectedEndOfInput,
|
|
UnexpectedToken,
|
|
MissingOpenParen,
|
|
MissingCloseParen,
|
|
UnexpectedTopLevelToken
|
|
};
|
|
|
|
enum class InterpreterErrorType {
|
|
UnknownInstruction,
|
|
UnexpectedToken,
|
|
IncorrectTokenType,
|
|
MathError,
|
|
UnknownEnvironment
|
|
};
|
|
|
|
enum class CTranspilerErrorType {
|
|
UnknownInstruction,
|
|
UnexpectedToken,
|
|
IncorrectTokenType,
|
|
UnknownEnvironment
|
|
};
|
|
|
|
class CTranspilerError : public std::exception {
|
|
std::string message;
|
|
CTranspilerErrorType type;
|
|
public:
|
|
explicit CTranspilerError(CTranspilerErrorType type) : type(type) {
|
|
std::stringstream ss;
|
|
ss << "Compiling error: ";
|
|
switch (type) {
|
|
case CTranspilerErrorType::UnknownInstruction:
|
|
ss << "UnknownInstruction";
|
|
break;
|
|
case CTranspilerErrorType::UnexpectedToken:
|
|
ss << "UnexpectedToken";
|
|
break;
|
|
case CTranspilerErrorType::IncorrectTokenType:
|
|
ss << "IncorrectTokenType";
|
|
break;
|
|
case CTranspilerErrorType::UnknownEnvironment:
|
|
ss << "UnknownEnvironment";
|
|
break;
|
|
}
|
|
message = ss.str();
|
|
}
|
|
[[nodiscard]] const char *what() const noexcept override {
|
|
return message.c_str();
|
|
}
|
|
};
|
|
|
|
class InterpretingError : public std::exception {
|
|
std::string message;
|
|
InterpreterErrorType errorType;
|
|
public:
|
|
explicit InterpretingError(InterpreterErrorType errorType) : errorType(errorType) {
|
|
std::stringstream oss;
|
|
|
|
oss << "Interpreting error: ";
|
|
switch (errorType) {
|
|
case InterpreterErrorType::UnexpectedToken:
|
|
oss << "Unexpected token";
|
|
break;
|
|
case InterpreterErrorType::UnknownInstruction:
|
|
oss << "Unknown instruction";
|
|
break;
|
|
case InterpreterErrorType::IncorrectTokenType:
|
|
oss << "Incorrect token type";
|
|
break;
|
|
case InterpreterErrorType::MathError:
|
|
oss << "Math error";
|
|
break;
|
|
case InterpreterErrorType::UnknownEnvironment:
|
|
oss << "Unknown environment";
|
|
break;
|
|
}
|
|
message = oss.str();
|
|
}
|
|
|
|
[[nodiscard]] const char* what() const noexcept override {
|
|
return message.c_str();
|
|
}
|
|
};
|
|
|
|
class ParsingError : public std::exception {
|
|
std::string message;
|
|
ParserErrorType errorType;
|
|
int position;
|
|
std::string sourceCode;
|
|
|
|
public:
|
|
ParsingError(ParserErrorType type, int pos, std::string source = "")
|
|
: errorType(type), position(pos), sourceCode(std::move(source)) {
|
|
std::ostringstream oss;
|
|
oss << "Parsing error at position " << pos << ": ";
|
|
|
|
switch (type) {
|
|
case ParserErrorType::UnexpectedEndOfInput:
|
|
oss << "Unexpected end of input";
|
|
break;
|
|
case ParserErrorType::UnexpectedToken:
|
|
oss << "Unexpected token";
|
|
break;
|
|
case ParserErrorType::MissingOpenParen:
|
|
oss << "Expected '(' at start of expression";
|
|
break;
|
|
case ParserErrorType::MissingCloseParen:
|
|
oss << "Missing closing ')'";
|
|
break;
|
|
case ParserErrorType::UnexpectedTopLevelToken:
|
|
oss << "Unexpected token at top level (expected '(')";
|
|
break;
|
|
}
|
|
|
|
message = oss.str();
|
|
}
|
|
|
|
[[nodiscard]] const char* what() const noexcept override {
|
|
return message.c_str();
|
|
}
|
|
|
|
[[nodiscard]] ParserErrorType getErrorType() const { return errorType; }
|
|
[[nodiscard]] int getPosition() const { return position; }
|
|
[[nodiscard]] const std::string& getSourceCode() const { return sourceCode; }
|
|
};
|
|
|
|
class Instruction;
|
|
|
|
class Function {
|
|
public:
|
|
ValueTypes returnType = ValueTypes::Nil;
|
|
std::vector<std::pair<std::string, ValueTypes>> arguments;
|
|
std::vector<Instruction> code;
|
|
Function(ValueTypes returnType, std::vector<std::pair<std::string, ValueTypes>> args, std::vector<Instruction> code) : returnType(returnType), arguments(std::move(args)), code(std::move(code)) {}
|
|
Function() = default;
|
|
};
|
|
|
|
class Value {
|
|
std::variant<int, double, std::string, void*, std::vector<Value>, Function, ValueTypes> value;
|
|
public:
|
|
ValueTypes type;
|
|
[[nodiscard]] std::optional<int> getInt() const {
|
|
if (std::holds_alternative<int>(value)) {
|
|
return std::get<int>(value);
|
|
}
|
|
return {};
|
|
}
|
|
[[nodiscard]] std::optional<double> getDouble() const {
|
|
if (std::holds_alternative<double>(value)) {
|
|
return std::get<double>(value);
|
|
}
|
|
return {};
|
|
}
|
|
[[nodiscard]] std::optional<std::string> getString() const {
|
|
if (std::holds_alternative<std::string>(value)) {
|
|
return std::get<std::string>(value);
|
|
}
|
|
return {};
|
|
}
|
|
[[nodiscard]] std::optional<std::vector<Value>> getList() const {
|
|
if (std::holds_alternative<std::vector<Value>>(value)) {
|
|
return std::get<std::vector<Value>>(value);
|
|
}
|
|
return {};
|
|
}
|
|
[[nodiscard]] std::optional<Function> getFunction() const {
|
|
if (std::holds_alternative<Function>(value)) {
|
|
return std::get<Function>(value);
|
|
}
|
|
return {};
|
|
}
|
|
[[nodiscard]] std::optional<ValueTypes> getType() const {
|
|
if (std::holds_alternative<ValueTypes>(value)) {
|
|
return std::get<ValueTypes>(value);
|
|
}
|
|
return {};
|
|
}
|
|
void print() const {
|
|
switch (type) {
|
|
case ValueTypes::String: {
|
|
std::cout << getString().value();
|
|
break;
|
|
}
|
|
case ValueTypes::Int: {
|
|
std::cout << getInt().value();
|
|
break;
|
|
}
|
|
case ValueTypes::Double: {
|
|
std::cout << getDouble().value();
|
|
break;
|
|
}
|
|
case ValueTypes::List: {
|
|
auto list = getList().value();
|
|
bool first = true;
|
|
for (auto& listElement : list) {
|
|
if (!first) {
|
|
std::cout << ", ";
|
|
} else {
|
|
first = false;
|
|
}
|
|
listElement.print();
|
|
}
|
|
break;
|
|
}
|
|
case ValueTypes::Function: {
|
|
std::cout << "<function>";
|
|
break;
|
|
}
|
|
case ValueTypes::Type: {
|
|
std::cout << "<type>";
|
|
break;
|
|
}
|
|
default:
|
|
case ValueTypes::Nil: {
|
|
std::cout << "\033[2;3;96m" << "nil" << "\033[0m";
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool operator==(Value &otherValue) const {
|
|
if (type != otherValue.type) {
|
|
return false;
|
|
}
|
|
switch (type) {
|
|
case ValueTypes::String: {
|
|
if (getString() == otherValue.getString()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case ValueTypes::Int: {
|
|
if (getInt() == otherValue.getInt()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case ValueTypes::Double: {
|
|
if (getDouble() == otherValue.getDouble()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case ValueTypes::List: {
|
|
auto list = getList().value();
|
|
auto compareList = otherValue.getList().value();
|
|
if (list.size() != compareList.size()) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < list.size(); i++) {
|
|
if (list[i] == compareList[i]) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
friend std::ostream& operator<<(std::ostream &os, const Value &obj) {
|
|
switch (obj.type) {
|
|
case ValueTypes::String: {
|
|
os << obj.getString().value();
|
|
break;
|
|
}
|
|
case ValueTypes::Int: {
|
|
os << obj.getInt().value();
|
|
break;
|
|
}
|
|
case ValueTypes::Double: {
|
|
os << obj.getDouble().value();
|
|
break;
|
|
}
|
|
case ValueTypes::List: {
|
|
auto list = obj.getList().value();
|
|
bool first = true;
|
|
for (auto& listElement : list) {
|
|
if (!first) {
|
|
os << ", ";
|
|
} else {
|
|
first = false;
|
|
}
|
|
listElement.print();
|
|
}
|
|
break;
|
|
}
|
|
case ValueTypes::Function: {
|
|
os << "<function>";
|
|
break;
|
|
}
|
|
case ValueTypes::Type: {
|
|
os << "<type>";
|
|
break;
|
|
}
|
|
default:
|
|
case ValueTypes::Nil: {
|
|
os << "\033[2;3;96m" << "nil" << "\033[0m";
|
|
}
|
|
}
|
|
return os;
|
|
}
|
|
|
|
explicit Value() : value(nullptr), type(ValueTypes::Nil) {}
|
|
explicit Value(int in) : value(in), type(ValueTypes::Int) {}
|
|
explicit Value(double in) : value(in), type(ValueTypes::Double) {}
|
|
explicit Value(std::string in) : value(in), type(ValueTypes::String) {}
|
|
explicit Value(std::vector<Value> in) : value(in), type(ValueTypes::List) {}
|
|
explicit Value(Function in) : value(in), type(ValueTypes::Function) {}
|
|
explicit Value(ValueTypes in) : value(in), type(ValueTypes::Type) {}
|
|
Value(std::string in, bool isIdentifier) : value(in), type(isIdentifier ? ValueTypes::Identifier : ValueTypes::String) {}
|
|
};
|
|
|
|
class Instruction {
|
|
public:
|
|
std::string instruction;
|
|
std::vector<std::variant<Instruction, Value>> args;
|
|
Instruction(std::string instruction, std::vector<std::variant<Instruction, Value>> args) : instruction(std::move(instruction)), args(std::move(args)) {}
|
|
Instruction() = default;
|
|
};
|
|
|
|
class Parser {
|
|
std::string input;
|
|
std::vector<std::string> split;
|
|
int currentChar = -1;
|
|
int current = -1;
|
|
|
|
std::optional<char> consumeChar() {
|
|
currentChar++;
|
|
if (currentChar >= input.size()) {
|
|
return {};
|
|
}
|
|
return input[currentChar];
|
|
}
|
|
|
|
std::optional<std::string> consume() {
|
|
current++;
|
|
if (current >= split.size()) {
|
|
return {};
|
|
}
|
|
return split[current];
|
|
}
|
|
|
|
[[nodiscard]] std::optional<std::string> peek() const {
|
|
if (current + 1 >= split.size()) {
|
|
return {};
|
|
}
|
|
return split[current + 1];
|
|
}
|
|
|
|
// Helper to detect value type
|
|
static Value parseValue(const std::string& token) {
|
|
// If it's nil, just return nil
|
|
if (token == "nil") {
|
|
return Value();
|
|
}
|
|
|
|
// Also check the types
|
|
if (token == "int") {
|
|
return Value(ValueTypes::Int);
|
|
}
|
|
if (token == "double") {
|
|
return Value(ValueTypes::Double);
|
|
}
|
|
if (token == "string") {
|
|
return Value(ValueTypes::String);
|
|
}
|
|
if (token == "list") {
|
|
return Value(ValueTypes::List);
|
|
}
|
|
if (token == "function") {
|
|
return Value(ValueTypes::Function);
|
|
}
|
|
if (token == "type") {
|
|
return Value(ValueTypes::Type);
|
|
}
|
|
|
|
// Check if it's a string literal
|
|
if (token.front() == '"' && token.back() == '"') {
|
|
return Value(token.substr(1, token.length() - 2));
|
|
}
|
|
|
|
// Try to parse as integer
|
|
bool isInt = true;
|
|
bool isDouble = false;
|
|
for (size_t i = 0; i < token.length(); i++) {
|
|
char c = token[i];
|
|
if (i == 0 && c == '-') continue; // Allow negative sign
|
|
if (c == '.') {
|
|
if (isDouble) { // Second dot
|
|
isInt = false;
|
|
break;
|
|
}
|
|
isDouble = true;
|
|
isInt = false;
|
|
} else if (!std::isdigit(c)) {
|
|
isInt = false;
|
|
isDouble = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isInt) {
|
|
return Value(std::stoi(token));
|
|
}
|
|
if (isDouble) {
|
|
return Value(std::stod(token));
|
|
}
|
|
|
|
// If it isn't any value, return an identifier
|
|
return {token, true};
|
|
}
|
|
|
|
// Recursive parser for expressions
|
|
Instruction parseExpression() {
|
|
auto topt = consume();
|
|
if (!topt) {
|
|
throw ParsingError(ParserErrorType::UnexpectedEndOfInput, current, input);
|
|
}
|
|
|
|
std::string token = topt.value();
|
|
if (token != "(") {
|
|
throw ParsingError(ParserErrorType::MissingOpenParen, current, input);
|
|
}
|
|
|
|
topt = consume();
|
|
if (!topt) {
|
|
throw ParsingError(ParserErrorType::UnexpectedEndOfInput, current, input);
|
|
}
|
|
|
|
std::string instruction = topt.value();
|
|
std::vector<std::variant<Instruction, Value>> args;
|
|
|
|
while (true) {
|
|
topt = peek();
|
|
if (!topt) {
|
|
throw ParsingError(ParserErrorType::MissingCloseParen, current, input);
|
|
}
|
|
|
|
token = topt.value();
|
|
|
|
if (token == ")") {
|
|
consume();
|
|
break;
|
|
} else if (token == "(") {
|
|
args.emplace_back(parseExpression());
|
|
} else {
|
|
consume();
|
|
args.emplace_back(parseValue(token));
|
|
}
|
|
}
|
|
|
|
return {instruction, args};
|
|
}
|
|
|
|
public:
|
|
std::vector<Instruction> instructions;
|
|
|
|
explicit Parser(std::string in) : input(std::move(in)) {
|
|
// Lexer logic
|
|
std::string buf;
|
|
bool inString = false;
|
|
while (auto copt = consumeChar()) {
|
|
char c = copt.value();
|
|
if (c != '"' && inString) {
|
|
buf.push_back(c);
|
|
continue;
|
|
}
|
|
switch (c) {
|
|
case '(': case ')': case '[': case ']': {
|
|
if (!buf.empty()) {
|
|
split.push_back(buf);
|
|
buf.clear();
|
|
}
|
|
split.emplace_back(1, c);
|
|
break;
|
|
}
|
|
case ' ': case '\n':
|
|
if (!buf.empty()) {
|
|
split.push_back(buf);
|
|
buf.clear();
|
|
}
|
|
break;
|
|
case '"': {
|
|
inString = !inString;
|
|
buf.push_back('"');
|
|
if (!inString) {
|
|
split.push_back(buf);
|
|
buf.clear();
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
buf.push_back(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Parser logic - parse all top-level expressions
|
|
while (peek()) {
|
|
auto token = peek().value();
|
|
if (token == "(") {
|
|
instructions.push_back(parseExpression());
|
|
} else {
|
|
throw ParsingError(ParserErrorType::UnexpectedTopLevelToken, current + 1, input);
|
|
}
|
|
}
|
|
}
|
|
Parser() = default;
|
|
};
|
|
|
|
class Interpreter {
|
|
public:
|
|
std::vector<Instruction> instructions = {};
|
|
Value returnValue;
|
|
std::map<std::string, Value> environment = {{"pippleVersion", Value("0.0.1")}};
|
|
|
|
Value interpretInstruction(Instruction& instruction) {
|
|
// Preprocess identifiers
|
|
for (auto& arg : instruction.args) {
|
|
if (std::holds_alternative<Value>(arg) && instruction.instruction != "let" && instruction.instruction != "set" && instruction.instruction != "function") {
|
|
if (std::get<Value>(arg).type == ValueTypes::Identifier) {
|
|
std::string id = std::get<Value>(arg).getString().value();
|
|
if (!environment.contains(id)) {
|
|
throw InterpretingError(InterpreterErrorType::UnknownEnvironment);
|
|
}
|
|
arg = environment[id];
|
|
}
|
|
}
|
|
}
|
|
// Instructions at the top of this function require input to not be preprocessed
|
|
if (instruction.instruction == "if") {
|
|
if (instruction.args.size() < 2) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
bool toContinue = true;
|
|
if (std::holds_alternative<Instruction>(instruction.args[0])) {
|
|
toContinue = interpretInstruction(std::get<Instruction>(instruction.args[0])).type != ValueTypes::Nil;
|
|
}
|
|
if (std::holds_alternative<Value>(instruction.args[0])) {
|
|
toContinue = std::get<Value>(instruction.args[0]).type != ValueTypes::Nil;
|
|
}
|
|
if (toContinue) {
|
|
bool first = true;
|
|
Value returnValue;
|
|
for (auto& arg : instruction.args) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
if (std::holds_alternative<Instruction>(arg)) {
|
|
returnValue = interpretInstruction(std::get<Instruction>(arg));
|
|
}
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
return Value();
|
|
}
|
|
if (instruction.instruction == "while") {
|
|
if (instruction.args.size() < 2) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
while (true) {
|
|
Value conditionResult;
|
|
if (std::holds_alternative<Instruction>(instruction.args[0])) {
|
|
Instruction condCopy = std::get<Instruction>(instruction.args[0]);
|
|
conditionResult = interpretInstruction(condCopy);
|
|
} else if (std::holds_alternative<Value>(instruction.args[0])) {
|
|
conditionResult = std::get<Value>(instruction.args[0]);
|
|
}
|
|
|
|
if (conditionResult.type == ValueTypes::Nil) {
|
|
break;
|
|
}
|
|
|
|
for (size_t i = 1; i < instruction.args.size(); i++) {
|
|
if (std::holds_alternative<Instruction>(instruction.args[i])) {
|
|
Instruction bodyCopy = std::get<Instruction>(instruction.args[i]);
|
|
if (bodyCopy.instruction == "break") {
|
|
return Value();
|
|
}
|
|
interpretInstruction(bodyCopy);
|
|
}
|
|
}
|
|
}
|
|
return Value();
|
|
}
|
|
if (instruction.instruction == "function") {
|
|
// (function returntype [valtype argname valtype argname] (code) (morecode))
|
|
|
|
// returnType
|
|
if (std::holds_alternative<Instruction>(instruction.args[0])) {
|
|
instruction.args[0] = interpretInstruction(std::get<Instruction>(instruction.args[0]));
|
|
}
|
|
auto returnTypeValue = std::get<Value>(instruction.args[0]);
|
|
if (returnTypeValue.type != ValueTypes::Type) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
ValueTypes returnType = returnTypeValue.getType().value();
|
|
std::vector<std::pair<std::string, ValueTypes>> args;
|
|
|
|
// [valtype argname valtype argname]
|
|
int argAmount = 0;
|
|
if (std::holds_alternative<Value>(instruction.args[1]) && std::get<Value>(instruction.args[1]).type == ValueTypes::Identifier && std::get<Value>(instruction.args[1]).getString().value() != "[") {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
for (int i = 2; i < instruction.args.size(); i += 2) {
|
|
if (std::holds_alternative<Instruction>(instruction.args[i])) {
|
|
instruction.args[i] = interpretInstruction(std::get<Instruction>(instruction.args[i]));
|
|
}
|
|
// this is safe to do because we just evaluated the instruction
|
|
Value argTypeVal = std::get<Value>(instruction.args[i]);
|
|
if (argTypeVal.type != ValueTypes::Type) {
|
|
if (argTypeVal.type == ValueTypes::Identifier && argTypeVal.getString().value() == "]") {
|
|
break;
|
|
}
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
ValueTypes argType = argTypeVal.getType().value();
|
|
|
|
// identifiers cannot be returned by anything
|
|
if (std::holds_alternative<Instruction>(instruction.args[i + 1])) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
Value argNameVal = std::get<Value>(instruction.args[i + 1]);
|
|
if (argNameVal.type != ValueTypes::Identifier) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
std::string argName = argNameVal.getString().value();
|
|
|
|
args.emplace_back(argName, argType);
|
|
argAmount += 2;
|
|
}
|
|
|
|
// (code) (morecode)
|
|
std::vector<Instruction> body;
|
|
for (int i = argAmount + 3; i < instruction.args.size(); i++) {
|
|
if (std::holds_alternative<Instruction>(instruction.args[i])) {
|
|
body.push_back(std::get<Instruction>(instruction.args[i]));
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
return Value(Function(returnType, args, body));
|
|
}
|
|
// Preprocess instructions inside instructions
|
|
for (auto &arg : instruction.args) {
|
|
if (std::holds_alternative<Instruction>(arg)) {
|
|
arg = interpretInstruction(std::get<Instruction>(arg));
|
|
}
|
|
}
|
|
// Instructions that don't require preprocessing go below this line
|
|
// It is safe to use std::get<Value>(...) on all arguments
|
|
|
|
// First, search for custom functions
|
|
if (environment.contains(instruction.instruction)) {
|
|
if (environment[instruction.instruction].type == ValueTypes::Function) {
|
|
Function function = environment[instruction.instruction].getFunction().value();
|
|
if (function.arguments.size() != instruction.args.size()) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
Interpreter fnInterpreter;
|
|
fnInterpreter.environment = this->environment;
|
|
for (int i = 0; i < instruction.args.size(); i++) {
|
|
Value argTypeVal = std::get<Value>(instruction.args[i]);
|
|
if (argTypeVal.type != function.arguments[i].second) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
fnInterpreter.environment[function.arguments[i].first] = std::get<Value>(instruction.args[i]);
|
|
}
|
|
Value fnReturnValue;
|
|
for (Instruction& inst : function.code) {
|
|
if (inst.instruction == "return") {
|
|
return fnInterpreter.interpretInstruction(inst);
|
|
}
|
|
fnReturnValue = fnInterpreter.interpretInstruction(inst);
|
|
}
|
|
return fnReturnValue;
|
|
|
|
} else {
|
|
return environment[instruction.instruction];
|
|
}
|
|
return Value();
|
|
}
|
|
if (instruction.instruction == "+" || instruction.instruction == "add") {
|
|
double result = 0;
|
|
for (const auto& arg : instruction.args) {
|
|
auto value = std::get<Value>(arg);
|
|
switch (value.type) {
|
|
case ValueTypes::Int: {
|
|
result += value.getInt().value();
|
|
break;
|
|
}
|
|
case ValueTypes::Double: {
|
|
result += value.getDouble().value();
|
|
break;
|
|
}
|
|
default: {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
}
|
|
if (result == static_cast<int>(result)) {
|
|
return Value(static_cast<int>(result));
|
|
}
|
|
return Value(result);
|
|
}
|
|
if (instruction.instruction == "-" || instruction.instruction == "subtract") {
|
|
if (instruction.args.empty()) return Value(0);
|
|
|
|
auto firstValue = std::get<Value>(instruction.args[0]);
|
|
double result = 0;
|
|
|
|
if (firstValue.type == ValueTypes::Int) {
|
|
result = firstValue.getInt().value();
|
|
} else if (firstValue.type == ValueTypes::Double) {
|
|
result = firstValue.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
for (size_t i = 1; i < instruction.args.size(); i++) {
|
|
auto value = std::get<Value>(instruction.args[i]);
|
|
if (value.type == ValueTypes::Int) {
|
|
result -= value.getInt().value();
|
|
} else if (value.type == ValueTypes::Double) {
|
|
result -= value.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
|
|
if (result == static_cast<int>(result)) {
|
|
return Value(static_cast<int>(result));
|
|
}
|
|
return Value(result);
|
|
}
|
|
|
|
if (instruction.instruction == "*" || instruction.instruction == "multiply") {
|
|
if (instruction.args.empty()) return Value(1);
|
|
|
|
auto firstValue = std::get<Value>(instruction.args[0]);
|
|
double result = 0;
|
|
|
|
if (firstValue.type == ValueTypes::Int) {
|
|
result = firstValue.getInt().value();
|
|
} else if (firstValue.type == ValueTypes::Double) {
|
|
result = firstValue.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
for (size_t i = 1; i < instruction.args.size(); i++) {
|
|
auto value = std::get<Value>(instruction.args[i]);
|
|
if (value.type == ValueTypes::Int) {
|
|
result *= value.getInt().value();
|
|
} else if (value.type == ValueTypes::Double) {
|
|
result *= value.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
|
|
if (result == static_cast<int>(result)) {
|
|
return Value(static_cast<int>(result));
|
|
}
|
|
return Value(result);
|
|
}
|
|
|
|
if (instruction.instruction == "/" || instruction.instruction == "divide") {
|
|
if (instruction.args.empty()) return Value(1);
|
|
|
|
auto firstValue = std::get<Value>(instruction.args[0]);
|
|
double result = 0;
|
|
|
|
if (firstValue.type == ValueTypes::Int) {
|
|
result = firstValue.getInt().value();
|
|
} else if (firstValue.type == ValueTypes::Double) {
|
|
result = firstValue.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
for (size_t i = 1; i < instruction.args.size(); i++) {
|
|
auto value = std::get<Value>(instruction.args[i]);
|
|
if (value.type == ValueTypes::Int) {
|
|
if (value.getInt().value() == 0) {
|
|
throw InterpretingError(InterpreterErrorType::MathError);
|
|
}
|
|
result /= value.getInt().value();
|
|
} else if (value.type == ValueTypes::Double) {
|
|
if (value.getDouble().value() == 0) {
|
|
throw InterpretingError(InterpreterErrorType::MathError);
|
|
}
|
|
result /= value.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
|
|
if (result == static_cast<int>(result)) {
|
|
return Value(static_cast<int>(result));
|
|
}
|
|
return Value(result);
|
|
}
|
|
if (instruction.instruction == "==" || instruction.instruction == "equal") {
|
|
bool first = true;
|
|
Value firstVal;
|
|
for (const auto& arg : instruction.args) {
|
|
auto value = std::get<Value>(arg);
|
|
if (first) {
|
|
first = false;
|
|
firstVal = value;
|
|
} else {
|
|
if (value != firstVal) {
|
|
return Value();
|
|
}
|
|
}
|
|
}
|
|
return Value(1);
|
|
}
|
|
if (instruction.instruction == "!=" || instruction.instruction == "inequal") {
|
|
bool first = true;
|
|
Value firstVal;
|
|
for (const auto& arg : instruction.args) {
|
|
auto value = std::get<Value>(arg);
|
|
if (first) {
|
|
first = false;
|
|
firstVal = value;
|
|
} else {
|
|
if (value == firstVal) {
|
|
return Value();
|
|
}
|
|
}
|
|
}
|
|
return Value(1);
|
|
}
|
|
if (instruction.instruction == "<" || instruction.instruction == "lesser") {
|
|
if (instruction.args.size() != 2) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
auto left = std::get<Value>(instruction.args[0]);
|
|
auto right = std::get<Value>(instruction.args[1]);
|
|
|
|
double leftVal = 0, rightVal = 0;
|
|
|
|
if (left.type == ValueTypes::Int) {
|
|
leftVal = left.getInt().value();
|
|
} else if (left.type == ValueTypes::Double) {
|
|
leftVal = left.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
if (right.type == ValueTypes::Int) {
|
|
rightVal = right.getInt().value();
|
|
} else if (right.type == ValueTypes::Double) {
|
|
rightVal = right.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
return leftVal < rightVal ? Value(1) : Value();
|
|
}
|
|
|
|
if (instruction.instruction == ">" || instruction.instruction == "greater") {
|
|
if (instruction.args.size() != 2) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
auto left = std::get<Value>(instruction.args[0]);
|
|
auto right = std::get<Value>(instruction.args[1]);
|
|
|
|
double leftVal = 0, rightVal = 0;
|
|
|
|
if (left.type == ValueTypes::Int) {
|
|
leftVal = left.getInt().value();
|
|
} else if (left.type == ValueTypes::Double) {
|
|
leftVal = left.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
if (right.type == ValueTypes::Int) {
|
|
rightVal = right.getInt().value();
|
|
} else if (right.type == ValueTypes::Double) {
|
|
rightVal = right.getDouble().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
return leftVal > rightVal ? Value(1) : Value();
|
|
}
|
|
if (instruction.instruction == "input") {
|
|
std::string input;
|
|
linenoise::Readline("", input);
|
|
return Value(input);
|
|
}
|
|
if (instruction.instruction == "return") {
|
|
if (instruction.args.empty()) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
return std::get<Value>(instruction.args[0]);
|
|
}
|
|
if (instruction.instruction == "list") {
|
|
std::vector<Value> list;
|
|
for (const auto& item : instruction.args) {
|
|
list.push_back(std::get<Value>(item));
|
|
}
|
|
return Value(list);
|
|
}
|
|
if (instruction.instruction == "let") {
|
|
if (instruction.args.size() < 2) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
auto idval = std::get<Value>(instruction.args[0]);
|
|
std::string id;
|
|
if (idval.type == ValueTypes::Identifier) {
|
|
id = idval.getString().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
environment[id] = std::get<Value>(instruction.args[1]);
|
|
return {environment[id]};
|
|
}
|
|
if (instruction.instruction == "set") {
|
|
if (instruction.args.size() < 2) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
auto idval = std::get<Value>(instruction.args[0]);
|
|
std::string id;
|
|
if (idval.type == ValueTypes::Identifier) {
|
|
id = idval.getString().value();
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
if (!environment.contains(id)) {
|
|
throw InterpretingError(InterpreterErrorType::UnknownEnvironment);
|
|
}
|
|
environment[id] = std::get<Value>(instruction.args[1]);
|
|
return {environment[id]};
|
|
}
|
|
if (instruction.instruction == "print") {
|
|
for (const auto& arg : instruction.args) {
|
|
auto value = std::get<Value>(arg);
|
|
value.print();
|
|
std::cout << " ";
|
|
}
|
|
std::cout << "\n";
|
|
return Value();
|
|
}
|
|
if (instruction.instruction == "log") {
|
|
for (const auto& arg : instruction.args) {
|
|
std::cout << "\033[2;3;93m";
|
|
auto value = std::get<Value>(arg);
|
|
value.print();
|
|
std::cout << " ";
|
|
}
|
|
std::cout << "\033[0m\n";
|
|
return Value();
|
|
}
|
|
if (instruction.instruction == "exit") {
|
|
if (!instruction.args.empty()) {
|
|
auto value = std::get<Value>(instruction.args[0]);
|
|
if (value.type == ValueTypes::Int) {
|
|
exit(value.getInt().value());
|
|
}
|
|
}
|
|
exit(0);
|
|
}
|
|
throw InterpretingError(InterpreterErrorType::UnknownInstruction);
|
|
}
|
|
explicit Interpreter(std::vector<Instruction> in) : instructions(std::move(in)) {
|
|
for (Instruction &instruction : instructions) {
|
|
if (instruction.instruction == "return") {
|
|
if (instruction.args.empty()) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
if (std::holds_alternative<Instruction>(instruction.args[0])) {
|
|
instruction.args[0] = interpretInstruction(std::get<Instruction>(instruction.args[0]));
|
|
}
|
|
returnValue = std::get<Value>(instruction.args[0]);
|
|
return;
|
|
}
|
|
returnValue = interpretInstruction(instruction);
|
|
}
|
|
}
|
|
Interpreter() = default;
|
|
};
|
|
|
|
class CppTranspiler {
|
|
std::vector<Instruction> instructions;
|
|
std::map<std::string, Function> functions;
|
|
std::map<std::string, Value> environment;
|
|
std::vector<std::string> headers;
|
|
std::vector<std::string> body;
|
|
std::vector<std::string> tail;
|
|
int fnAmount = 0;
|
|
|
|
void validateFunctionCall(const std::string& name, const std::vector<std::variant<Value, std::string>>& args) {
|
|
// Check if function exists
|
|
if (functions.find(name) == functions.end()) {
|
|
throw CTranspilerError(CTranspilerErrorType::UnknownEnvironment);
|
|
}
|
|
|
|
Function& func = functions[name];
|
|
|
|
// Check argument count
|
|
if (args.size() != func.arguments.size()) {
|
|
std::cerr << "Function '" << name << "' expects "
|
|
<< func.arguments.size() << " arguments but got "
|
|
<< args.size() << std::endl;
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
// Check argument types (if we know them at compile time)
|
|
for (size_t i = 0; i < args.size(); i++) {
|
|
if (std::holds_alternative<Value>(args[i])) {
|
|
Value argVal = std::get<Value>(args[i]);
|
|
ValueTypes expectedType = func.arguments[i].second;
|
|
|
|
// Only validate if it's a literal value (not an identifier or expression)
|
|
if (argVal.type != ValueTypes::Identifier && argVal.type != expectedType) {
|
|
std::cerr << "Function '" << name << "' argument " << i
|
|
<< " ('" << func.arguments[i].first << "') expects type "
|
|
<< static_cast<int>(expectedType) << " but got "
|
|
<< static_cast<int>(argVal.type) << std::endl;
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string compileFunction(const Instruction &instruction) {
|
|
std::stringstream functionss;
|
|
Function function;
|
|
|
|
auto returnTypeValue = std::get<Value>(instruction.args[0]);
|
|
if (returnTypeValue.type != ValueTypes::Type) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
ValueTypes returnType = returnTypeValue.getType().value();
|
|
std::vector<std::pair<std::string, ValueTypes>> args;
|
|
|
|
int argAmount = 0;
|
|
if (std::holds_alternative<Value>(instruction.args[1]) &&
|
|
std::get<Value>(instruction.args[1]).type == ValueTypes::Identifier &&
|
|
std::get<Value>(instruction.args[1]).getString().value() != "[") {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
// Parse arguments
|
|
for (int i = 2; i < instruction.args.size(); i += 2) {
|
|
Value argTypeVal = std::get<Value>(instruction.args[i]);
|
|
if (argTypeVal.type != ValueTypes::Type) {
|
|
if (argTypeVal.type == ValueTypes::Identifier &&
|
|
argTypeVal.getString().value() == "]") {
|
|
break;
|
|
}
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
ValueTypes argType = argTypeVal.getType().value();
|
|
|
|
if (std::holds_alternative<Instruction>(instruction.args[i + 1])) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
Value argNameVal = std::get<Value>(instruction.args[i + 1]);
|
|
if (argNameVal.type != ValueTypes::Identifier) {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
std::string argName = argNameVal.getString().value();
|
|
|
|
args.emplace_back(argName, argType);
|
|
argAmount += 2;
|
|
}
|
|
|
|
std::vector<Instruction> body;
|
|
for (int i = argAmount + 3; i < instruction.args.size(); i++) {
|
|
if (std::holds_alternative<Instruction>(instruction.args[i])) {
|
|
body.push_back(std::get<Instruction>(instruction.args[i]));
|
|
} else {
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
|
|
// Store in function object
|
|
function.returnType = returnType;
|
|
function.arguments = args;
|
|
function.code = body;
|
|
|
|
// Generate C++ code
|
|
std::string returntype;
|
|
switch (returnType) {
|
|
case ValueTypes::Int:
|
|
returntype = "int";
|
|
break;
|
|
case ValueTypes::Double:
|
|
returntype = "double";
|
|
break;
|
|
case ValueTypes::String:
|
|
returntype = "std::string";
|
|
break;
|
|
default:
|
|
std::cout << "that's not currently supported" << std::endl;
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
bool first = true;
|
|
std::stringstream argss;
|
|
for (const auto& arg : function.arguments) {
|
|
if (!first) {
|
|
argss << ", ";
|
|
}
|
|
first = false;
|
|
|
|
switch (arg.second) {
|
|
case ValueTypes::Int:
|
|
argss << "int " << arg.first;
|
|
break;
|
|
case ValueTypes::Double:
|
|
argss << "double " << arg.first;
|
|
break;
|
|
case ValueTypes::String:
|
|
argss << "std::string " << arg.first;
|
|
break;
|
|
default:
|
|
std::cout << "that's not currently supported" << std::endl;
|
|
throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
|
|
functionss << "[](" << argss.str() << ") -> " << returntype << " {\n";
|
|
for (const auto& inst : function.code) {
|
|
functionss << " " << compileInstruction(inst) << ";\n";
|
|
}
|
|
functionss << "}";
|
|
|
|
return functionss.str();
|
|
}
|
|
std::string compileInstruction(const Instruction &instruction) {
|
|
// the value is for values being held, the std::string is for compiled instructions
|
|
std::vector<std::variant<Value, std::string>> args;
|
|
for (const auto &arg : instruction.args) {
|
|
if (std::holds_alternative<Instruction>(arg)) {
|
|
args.emplace_back("(" + compileInstruction(std::get<Instruction>(arg)) + ")");
|
|
}
|
|
if (std::holds_alternative<Value>(arg)) {
|
|
args.emplace_back(std::get<Value>(arg));
|
|
}
|
|
}
|
|
if (functions.find(instruction.instruction) != functions.end()) {
|
|
// Validate the call
|
|
validateFunctionCall(instruction.instruction, args);
|
|
|
|
// Compile the call
|
|
std::stringstream call;
|
|
call << instruction.instruction << "(";
|
|
bool first = true;
|
|
for (const auto& arg : args) {
|
|
if (!first) call << ", ";
|
|
first = false;
|
|
|
|
if (std::holds_alternative<std::string>(arg)) {
|
|
call << std::get<std::string>(arg);
|
|
} else {
|
|
Value v = std::get<Value>(arg);
|
|
if (v.type == ValueTypes::String) {
|
|
call << "\"" << v.getString().value() << "\"";
|
|
} else if (v.type == ValueTypes::Int) {
|
|
call << v.getInt().value();
|
|
} else if (v.type == ValueTypes::Double) {
|
|
call << v.getDouble().value();
|
|
} else if (v.type == ValueTypes::Identifier) {
|
|
call << v.getString().value();
|
|
}
|
|
}
|
|
}
|
|
call << ")";
|
|
return call.str();
|
|
}
|
|
if (instruction.instruction == "let") {
|
|
if (args.size() < 2) {
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
if (!std::holds_alternative<Value>(args[0])) {
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
Value nameVal = std::get<Value>(args[0]);
|
|
if (nameVal.type != ValueTypes::Identifier) {
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
std::string varName = nameVal.getString().value();
|
|
|
|
// Check if it's a function definition
|
|
if (std::holds_alternative<std::string>(args[1])) {
|
|
std::string compiled = std::get<std::string>(args[1]);
|
|
// Check if the original instruction.args[1] was a function
|
|
if (std::holds_alternative<Instruction>(instruction.args[1])) {
|
|
Instruction funcInst = std::get<Instruction>(instruction.args[1]);
|
|
if (funcInst.instruction == "function") {
|
|
// Extract the function signature and store it
|
|
Function func;
|
|
auto returnTypeValue = std::get<Value>(funcInst.args[0]);
|
|
func.returnType = returnTypeValue.getType().value();
|
|
|
|
// Parse arguments
|
|
int argAmount = 0;
|
|
for (int i = 2; i < funcInst.args.size(); i += 2) {
|
|
Value argTypeVal = std::get<Value>(funcInst.args[i]);
|
|
if (argTypeVal.type != ValueTypes::Type) {
|
|
if (argTypeVal.type == ValueTypes::Identifier &&
|
|
argTypeVal.getString().value() == "]") {
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
ValueTypes argType = argTypeVal.getType().value();
|
|
Value argNameVal = std::get<Value>(funcInst.args[i + 1]);
|
|
std::string argName = argNameVal.getString().value();
|
|
|
|
func.arguments.emplace_back(argName, argType);
|
|
argAmount += 2;
|
|
}
|
|
|
|
// Store the function signature
|
|
functions[varName] = func;
|
|
}
|
|
}
|
|
|
|
return "auto " + varName + " = " + compiled;
|
|
}
|
|
|
|
std::stringstream code;
|
|
|
|
code << "auto ";
|
|
if (std::holds_alternative<Value>(args[0]) && std::get<Value>(args[0]).type == ValueTypes::Identifier) {
|
|
code << std::get<Value>(args[0]).getString().value() << " = ";
|
|
} else {
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
|
|
if (std::holds_alternative<Value>(args[1])) {
|
|
code << std::get<Value>(args[1]);
|
|
}
|
|
if (std::holds_alternative<std::string>(args[1])) {
|
|
code << std::get<std::string>(args[1]);
|
|
}
|
|
|
|
return code.str();
|
|
}
|
|
if (instruction.instruction == "function") {
|
|
if (std::ranges::find(headers, "functional") == headers.end()) {
|
|
headers.emplace_back("functional");
|
|
}
|
|
return compileFunction(instruction);
|
|
}
|
|
if (instruction.instruction == "return") {
|
|
if (!args.empty()) {
|
|
if (std::holds_alternative<Value>(args[0])) {
|
|
Value value = std::get<Value>(args[0]);
|
|
if (value.type == ValueTypes::Int) {
|
|
return "return " + std::to_string(value.getInt().value());
|
|
} else {
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
if (std::holds_alternative<std::string>(args[0])) {
|
|
return "return(" + std::get<std::string>(args[0]) + ")";
|
|
}
|
|
} else {
|
|
throw CTranspilerError(CTranspilerErrorType::IncorrectTokenType);
|
|
}
|
|
}
|
|
if (instruction.instruction == "print") {
|
|
std::stringstream retval;
|
|
if (std::ranges::find(headers, "iostream") == headers.end()) {
|
|
headers.emplace_back("iostream");
|
|
}
|
|
for (const auto &arg : args) {
|
|
if (std::holds_alternative<std::string>(arg)) {
|
|
retval << "std::cout << " << std::get<std::string>(arg) << " << \"\\n\"";
|
|
}
|
|
if (std::holds_alternative<Value>(arg)) {
|
|
if (std::get<Value>(arg).type == ValueTypes::String) {
|
|
retval << "std::cout << \"" << std::get<Value>(arg) << "\" << \"\\n\"";
|
|
} else {
|
|
retval << "std::cout << " << std::get<Value>(arg) << " << \"\\n\"";
|
|
}
|
|
}
|
|
}
|
|
return retval.str();
|
|
}
|
|
throw InterpretingError(InterpreterErrorType::UnknownInstruction);
|
|
}
|
|
|
|
public:
|
|
std::string createCppFile() const {
|
|
std::stringstream cpp;
|
|
cpp << "// Autogenerated by the Pipple compiler.\n// Headers\n";
|
|
for (const auto &header : headers) {
|
|
cpp << "#include <" << header << ">\n";
|
|
}
|
|
cpp << "\n// Code\n";
|
|
for (const auto &body : body) {
|
|
cpp << body << "\n";
|
|
}
|
|
for (const auto &tail : tail) {
|
|
cpp << tail << "\n";
|
|
}
|
|
return cpp.str();
|
|
|
|
}
|
|
void addInstruction(const Instruction &instruction) {
|
|
body.emplace_back(compileInstruction(instruction) + ";");
|
|
}
|
|
explicit CppTranspiler(std::vector<Instruction> in) : instructions(std::move(in)) {
|
|
for (Instruction &instruction : instructions) {
|
|
body.push_back(compileInstruction(instruction));
|
|
}
|
|
std::cout << createCppFile() << std::endl;
|
|
}
|
|
CppTranspiler() {
|
|
headers = {};
|
|
body = {
|
|
"void* nil = nullptr;",
|
|
"int main(int argc, char** argv) {",
|
|
};
|
|
tail = {
|
|
"}"
|
|
};
|
|
}
|
|
};
|
|
|
|
int main(int argc, char** argv) {
|
|
bool isInteractive = true;
|
|
bool compiling = false;
|
|
std::string program;
|
|
if (argc > 1) {
|
|
int fileNum = 1;
|
|
if (strcmp(argv[1], "-c") == 0) {
|
|
fileNum = 2;
|
|
compiling = true;
|
|
}
|
|
isInteractive = false;
|
|
std::ifstream ifs(argv[fileNum]);
|
|
std::stringstream buffer;
|
|
if (ifs.is_open()) {
|
|
buffer << ifs.rdbuf();
|
|
}
|
|
program = buffer.str();
|
|
}
|
|
linenoise::SetMultiLine(true);
|
|
linenoise::SetHistoryMaxLen(50);
|
|
Parser parser;
|
|
Interpreter interpreter;
|
|
CppTranspiler transpiler;
|
|
while (true) {
|
|
if (isInteractive) {
|
|
if (linenoise::Readline("pipple> ", program)) {
|
|
return 0;
|
|
}
|
|
}
|
|
try {
|
|
parser = Parser(program);
|
|
} catch (const ParsingError& e) {
|
|
std::cerr << "Parse error: " << e.what() << std::endl;
|
|
|
|
// Show code context
|
|
const std::string& source = e.getSourceCode();
|
|
if (!source.empty()) {
|
|
int pos = e.getPosition();
|
|
|
|
// Calculate character position in source from token position
|
|
int charPos = 0;
|
|
int tokenCount = 0;
|
|
bool inString = false;
|
|
|
|
for (size_t i = 0; i < source.length() && tokenCount < pos; i++) {
|
|
char c = source[i];
|
|
if (c == '"') inString = !inString;
|
|
if (!inString && (c == '(' || c == ')' || c == ' ' || c == '\n')) {
|
|
if (i > 0 && source[i-1] != ' ' && source[i-1] != '\n' && source[i-1] != '(' && source[i-1] != ')') {
|
|
tokenCount++;
|
|
}
|
|
if (c == '(' || c == ')') tokenCount++;
|
|
}
|
|
charPos = static_cast<int>(i);
|
|
}
|
|
|
|
// Show context (30 chars before and after)
|
|
int start = std::max(0, charPos - 30);
|
|
int end = std::min(static_cast<int>(source.length()), charPos + 30);
|
|
|
|
std::cerr << "\nCode context:\n";
|
|
if (start > 0) std::cerr << "...";
|
|
std::cerr << source.substr(start, end - start);
|
|
if (end < static_cast<int>(source.length())) std::cerr << "...";
|
|
std::cerr << "\n";
|
|
|
|
// Show pointer to error position
|
|
int pointerPos = (start > 0 ? 3 : 0) + (charPos - start);
|
|
std::cerr << std::string(pointerPos, ' ') << "^\n";
|
|
}
|
|
|
|
if (!isInteractive) return 1;
|
|
continue;
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Unexpected error: " << e.what() << std::endl;
|
|
if (!isInteractive) return 1;
|
|
}
|
|
try {
|
|
if (compiling) {
|
|
for (const auto &instruction : parser.instructions) {
|
|
transpiler.addInstruction(instruction);
|
|
}
|
|
|
|
} else {
|
|
for (auto instruction : parser.instructions) {
|
|
interpreter.interpretInstruction(instruction);
|
|
}
|
|
}
|
|
} catch (const InterpretingError& e) {
|
|
std::cerr << e.what() << std::endl;
|
|
if (!isInteractive) return 1;
|
|
}
|
|
if (!isInteractive) {
|
|
break;
|
|
}
|
|
}
|
|
if (compiling) {
|
|
std::cout << transpiler.createCppFile() << std::endl;
|
|
}
|
|
return 0;
|
|
}
|