OSDev.org

Code: Select all

typedef std::shared_ptr<Env_Symbol> EnvSymbolPtr;
typedef std::shared_ptr<Environment> EnvPtr;

// provide a type list for the different subclasses of MalObject.
// I felt that this was more useful for my purposes than trying
// to use typeid().
enum MalType
{
    MAL_OBJECT,
[...]
    MAL_COLLECTION, MAL_PAIR, 
[...]
};

// an array of strings representing the type names.
extern std::string mal_type_name[];

// shortcuts for the two most frequently used pointer types.
typedef std::shared_ptr<MalObject> MalPtr;
typedef std::shared_ptr<MalPair> PairPtr;


class MalObject
{
public:
    MalObject(MalType type): m_type(type) {};
    virtual std::string to_str() {return "";};
    MalType type() {return m_type;};
    std::string type_name() {return mal_type_name[m_type];};
    virtual size_t size() {return 1;};

    // type predicates
[...]
    virtual bool is_null() {return false;};
    virtual bool is_pair() {return false;};
    virtual bool is_list() {return false;};
[,,,]
    // return values of the subclasses
[...]
    virtual PairPtr as_pair() {throw InvalidConversionException(mal_type_name[m_type], mal_type_name[MAL_PAIR]); return nullptr;};


protected:
    MalType m_type;
};

[...]


class MalCollection: public MalObject
{
public:
    MalCollection(MalType type): MalObject(type) {};
    virtual bool is_collection() {return true;};
};


class MalPair: public MalCollection
{
public:
    MalPair(MalPtr car=nullptr, MalPtr cdr=nullptr): MalCollection(MAL_PAIR), m_car(car), m_cdr(cdr) {};
    virtual std::string to_str();
    virtual std::string to_str_continued();
    virtual bool is_null() {return (m_car == nullptr && m_cdr == nullptr);};
    virtual bool is_pair() {return true;};
    virtual bool is_list() {return (m_cdr == nullptr || m_cdr->is_pair());};
    virtual PairPtr as_pair() {return std::make_shared<MalPair>(m_car, m_cdr);};
    virtual size_t size();
    virtual MalPtr operator[](size_t index);
    virtual MalPtr car() {return m_car;};
    virtual MalPtr cdr() {return m_cdr;};
    virtual void add(MalPtr addition);       // inserts an element at the end of the list
protected:
    MalPtr m_car, m_cdr;
};

Code: Select all

void MalPair::add(MalPtr addition)
{
    if (m_car == nullptr)
    {
        if (m_cdr == nullptr)
        {
            // insert to the first element of the list
            m_car = addition;
        }
        else if (m_cdr->type() == MAL_PAIR)
        {
            // recurse over the list
            m_cdr->as_pair()->add(addition);
        }
        else
        {
            throw ImproperListException(this->to_str());
        }
    }
    else if (m_cdr == nullptr)
    {
        // insert to the end of the list
        m_cdr = std::make_shared<MalPair>(addition);
    }
    else
    {
        if (m_cdr->type() == MAL_PAIR)
        {
            // recurse over the list
            m_cdr->as_pair()->add(addition);
        }
        else
        {
            throw ImproperListException(this->to_str());
        }
    }
}

Code: Select all

    TEST_CASE("appending single element to list")
    {
        PairPtr test = std::make_shared<MalPair>();
        CHECK(test->to_str() == "()");
        test->add(std::make_shared<MalSymbol>("foo"));
        CHECK(test->to_str() == "(foo)");
        test->add(std::make_shared<MalKeyword>("bar"));
        CHECK(test->to_str() == "(foo :bar)");
// fails with both of the following tests
        test->add(std::make_shared<MalInteger>(69));
        CHECK(test->to_str() == "(foo :bar 69)");
        test->add(std::make_shared<MalRational>(mpq_class("17/23")));
        CHECK(test->to_str() == "(foo :bar 69 17/23)");
    }

Code: Select all

struct list_node {
  void *data;
  struct list_node *next;
};

struct list {
  struct list_node *first;
  struct list_node **plast;
};

void init_list(struct list *l) {
  l->first = 0;
  l->plast = &l->first;
};

int add_to_list(struct list *l, void *d)
{
  struct list_node *n = malloc(sizeof *n);
  if (!n) return ENOMEM;
  n->data = d;
  n->next = 0;
  *l->plast = n;
  l->plast = &n->next;
  return 0;
}

Code: Select all

    TEST_CASE("proper list of two integer elements")
    {
        PairPtr test = std::make_shared<MalPair>(std::make_shared<MalInteger>(42), std::make_shared<MalPair>(std::make_shared<MalInteger>(69)));
        MalPtr test_car = test->car();
        CHECK(test_car->type() == MAL_INTEGER);
        mpz_class test_num = test_car->as_integer();
        CHECK(test_num == 42);
        PairPtr test_cdr = test->cdr()->as_pair();                    //  <-- throws exception
        CHECK(test_cdr->type() == MAL_PAIR);
        CHECK(test_cdr->to_str() == "(69)");
        MalPtr test_cadr = test_cdr->car();
        CHECK(test_cadr->type() == MAL_INTEGER);
        test_num = test_cadr->as_integer();
        CHECK(test_num == 69);
        CHECK(test->to_str() == "(42 69)");
    }