vaclavt
/
mlisp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
mlisp/ml.cpp

1881 lines
64 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// LANGUAGE OPTIONS ///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Comment this define out to drop support for libm functions
#ifdef HAS_LIBM
#include <cmath>
#else
#define NO_LIBM_SUPPORT "no libm support"
#endif
// Comment this define out to drop support for standard library functions.
// This allows the program to run without a runtime.
#define USE_STD
#ifdef USE_STD
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <ctime>
#include <regex>
std::string read_file_contents(std::string filename) {
std::ifstream f;
f.open(filename.c_str());
if (!f)
throw std::runtime_error("could not open file");
f.seekg(0, std::ios::end);
std::string contents;
contents.reserve(f.tellg());
f.seekg(0, std::ios::beg);
contents.assign(std::istreambuf_iterator<char>(f),
std::istreambuf_iterator<char>());
f.close();
return contents;
}
#else
#define NO_STD "no standard library support"
#endif
////////////////////////////////////////////////////////////////////////////////
/// REQUIRED INCLUDES //////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#include <map>
#include <string>
#include <vector>
#include <sstream>
#include <exception>
#include "csvparser.h"
#include "sslclient.h"
////////////////////////////////////////////////////////////////////////////////
/// ERROR MESSAGES /////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#define TOO_FEW_ARGS "too few arguments to function"
#define TOO_MANY_ARGS "too many arguments to function"
#define INVALID_ARGUMENT "invalid argument"
#define MISMATCHED_TYPES "mismatched types"
#define CALL_NON_FUNCTION "called non-function"
#define UNKNOWN_ERROR "unknown exception"
#define INVALID_LAMBDA "invalid lambda"
#define INVALID_BIN_OP "invalid binary operation"
#define INVALID_ORDER "cannot order expression"
#define BAD_CAST "cannot cast"
#define ATOM_NOT_DEFINED "atom not defined"
#define EVAL_EMPTY_LIST "evaluated empty list"
#define INTERNAL_ERROR "interal virtual machine error"
#define INDEX_OUT_OF_RANGE "index out of range"
#define MALFORMED_PROGRAM "malformed program"
////////////////////////////////////////////////////////////////////////////////
/// TYPE NAMES /////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#define STRING_TYPE "string"
#define INT_TYPE "int"
#define FLOAT_TYPE "float"
#define UNIT_TYPE "unit"
#define FUNCTION_TYPE "function"
#define ATOM_TYPE "atom"
#define QUOTE_TYPE "quote"
#define LIST_TYPE "list"
////////////////////////////////////////////////////////////////////////////////
/// HELPER FUNCTIONS ///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Convert an object to a string using a stringstream conveniently
#define to_string( x ) static_cast<std::ostringstream>((std::ostringstream() << std::dec << x )).str()
// Replace a substring with a replacement string in a source string
void replace_substring(std::string &src, std::string substr, std::string replacement) {
size_t i=0;
for (i=src.find(substr, i); i!=std::string::npos; i=src.find(substr, i)) {
src.replace(i, substr.size(), replacement);
i += replacement.size();
}
}
// Is this character a valid lisp symbol character
bool is_symbol(char ch) {
return (isalpha(ch) || ispunct(ch)) && ch != '(' && ch != ')' && ch != '"' && ch != '\'';
}
// std::regex int_underscored_regex("[0-9][0-9_]+[0-9]");
std::regex int_regex("[0-9]+");
std::regex double_regex("[0-9]+\\.[0-9]+");
// Is string representing int value
bool is_string_int(const std::string &str) {
return std::regex_match(str, int_regex);
}
// Is string representing float value
bool is_string_float(const std::string &str) {
return std::regex_match(str, double_regex);
}
////////////////////////////////////////////////////////////////////////////////
/// LISP CONSTRUCTS ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Forward declaration for Environment class definition
class Value;
// An instance of a function's scope.
class Environment {
public:
// Default constructor
Environment() : parent_scope(NULL) {}
// Does this environment, or its parent environment,
// have this atom in scope?
// This is only used to determine which atoms to capture when
// creating a lambda function.
bool has(std::string name) const;
// Get the value associated with this name in this scope
Value get(std::string name) const;
// Set the value associated with this name in this scope
void set(std::string name, Value value);
void combine(Environment const &other);
void set_parent_scope(Environment *parent) {
parent_scope = parent;
}
// Output this scope in readable form to a stream.
friend std::ostream &operator<<(std::ostream &os, Environment const &v);
private:
// The definitions in the scope.
std::map<std::string, Value> defs;
Environment *parent_scope;
};
// An exception thrown by the lisp
class Error {
public:
// Create an error with the value that caused the error,
// the scope where the error was found, and the message.
Error(const Value &v, Environment const &env, const char *msg);
// Copy constructor is needed to prevent double frees
Error(Error const &other);
~Error();
// Get the printable error description.
std::string description();
private:
Value *cause;
Environment env;
const char *msg;
};
// The type for a builtin function, which takes a list of values,
// and the environment to run the function in.
typedef Value (*Builtin)(std::vector<Value>, Environment &);
class Value {
public:
////////////////////////////////////////////////////////////////////////////////
/// CONSTRUCTORS ///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Constructs a unit value
Value() : type(UNIT) {}
// Constructs an integer
Value(int i) : type(INT) { stack_data.i = i; }
// Constructs a floating point value
Value(double f) : type(FLOAT) { stack_data.f = f; }
// Constructs a list
Value(const std::vector<Value> &list) : type(LIST), list(list) {}
// Construct a quoted value
static Value quote(Value quoted) {
Value result;
result.type = QUOTE;
// The first position in the list is
// used to store the quoted expression.
result.list.push_back(quoted);
return result;
}
// Construct an atom
static Value atom(const std::string &s) {
Value result;
result.type = ATOM;
// We use the `str` member to store the atom.
result.str = s;
return result;
}
// Construct a string
static Value string(const std::string &s) {
Value result;
result.type = STRING;
// We use the `str` member to store the string.
result.str = s;
return result;
}
// Construct a lambda function
Value(const std::vector<Value> &params, Value ret, Environment const &env) : type(LAMBDA) {
// We store the params and the result in the list member
// instead of having dedicated members. This is to save memory.
list.push_back(Value(params));
list.push_back(ret);
// Lambdas capture only variables that they know they will use.
std::vector<std::string> used_atoms = ret.get_used_atoms();
for (size_t i=0; i<used_atoms.size(); i++) {
// If the environment has a symbol that this lambda uses, capture it.
if (env.has(used_atoms[i]))
lambda_scope.set(used_atoms[i], env.get(used_atoms[i]));
}
}
// Construct a builtin function
Value(const std::string &name, Builtin b) : type(BUILTIN) {
// Store the name of the builtin function in the str member
// to save memory, and use the builtin function slot in the union
// to store the function pointer.
str = name;
stack_data.b = b;
}
////////////////////////////////////////////////////////////////////////////////
/// C++ INTEROP METHODS ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Get all of the atoms used in a given Value
std::vector<std::string> get_used_atoms() {
std::vector<std::string> result, tmp;
switch (type) {
case QUOTE:
// The data for a quote is stored in the
// first slot of the list member.
return list[0].get_used_atoms();
case ATOM:
// If this is an atom, add it to the list
// of used atoms in this expression.
result.push_back(as_atom());
return result;
case LAMBDA:
// If this is a lambda, get the list of used atoms in the body
// of the expression.
return list[1].get_used_atoms();
case LIST:
// If this is a list, add each of the atoms used in all
// of the elements in the list.
for (size_t i=0; i<list.size(); i++) {
// Get the atoms used in the element
tmp = list[i].get_used_atoms();
// Add the used atoms to the current list of used atoms
result.insert(result.end(), tmp.begin(), tmp.end());
}
return result;
default:
return result;
}
}
// Is this a builtin function?
bool is_builtin() {
return type == BUILTIN;
}
// Apply this as a function to a list of arguments in a given environment.
Value apply(std::vector<Value> args, Environment &env);
// Evaluate this value as lisp code.
Value eval(Environment &env);
bool is_number() const {
return type == INT || type == FLOAT;
}
// Get the "truthy" boolean value of this value.
bool as_bool() const {
return *this != Value(0);
}
// Get this item's integer value
int as_int() const {
return cast_to_int().stack_data.i;
}
// Get this item's floating point value
double as_float() const {
return cast_to_int().stack_data.f;
}
// Get this item's string value
std::string as_string() const {
// If this item is not a string, throw a cast error.
if (type != STRING)
throw Error(*this, Environment(), BAD_CAST);
return str;
}
// Get this item's atom value
std::string as_atom() const {
// If this item is not an atom, throw a cast error.
if (type != ATOM)
throw Error(*this, Environment(), BAD_CAST);
return str;
}
// Get this item's list value
std::vector<Value> as_list() const {
// If this item is not a list, throw a cast error.
if (type != LIST)
throw Error(*this, Environment(), BAD_CAST);
return list;
}
// Push an item to the end of this list
void push(Value val) {
// If this item is not a list, you cannot push to it.
// Throw an error.
if (type != LIST)
throw Error(*this, Environment(), MISMATCHED_TYPES);
list.push_back(val);
}
// Push an item from the end of this list
Value pop() {
// If this item is not a list, you cannot pop from it.
// Throw an error.
if (type != LIST)
throw Error(*this, Environment(), MISMATCHED_TYPES);
// Remember the last item in the list
Value result = list[list.size()-1];
// Remove it from this instance
list.pop_back();
// Return the remembered value
return result;
}
////////////////////////////////////////////////////////////////////////////////
/// TYPECASTING METHODS ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Cast this to an integer value
Value cast_to_int() const {
switch (type) {
case INT: return *this;
case FLOAT: return Value(int(stack_data.f));
// Only ints and floats can be cast to an int
default:
throw Error(*this, Environment(), BAD_CAST);
}
}
// Cast this to a floating point value
Value cast_to_float() const {
switch (type) {
case FLOAT: return *this;
case INT: return Value(float(stack_data.i));
// Only ints and floats can be cast to a float
default:
throw Error(*this, Environment(), BAD_CAST);
}
}
////////////////////////////////////////////////////////////////////////////////
/// COMPARISON OPERATIONS //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
bool operator==(Value other) const {
// If either of these values are floats, promote the
// other to a float, and then compare for equality.
if (type == FLOAT && other.type == INT) return *this == other.cast_to_float();
else if (type == INT && other.type == FLOAT) return this->cast_to_float() == other;
// If the values types aren't equal, then they cannot be equal.
else if (type != other.type) return false;
switch (type) {
case FLOAT:
return stack_data.f == other.stack_data.f;
case INT:
return stack_data.i == other.stack_data.i;
case BUILTIN:
return stack_data.b == other.stack_data.b;
case STRING:
case ATOM:
// Both atoms and strings store their
// data in the str member.
return str == other.str;
case LAMBDA:
case LIST:
// Both lambdas and lists store their
// data in the list member.
return list == other.list;
case QUOTE:
// The values for quotes are stored in the
// first slot of the list member.
return list[0] == other.list[0];
default:
return true;
}
}
bool operator!=(const Value &other) const {
return !(*this == other);
}
////////////////////////////////////////////////////////////////////////////////
/// ORDERING OPERATIONS ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
bool operator>=(const Value &other) const {
return !(*this < other);
}
bool operator<=(const Value &other) const {
return (*this == other) || (*this < other);
}
bool operator>(const Value &other) const {
return !(*this <= other);
}
bool operator<(const Value &other) const {
// Other type must be a float or an int
if (other.type != FLOAT && other.type != INT)
throw Error(*this, Environment(), INVALID_BIN_OP);
switch (type) {
case FLOAT:
// If this is a float, promote the other value to a float and compare.
return stack_data.f < other.cast_to_float().stack_data.f;
case INT:
// If the other value is a float, promote this value to a float and compare.
if (other.type == FLOAT)
return cast_to_float().stack_data.f < other.stack_data.f;
// Otherwise compare the integer values
else return stack_data.i < other.stack_data.i;
default:
// Only allow comparisons between integers and floats
throw Error(*this, Environment(), INVALID_ORDER);
}
}
////////////////////////////////////////////////////////////////////////////////
/// ARITHMETIC OPERATIONS //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// This function adds two lisp values, and returns the lisp value result.
Value operator+(const Value &other) const {
// If the other value's type is the unit type,
// don't even bother continuing.
// Unit types consume all arithmetic operations.
if (other.type == UNIT) return other;
// Other type must be a float or an int
if ((is_number() || other.is_number()) &&
!(is_number() && other.is_number()))
throw Error(*this, Environment(), INVALID_BIN_OP);
switch (type) {
case FLOAT:
// If one is a float, promote the other by default and do
// float addition.
return Value(stack_data.f + other.cast_to_float().stack_data.f);
case INT:
// If the other type is a float, go ahead and promote this expression
// before continuing with the addition.
if (other.type == FLOAT)
return Value(cast_to_float() + other.stack_data.f);
// Otherwise, do integer addition.
else return Value(stack_data.i + other.stack_data.i);
case STRING:
// If the other value is also a string, do the concat
if (other.type == STRING)
return Value::string(str + other.str);
// We throw an error if we try to concat anything of non-string type
else throw Error(*this, Environment(), INVALID_BIN_OP);
case LIST:
// If the other value is also a list, do the concat
if (other.type == LIST) {
// Maintain the value that will be returned
Value result = *this;
// Add each item in the other list to the end of this list
for (size_t i=0; i<other.list.size(); i++)
result.push(other.list[i]);
return result;
} else throw Error(*this, Environment(), INVALID_BIN_OP);
case UNIT:
return *this;
default:
throw Error(*this, Environment(), INVALID_BIN_OP);
}
}
// This function subtracts two lisp values, and returns the lisp value result.
Value operator-(const Value &other) const {
// If the other value's type is the unit type,
// don't even bother continuing.
// Unit types consume all arithmetic operations.
if (other.type == UNIT) return other;
// Other type must be a float or an int
if (other.type != FLOAT && other.type != INT)
throw Error(*this, Environment(), INVALID_BIN_OP);
switch (type) {
case FLOAT:
// If one is a float, promote the other by default and do
// float subtraction.
return Value(stack_data.f - other.cast_to_float().stack_data.f);
case INT:
// If the other type is a float, go ahead and promote this expression
// before continuing with the subtraction
if (other.type == FLOAT)
return Value(cast_to_float().stack_data.f - other.stack_data.f);
// Otherwise, do integer subtraction.
else return Value(stack_data.i - other.stack_data.i);
case UNIT:
// Unit types consume all arithmetic operations.
return *this;
default:
// This operation was done on an unsupported type
throw Error(*this, Environment(), INVALID_BIN_OP);
}
}
// This function multiplies two lisp values, and returns the lisp value result.
Value operator*(const Value &other) const {
// If the other value's type is the unit type,
// don't even bother continuing.
// Unit types consume all arithmetic operations.
if (other.type == UNIT) return other;
// Other type must be a float or an int
if (other.type != FLOAT && other.type != INT)
throw Error(*this, Environment(), INVALID_BIN_OP);
switch (type) {
case FLOAT:
return Value(stack_data.f * other.cast_to_float().stack_data.f);
case INT:
// If the other type is a float, go ahead and promote this expression
// before continuing with the product
if (other.type == FLOAT)
return Value(cast_to_float().stack_data.f * other.stack_data.f);
// Otherwise, do integer multiplication.
else return Value(stack_data.i * other.stack_data.i);
case UNIT:
// Unit types consume all arithmetic operations.
return *this;
default:
// This operation was done on an unsupported type
throw Error(*this, Environment(), INVALID_BIN_OP);
}
}
// This function divides two lisp values, and returns the lisp value result.
Value operator/(const Value &other) const {
// If the other value's type is the unit type,
// don't even bother continuing.
// Unit types consume all arithmetic operations.
if (other.type == UNIT) return other;
// Other type must be a float or an int
if (other.type != FLOAT && other.type != INT)
throw Error(*this, Environment(), INVALID_BIN_OP);
switch (type) {
case FLOAT:
return Value(stack_data.f / other.cast_to_float().stack_data.f);
case INT:
// If the other type is a float, go ahead and promote this expression
// before continuing with the product
if (other.type == FLOAT)
return Value(cast_to_float().stack_data.f / other.stack_data.f);
// Otherwise, do integer multiplication.
else return Value(stack_data.i / other.stack_data.i);
case UNIT:
// Unit types consume all arithmetic operations.
return *this;
default:
// This operation was done on an unsupported type
throw Error(*this, Environment(), INVALID_BIN_OP);
}
}
// This function finds the remainder of two lisp values, and returns the lisp value result.
Value operator%(const Value &other) const {
// If the other value's type is the unit type,
// don't even bother continuing.
// Unit types consume all arithmetic operations.
if (other.type == UNIT) return other;
// Other type must be a float or an int
if (other.type != FLOAT && other.type != INT)
throw Error(*this, Environment(), INVALID_BIN_OP);
switch (type) {
// If we support libm, we can find the remainder of floating point values.
#ifdef HAS_LIBM
case FLOAT:
return Value(fmod(stack_data.f, other.cast_to_float().stack_data.f));
case INT:
if (other.type == FLOAT)
return Value(fmod(cast_to_float().stack_data.f, other.stack_data.f));
else return Value(stack_data.i % other.stack_data.i);
#else
case INT:
// If we do not support libm, we have to throw errors for floating point values.
if (other.type != INT)
throw Error(other, Environment(), NO_LIBM_SUPPORT);
return Value(stack_data.i % other.stack_data.i);
#endif
case UNIT:
// Unit types consume all arithmetic operations.
return *this;
default:
// This operation was done on an unsupported type
throw Error(*this, Environment(), INVALID_BIN_OP);
}
}
// Get the name of the type of this value
std::string get_type_name() {
switch (type) {
case QUOTE: return QUOTE_TYPE;
case ATOM: return ATOM_TYPE;
case INT: return INT_TYPE;
case FLOAT: return FLOAT_TYPE;
case LIST: return LIST_TYPE;
case STRING: return STRING_TYPE;
case BUILTIN:
case LAMBDA:
// Instead of differentiating between
// lambda and builtin types, we group them together.
// This is because they are both callable.
return FUNCTION_TYPE;
case UNIT:
return UNIT_TYPE;
default:
// We don't know the name of this type.
// This isn't the users fault, this is just unhandled.
// This should never be reached.
throw Error(*this, Environment(), INTERNAL_ERROR);
}
}
std::string display() const {
std::string result;
switch (type) {
case QUOTE:
return "'" + list[0].debug();
case ATOM:
return str;
case INT:
return to_string(stack_data.i);
case FLOAT:
return to_string(stack_data.f);
case STRING:
return str;
case LAMBDA:
for (size_t i=0; i<list.size(); i++) {
result += list[i].debug();
if (i < list.size()-1) result += " ";
}
return "(lambda " + result + ")";
case LIST:
for (size_t i=0; i<list.size(); i++) {
result += list[i].debug();
if (i < list.size()-1) result += " ";
}
return "(" + result + ")";
case BUILTIN:
return "<" + str + " at " + to_string(long(stack_data.b)) + ">";
case UNIT:
return "@";
default:
// We don't know how to display whatever type this is.
// This isn't the users fault, this is just unhandled.
// This should never be reached.
throw Error(*this, Environment(), INTERNAL_ERROR);
}
}
std::string debug() const {
std::string result;
switch (type) {
case QUOTE:
return "'" + list[0].debug();
case ATOM:
return str;
case INT:
return to_string(stack_data.i);
case FLOAT:
return to_string(stack_data.f);
case STRING:
for (size_t i=0; i<str.length(); i++) {
if (str[i] == '"') result += "\\\"";
else result.push_back(str[i]);
}
return "\"" + result + "\"";
case LAMBDA:
for (size_t i=0; i<list.size(); i++) {
result += list[i].debug();
if (i < list.size()-1) result += " ";
}
return "(lambda " + result + ")";
case LIST:
for (size_t i=0; i<list.size(); i++) {
result += list[i].debug();
if (i < list.size()-1) result += " ";
}
return "(" + result + ")";
case BUILTIN:
return "<" + str + " at " + to_string(long(stack_data.b)) + ">";
case UNIT:
return "@";
default:
// We don't know how to debug whatever type this is.
// This isn't the users fault, this is just unhandled.
// This should never be reached.
throw Error(*this, Environment(), INTERNAL_ERROR);
}
}
friend std::ostream &operator<<(std::ostream &os, Value const &v) {
return os << v.display();
}
private:
enum {
QUOTE,
ATOM,
INT,
FLOAT,
LIST,
STRING,
LAMBDA,
BUILTIN,
UNIT
} type;
union {
int i;
double f;
Builtin b;
} stack_data;
std::string str;
std::vector<Value> list;
Environment lambda_scope;
};
Error::Error(const Value &v, Environment const &env, const char *msg) : env(env), msg(msg) {
cause = new Value;
*cause = v;
}
Error::Error(Error const &other) : env(other.env), msg(other.msg) {
cause = new Value(*other.cause);
}
Error::~Error() {
delete cause;
}
std::string Error::description() {
return "error: the expression `" + cause->debug() + "` failed in scope " + to_string(env) + " with message \"" + msg + "\"";
}
void Environment::combine(Environment const &other) {
// Normally, I would use the `insert` method of the `map` class,
// but it doesn't overwrite previously declared values for keys.
std::map<std::string, Value>::const_iterator itr = other.defs.begin();
for (; itr!=other.defs.end(); itr++) {
// Iterate through the keys and assign each value.
defs[itr->first] = itr->second;
}
}
std::ostream &operator<<(std::ostream &os, Environment const &e) {
std::map<std::string, Value>::const_iterator itr = e.defs.begin();
os << "{ ";
for (; itr != e.defs.end(); itr++) {
os << '\'' << itr->first << "' : " << itr->second.debug() << ", ";
}
return os << "}";
}
void Environment::set(std::string name, Value value) {
defs[name] = value;
}
Value Value::apply(std::vector<Value> args, Environment &env) {
Environment e;
std::vector<Value> params;
switch (type) {
case LAMBDA:
// Get the list of parameter atoms
params = list[0].list;
if (params.size() != args.size())
throw Error(Value(args), env, args.size() > params.size()?
TOO_MANY_ARGS : TOO_FEW_ARGS
);
// Get the captured scope from the lambda
e = lambda_scope;
// And make this scope the parent scope
e.set_parent_scope(&env);
// Iterate through the list of parameters and
// insert the arguments into the scope.
for (size_t i=0; i<params.size(); i++) {
if (params[i].type != ATOM)
throw Error(*this, env, INVALID_LAMBDA);
// Set the parameter name into the scope.
e.set(params[i].str, args[i]);
}
// Evaluate the function body with the function scope
return list[1].eval(e);
case BUILTIN:
// Here, we call the builtin function with the current scope.
// This allows us to write special forms without syntactic sugar.
// For functions that are not special forms, we just evaluate
// the arguments before we run the function.
return (stack_data.b)(args, env);
default:
// We can only call lambdas and builtins
throw Error(*this, env, CALL_NON_FUNCTION);
}
}
Value Value::eval(Environment &env) {
std::vector<Value> args;
Value function;
Environment e;
switch (type) {
case QUOTE:
return list[0];
case ATOM:
return env.get(str);
case LIST:
if (list.size() < 1)
throw Error(*this, env, EVAL_EMPTY_LIST);
args = std::vector<Value>(list.begin() + 1, list.end());
// Only evaluate our arguments if it's not builtin!
// Builtin functions can be special forms, so we
// leave them to evaluate their arguments.
function = list[0].eval(env);
if (!function.is_builtin())
for (size_t i=0; i<args.size(); i++)
args[i] = args[i].eval(env);
return function.apply(
args,
env
);
default:
return *this;
}
}
void skip_whitespace(const std::string &s, int &ptr) {
while (isspace(s[ptr])) { ptr++; }
}
// Parse a single value and increment the pointer
// to the beginning of the next value to parse.
Value parse(std::string &s, int &ptr) {
skip_whitespace(s, ptr);
while (s[ptr] == ';') {
// If this is a comment
int save_ptr = ptr;
while (s[save_ptr] != '\n' && save_ptr < int(s.length())) { save_ptr++; }
s.erase(ptr, save_ptr - ptr);
skip_whitespace(s, ptr);
if (s.substr(ptr, s.length()-ptr-1) == "")
return Value();
}
if (s == "") {
return Value();
} else if (s[ptr] == '\'') {
// If this is a quote
ptr++;
return Value::quote(parse(s, ptr));
} else if (s[ptr] == '(') {
// If this is a list
skip_whitespace(s, ++ptr);
Value result = Value(std::vector<Value>());
while (s[ptr] != ')')
result.push(parse(s, ptr));
skip_whitespace(s, ++ptr);
return result;
} else if (isdigit(s[ptr]) || (s[ptr] == '-' && isdigit(s[ptr + 1]))) {
// If this is a number
bool negate = s[ptr] == '-';
if (negate) ptr++;
int save_ptr = ptr;
while (isdigit(s[ptr]) || s[ptr] == '.') ptr++;
std::string n = s.substr(save_ptr, ptr);
skip_whitespace(s, ptr);
if (n.find('.') != std::string::npos)
return Value((negate? -1 : 1) * atof(n.c_str()));
else return Value((negate? -1 : 1) * atoi(n.c_str()));
} else if (s[ptr] == '\"') {
// If this is a string
int n = 1;
while (s[ptr + n] != '\"') {
if (ptr + n >= int(s.length()))
throw std::runtime_error(MALFORMED_PROGRAM);
if (s[ptr + n] == '\\') n++;
n++;
}
std::string x = s.substr(ptr+1, n-1);
ptr += n+1;
skip_whitespace(s, ptr);
// Iterate over the characters in the string, and
// replace escaped characters with their intended values.
for (size_t i=0; i<x.size(); i++) {
if (x[i] == '\\' && x[i+1] == '\\')
x.replace(i, 2, "\\");
else if (x[i] == '\\' && x[i+1] == '"')
x.replace(i, 2, "\"");
else if (x[i] == '\\' && x[i+1] == 'n')
x.replace(i, 2, "\n");
else if (x[i] == '\\' && x[i+1] == 't')
x.replace(i, 2, "\t");
}
return Value::string(x);
} else if (s[ptr] == '@') {
ptr++;
skip_whitespace(s, ptr);
return Value();
} else if (is_symbol(s[ptr])) {
// If this is a string
int n = 0;
while (is_symbol(s[ptr + n])) {
n++;
}
std::string x = s.substr(ptr, n);
ptr += n;
skip_whitespace(s, ptr);
return Value::atom(x);
} else {
throw std::runtime_error(MALFORMED_PROGRAM);
}
}
// Parse an entire program and get its list of expressions.
std::vector<Value> parse(std::string s) {
int i=0, last_i=-1;
std::vector<Value> result;
// While the parser is making progress (while the pointer is moving right)
// and the pointer hasn't reached the end of the string,
while (last_i != i && i <= int(s.length()-1)) {
// Parse another expression and add it to the list.
last_i = i;
result.push_back(parse(s, i));
}
// If the whole string wasn't parsed, the program must be bad.
if (i < int(s.length()))
throw std::runtime_error(MALFORMED_PROGRAM);
// Return the list of values parsed.
return result;
}
// Execute code in an environment
Value run(const std::string &code, Environment &env) {
// Parse the code
std::vector<Value> parsed = parse(code);
// Iterate over the expressions and evaluate them
// in this environment.
for (size_t i=0; i<parsed.size()-1; i++)
parsed[i].eval(env);
// Return the result of the last expression.
return parsed[parsed.size()-1].eval(env);
}
// This namespace contains all the definitions of builtin functions
namespace builtin {
// This function is NOT a builtin function, but it is used
// by almost all of them.
//
// Special forms are just builtin functions that don't evaluate
// their arguments. To make a regular builtin that evaluates its
// arguments, we just call this function in our builtin definition.
void eval_args(std::vector<Value> &args, Environment &env) {
for (size_t i=0; i<args.size(); i++)
args[i] = args[i].eval(env);
}
// Create a lambda function (SPECIAL FORM)
Value lambda(std::vector<Value> args, Environment &env) {
if (args.size() < 2)
throw Error(Value("lambda", lambda), env, TOO_FEW_ARGS);
if (args[0].get_type_name() != LIST_TYPE)
throw Error(Value("lambda", lambda), env, INVALID_LAMBDA);
return Value(args[0].as_list(), args[1], env);
}
// if-else (SPECIAL FORM)
Value if_then_else(std::vector<Value> args, Environment &env) {
if (args.size() != 3)
throw Error(Value("if", if_then_else), env, args.size() > 3? TOO_MANY_ARGS : TOO_FEW_ARGS);
if (args[0].eval(env).as_bool())
return args[1].eval(env);
else return args[2].eval(env);
}
// Define a variable with a value (SPECIAL FORM)
Value define(std::vector<Value> args, Environment &env) {
if (args.size() != 2)
throw Error(Value("define", define), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
Value result = args[1].eval(env);
env.set(args[0].display(), result);
return result;
}
// Define a function with parameters and a result expression (SPECIAL FORM)
Value defun(std::vector<Value> args, Environment &env) {
if (args.size() != 3)
throw Error(Value("defun", defun), env, args.size() > 3? TOO_MANY_ARGS : TOO_FEW_ARGS);
if (args[1].get_type_name() != LIST_TYPE)
throw Error(Value("defun", defun), env, INVALID_LAMBDA);
Value f = Value(args[1].as_list(), args[2], env);
env.set(args[0].display(), f);
return f;
}
// Loop over a list of expressions with a condition (SPECIAL FORM)
Value while_loop(std::vector<Value> args, Environment &env) {
Value acc;
while (args[0].eval(env).as_bool()) {
for (size_t i=1; i<args.size()-1; i++)
args[i].eval(env);
acc = args[args.size()-1].eval(env);
}
return acc;
}
// Iterate through a list of values in a list (SPECIAL FORM)
Value for_loop(std::vector<Value> args, Environment &env) {
Value acc;
std::vector<Value> list = args[1].eval(env).as_list();
for (size_t i=0; i<list.size(); i++) {
env.set(args[0].as_atom(), list[i]);
for (size_t j=1; j<args.size()-1; j++)
args[j].eval(env);
acc = args[args.size()-1].eval(env);
}
return acc;
}
// Evaluate a block of expressions in the current environment (SPECIAL FORM)
Value do_block(std::vector<Value> args, Environment &env) {
Value acc;
for (size_t i=0; i<args.size(); i++)
acc = args[i].eval(env);
return acc;
}
// Evaluate a block of expressions in a new environment (SPECIAL FORM)
Value scope(std::vector<Value> args, Environment &env) {
Environment e = env;
Value acc;
for (size_t i=0; i<args.size(); i++)
acc = args[i].eval(e);
return acc;
}
// Quote an expression (SPECIAL FORM)
Value quote(std::vector<Value> args, Environment &env) {
std::vector<Value> v;
for (size_t i=0; i<args.size(); i++)
v.push_back(args[i]);
return Value(v);
}
#ifdef USE_STD
// Exit the program with an integer code
Value exit(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
std::exit(args.size() < 1? 0 : args[0].cast_to_int().as_int());
return Value();
}
// Print several values and return the last one
Value print(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() < 1)
throw Error(Value("print", print), env, TOO_FEW_ARGS);
Value acc;
for (size_t i=0; i<args.size(); i++) {
acc = args[i];
std::cout << acc.display();
if (i < args.size() - 1)
std::cout << " ";
}
std::cout << std::endl;
return acc;
}
// Get user input with an optional prompt
Value input(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() > 1)
throw Error(Value("input", input), env, TOO_MANY_ARGS);
if (!args.empty())
std::cout << args[0];
std::string s;
std::getline(std::cin, s);
return Value::string(s);
}
// Get a random number between two numbers inclusively
Value random(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("random", random), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
int low = args[0].as_int(), high = args[1].as_int();
return Value(rand()%(high-low+1) + low);
}
// Get the contents of a file
Value parse_csv(std::vector<Value> args, Environment &env) {
eval_args(args, env);
// TODO add support for more params specifying options
if (args.size() != 1)
throw Error(Value("read-csv", parse_csv), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
// PERF optimize it for memory usage and performance
CsvParser csv(true);
std::vector< std::vector<std::string> > parsed_data; // TODO some default size here
csv.parseCSV(args[0].as_string(), parsed_data);
int rows = parsed_data.size();
int cols = rows > 0 ? parsed_data[0].size() : 0;
std::vector<Value> result;
if (rows > 0 && cols > 0) {
for (int r = 0; r < rows; r++) {
std::vector<Value> row;
for (int c = 0; c < cols; c++) {
std::string value = parsed_data[r][c];
if (is_string_int(value)) {
row.push_back(Value(stoi(value)));
} if (is_string_float(value)) {
row.push_back(Value(std::stod(value)));
} else {
row.push_back(Value::string(value));
}
}
result.push_back(row);
}
}
return Value(result);
}
// Get the contents of a file
Value read_file(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("read-file", read_file), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value::string(read_file_contents(args[0].as_string()));
}
// Write a string to a file
Value write_file(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("write-file", write_file), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::ofstream f;
// The first argument is the file name
f.open(args[0].as_string().c_str());
// The second argument is the contents of the file to write
Value result = Value((f << args[1].as_string())? 1 : 0);
f.close();
return result;
}
// Read URL to (code content)
Value read_url(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
// PERF optimize it for memory usage and performance
// TODO handle second parameter (headers)
if (args.size() != 1)
throw Error(Value("read_url", write_file), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::unordered_map<std::string, std::string> headers = {};
HttpClient client;
if (args.size() == 2) {
// do magick here
// for (auto i = map.begin(); i != map.end(); ++i) {
// headers[i->first] = i->second.getString();
// }
}
std::pair<int, std::string> result = client.doGetRequest(args[0].as_string(), headers);
std::vector<Value> lst;
lst.push_back(Value(result.first));
lst.push_back(Value::string(result.second));
return lst;
}
// Read a file and execute its code
Value include(std::vector<Value> args, Environment &env) {
// Import is technically not a special form, it's more of a macro.
// We can evaluate our arguments.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("include", include), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
Environment e;
Value result = run(read_file_contents(args[0].as_string()), e);
env.combine(e);
return result;
}
#endif
// Evaluate a value as code
Value eval(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("eval", eval), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
else return args[0].eval(env);
}
// Create a list of values
Value list(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
return Value(args);
}
// Sum multiple values
Value sum(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() < 2)
throw Error(Value("+", sum), env, TOO_FEW_ARGS);
Value acc = args[0];
for (size_t i=1; i<args.size(); i++)
acc = acc + args[i];
return acc;
}
// Subtract two values
Value subtract(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("-", subtract), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return args[0] - args[1];
}
// Multiply several values
Value product(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() < 2)
throw Error(Value("*", product), env, TOO_FEW_ARGS);
Value acc = args[0];
for (size_t i=1; i<args.size(); i++)
acc = acc * args[i];
return acc;
}
// Divide two values
Value divide(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("/", divide), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return args[0] / args[1];
}
// Get the remainder of values
Value remainder(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("%", remainder), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return args[0] % args[1];
}
// Are two values equal?
Value eq(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("=", eq), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value(int(args[0] == args[1]));
}
// Are two values not equal?
Value neq(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("!=", neq), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value(int(args[0] != args[1]));
}
// Is one number greater than another?
Value greater(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value(">", greater), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value(int(args[0] > args[1]));
}
// Is one number less than another?
Value less(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("<", less), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value(int(args[0] < args[1]));
}
// Is one number greater than or equal to another?
Value greater_eq(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value(">=", greater_eq), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value(int(args[0] >= args[1]));
}
// Is one number less than or equal to another?
Value less_eq(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("<=", less_eq), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value(int(args[0] <= args[1]));
}
// Get the type name of a value
Value get_type_name(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("type", get_type_name), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value::string(args[0].get_type_name());
}
// Cast an item to a float
Value cast_to_float(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value(FLOAT_TYPE, cast_to_float), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return args[0].cast_to_float();
}
// Cast an item to an int
Value cast_to_int(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value(INT_TYPE, cast_to_int), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return args[0].cast_to_int();
}
// Index a list
Value index(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("index", index), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::vector<Value> list = args[0].as_list();
int i = args[1].as_int();
if (list.empty() || i >= list.size())
throw Error(list, env, INDEX_OUT_OF_RANGE);
return list[i];
}
// Insert a value into a list
Value insert(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 3)
throw Error(Value("insert", insert), env, args.size() > 3? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::vector<Value> list = args[0].as_list();
int i = args[1].as_int();
if (i > list.size())
throw Error(list, env, INDEX_OUT_OF_RANGE);
list.insert(list.begin() + args[1].as_int(), args[2]);
return Value(list);
}
// Remove a value at an index from a list
Value remove(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 2)
throw Error(Value("remove", remove), env, args.size() > 2? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::vector<Value> list = args[0].as_list();
int i = args[1].as_int();
if (list.empty() || i >= list.size())
throw Error(list, env, INDEX_OUT_OF_RANGE);
list.erase(list.begin() + i);
return Value(list);
}
// Get the length of a list
Value len(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("len", len), env, args.size() > 1?
TOO_MANY_ARGS : TOO_FEW_ARGS
);
return Value(int(args[0].as_list().size()));
}
// Add an item to the end of a list
Value push(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() == 0)
throw Error(Value("push", push), env, TOO_FEW_ARGS);
for (size_t i=1; i<args.size(); i++)
args[0].push(args[i]);
return args[0];
}
Value pop(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("pop", pop), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return args[0].pop();
}
Value head(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("head", head), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::vector<Value> list = args[0].as_list();
if (list.empty())
throw Error(Value("head", head), env, INDEX_OUT_OF_RANGE);
return list[0];
}
Value tail(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("tail", tail), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::vector<Value> result, list = args[0].as_list();
for (size_t i = 1; i<list.size(); i++)
result.push_back(list[i]);
return Value(result);
}
Value parse(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("parse", parse), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
if (args[0].get_type_name() != STRING_TYPE)
throw Error(args[0], env, INVALID_ARGUMENT);
std::vector<Value> parsed = ::parse(args[0].as_string());
// if (parsed.size() == 1)
// return parsed[0];
// else return Value(parsed);
return Value(parsed);
}
Value replace(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 3)
throw Error(Value("replace", replace), env, args.size() > 3? TOO_MANY_ARGS : TOO_FEW_ARGS);
std::string src = args[0].as_string();
replace_substring(src, args[1].as_string(), args[2].as_string());
return Value::string(src);
}
Value display(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("display", display), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value::string(args[0].display());
}
Value debug(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
if (args.size() != 1)
throw Error(Value("debug", debug), env, args.size() > 1? TOO_MANY_ARGS : TOO_FEW_ARGS);
return Value::string(args[0].debug());
}
Value map_list(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
std::vector<Value> result, l=args[1].as_list(), tmp;
for (size_t i=0; i<l.size(); i++) {
tmp.push_back(l[i]);
result.push_back(args[0].apply(tmp, env));
tmp.clear();
}
return Value(result);
}
Value filter_list(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
std::vector<Value> result, l=args[1].as_list(), tmp;
for (size_t i=0; i<l.size(); i++) {
tmp.push_back(l[i]);
if (args[0].apply(tmp, env).as_bool())
result.push_back(l[i]);
tmp.clear();
}
return Value(result);
}
Value reduce_list(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
std::vector<Value> l=args[2].as_list(), tmp;
Value acc = args[1];
for (size_t i=0; i<l.size(); i++) {
tmp.push_back(acc);
tmp.push_back(l[i]);
acc = args[0].apply(tmp, env);
tmp.clear();
}
return acc;
}
Value range(std::vector<Value> args, Environment &env) {
// Is not a special form, so we can evaluate our args.
eval_args(args, env);
std::vector<Value> result;
Value low = args[0], high = args[1];
if (low.get_type_name() != INT_TYPE && low.get_type_name() != FLOAT_TYPE)
throw Error(low, env, MISMATCHED_TYPES);
if (high.get_type_name() != INT_TYPE && high.get_type_name() != FLOAT_TYPE)
throw Error(high, env, MISMATCHED_TYPES);
if (low >= high) return Value(result);
while (low < high) {
result.push_back(low);
low = low + Value(1);
}
return Value(result);
}
}
void repl(Environment &env) {
#ifdef USE_STD
std::string code;
std::string input;
Value tmp;
std::vector<Value> parsed;
while (true) {
std::cout << ">>> ";
std::getline(std::cin, input);
if (input == "!quit" || input == "!q")
break;
else if (input == "!env" || input == "!e")
std::cout << env << std::endl;
else if (input == "!export" || input == "!x") {
std::cout << "File to export to: ";
std::getline(std::cin, input);
std::ofstream f;
f.open(input.c_str(), std::ofstream::out);
f << code;
f.close();
} else if (input != "") {
try {
tmp = run(input, env);
std::cout << " => " << tmp.debug() << std::endl;
code += input + "\n";
} catch (Error &e) {
std::cerr << e.description() << std::endl;
} catch (std::runtime_error &e) {
std::cerr << e.what() << std::endl;
}
}
}
#endif
}
// Does this environment, or its parent environment, have a variable?
bool Environment::has(std::string name) const {
// Find the value in the map
std::map<std::string, Value>::const_iterator itr = defs.find(name);
if (itr != defs.end())
// If it was found
return true;
else if (parent_scope != NULL)
// If it was not found in the current environment,
// try to find it in the parent environment
return parent_scope->has(name);
else return false;
}
// Get the value associated with this name in this scope
Value Environment::get(std::string name) const {
// Meta operations
if (name == "eval") return Value("eval", builtin::eval);
if (name == "type") return Value("type", builtin::get_type_name);
if (name == "parse") return Value("parse", builtin::parse);
// Special forms
if (name == "do") return Value("do", builtin::do_block);
if (name == "if") return Value("if", builtin::if_then_else);
if (name == "for") return Value("for", builtin::for_loop);
if (name == "while") return Value("while", builtin::while_loop);
if (name == "scope") return Value("scope", builtin::scope);
if (name == "quote") return Value("quote", builtin::quote);
if (name == "defun") return Value("defun", builtin::defun);
if (name == "define") return Value("define", builtin::define);
if (name == "lambda") return Value("lambda", builtin::lambda);
// Comparison operations
if (name == "=") return Value("=", builtin::eq);
if (name == "!=") return Value("!=", builtin::neq);
if (name == ">") return Value(">", builtin::greater);
if (name == "<") return Value("<", builtin::less);
if (name == ">=") return Value(">=", builtin::greater_eq);
if (name == "<=") return Value("<=", builtin::less_eq);
// Arithmetic operations
if (name == "+") return Value("+", builtin::sum);
if (name == "-") return Value("-", builtin::subtract);
if (name == "*") return Value("*", builtin::product);
if (name == "/") return Value("/", builtin::divide);
if (name == "%") return Value("%", builtin::remainder);
// List operations
if (name == "list") return Value("list", builtin::list);
if (name == "insert") return Value("insert", builtin::insert);
if (name == "index") return Value("index", builtin::index);
if (name == "remove") return Value("remove", builtin::remove);
if (name == "len") return Value("len", builtin::len);
if (name == "push") return Value("push", builtin::push);
if (name == "pop") return Value("pop", builtin::pop);
if (name == "head") return Value("head", builtin::head);
if (name == "tail") return Value("tail", builtin::tail);
if (name == "first") return Value("first", builtin::head);
if (name == "last") return Value("last", builtin::pop);
if (name == "range") return Value("range", builtin::range);
// Functional operations
if (name == "map") return Value("map", builtin::map_list);
if (name == "filter") return Value("filter", builtin::filter_list);
if (name == "reduce") return Value("reduce", builtin::reduce_list);
// IO operations
#ifdef USE_STD
if (name == "exit") return Value("exit", builtin::exit);
if (name == "quit") return Value("quit", builtin::exit);
if (name == "print") return Value("print", builtin::print);
if (name == "input") return Value("input", builtin::input);
if (name == "random") return Value("random", builtin::random);
if (name == "include") return Value("include", builtin::include);
if (name == "parse-csv") return Value("parse-csv", builtin::parse_csv);
if (name == "read-file") return Value("read-file", builtin::read_file);
if (name == "write-file") return Value("write-file", builtin::write_file);
if (name == "read-url") return Value("read-url", builtin::read_url);
#endif
// String operations
if (name == "debug") return Value("debug", builtin::debug);
if (name == "replace") return Value("replace", builtin::replace);
if (name == "display") return Value("display", builtin::display);
// Casting operations
if (name == "int") return Value("int", builtin::cast_to_int);
if (name == "float") return Value("float", builtin::cast_to_float);
// Constants
if (name == "endl") return Value::string("\n");
std::map<std::string, Value>::const_iterator itr = defs.find(name);
if (itr != defs.end()) return itr->second;
else if (parent_scope != NULL) {
itr = parent_scope->defs.find(name);
if (itr != parent_scope->defs.end()) return itr->second;
else return parent_scope->get(name);
}
throw Error(Value::atom(name), *this, ATOM_NOT_DEFINED);
}
int main(int argc, const char **argv) {
Environment env;
std::vector<Value> args;
for (int i=0; i<argc; i++)
args.push_back(Value::string(argv[i]));
env.set("cmd-args", Value(args));
#ifdef USE_STD
srand(time(NULL));
try {
if (argc == 1 || (argc == 2 && std::string(argv[1]) == "-i"))
repl(env);
else if (argc == 3 && std::string(argv[1]) == "-c")
run(argv[2], env);
else if (argc == 3 && std::string(argv[1]) == "-f")
run(read_file_contents(argv[2]), env);
else std::cerr << "invalid arguments" << std::endl;
} catch (Error &e) {
std::cerr << e.description() << std::endl;
} catch (std::runtime_error &e) {
std::cerr << e.what() << std::endl;
}
#else
if (argc == 3 && std::string(argv[1]) == "-c")
run(argv[2], env);
#endif
return 0;
}
Reference in New Issue View Git Blame Copy Permalink