790 lines
27 KiB
C++
790 lines
27 KiB
C++
|
#include <iostream>
|
||
|
|
#include <utility>
|
||
|
|
#include <vector>
|
||
|
|
#include <optional>
|
||
|
|
#include <variant>
|
||
|
|
#include <cctype>
|
||
|
|
#include <complex>
|
||
|
|
#include <sstream>
|
||
|
|
#include <map>
|
||
|
|
#include "../libs/linenoise.hpp"
|
||
|
|
|
||
|
|
enum class ValueTypes {
|
||
|
|
Identifier, Int, Double, String, List, Nil
|
||
|
|
};
|
||
|
|
|
||
|
|
enum class ParserErrorType {
|
||
|
|
UnexpectedEndOfInput,
|
||
|
|
UnexpectedToken,
|
||
|
|
MissingOpenParen,
|
||
|
|
MissingCloseParen,
|
||
|
|
UnexpectedTopLevelToken
|
||
|
|
};
|
||
|
|
|
||
|
|
enum class InterpreterErrorType {
|
||
|
|
UnknownInstruction,
|
||
|
|
UnexpectedToken,
|
||
|
|
IncorrectTokenType,
|
||
|
|
MathError,
|
||
|
|
UnknownEnvironment
|
||
|
|
};
|
||
|
|
|
||
|
|
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 Value {
|
||
|
|
std::variant<int, double, std::string, void*, std::vector<Value>> value;
|
||
|
|
public:
|
||
|
|
ValueTypes type;
|
||
|
|
std::optional<int> getInt() {
|
||
|
|
if (std::holds_alternative<int>(value)) {
|
||
|
|
return std::get<int>(value);
|
||
|
|
}
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
std::optional<double> getDouble() {
|
||
|
|
if (std::holds_alternative<double>(value)) {
|
||
|
|
return std::get<double>(value);
|
||
|
|
}
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
std::optional<std::string> getString() {
|
||
|
|
if (std::holds_alternative<std::string>(value)) {
|
||
|
|
return std::get<std::string>(value);
|
||
|
|
}
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
std::optional<std::vector<Value>> getList() {
|
||
|
|
if (std::holds_alternative<std::vector<Value>>(value)) {
|
||
|
|
return std::get<std::vector<Value>>(value);
|
||
|
|
}
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
void print() {
|
||
|
|
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();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
case ValueTypes::Nil: {
|
||
|
|
std::cout << "\033[2;3;96m" << "nil" << "\033[0m";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
bool operator==(Value &otherValue) {
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
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) {}
|
||
|
|
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();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 ')': {
|
||
|
|
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 = {};
|
||
|
|
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") {
|
||
|
|
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();
|
||
|
|
}
|
||
|
|
// 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
|
||
|
|
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 == "input") {
|
||
|
|
std::string input;
|
||
|
|
linenoise::Readline("", input);
|
||
|
|
return Value(input);
|
||
|
|
}
|
||
|
|
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) {
|
||
|
|
interpretInstruction(instruction);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Interpreter() = default;
|
||
|
|
};
|
||
|
|
|
||
|
|
int main(int argc, char** argv) {
|
||
|
|
bool isInteractive = true;
|
||
|
|
std::string program;
|
||
|
|
if (argc > 1) {
|
||
|
|
isInteractive = false;
|
||
|
|
std::ifstream ifs(argv[1]);
|
||
|
|
std::stringstream buffer;
|
||
|
|
if (ifs.is_open()) {
|
||
|
|
buffer << ifs.rdbuf();
|
||
|
|
}
|
||
|
|
program = buffer.str();
|
||
|
|
}
|
||
|
|
linenoise::SetMultiLine(true);
|
||
|
|
linenoise::SetHistoryMaxLen(50);
|
||
|
|
Parser parser;
|
||
|
|
Interpreter interpreter;
|
||
|
|
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 {
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|