How to implement arrays in an interpreter?

Question

I have managed to write several interpreters including

• Tokenizing
• Parsing, including more complicated expressions such as ((x+y)*z)/2
• Building bytecode from syntax trees
• Actual bytecode execution

What I didn't manage: Implementation of dictionaries/lists/arrays.

I always got stuck with getting multiple values into one variable.

My value structure (used for all values passed around, including variables) looks like this, for example:

class Value
{
public:
 ValueType type;

 int integerValue;
 string stringValue;
}

Works fine with integers and strings, but how could I implement arrays?

(From now on with array I mean arrays in my experimental language, not in C++)

• How can I fit the array concept into the Value class above? Is it possible?

• How should I make arrays able to be passed around just as you could pass around integers and strings in my language, using the class above?

Accessing array elements or memory allocation wouldn't be the problem, I just don't know how to store them.

Answer 1

If I do this, does the rest follow through easily enough?

class Value
{
public:
 ValueType type;

 int integerValue;
 string stringValue;
 vector<Value> arrayValue;
}

Answer 2

Your Value type could be a (smart) pointer to a base class from which you'd derive classes for integers, strings, dictionnaries, ...

Answer 3

I think you need an extra layer of abstraction here.

Your 'variable' should model the binding of some internal object with a 'name' in the language you're building. The 'object' should model the representation.

This way, a variable can hold anything, it's a 'variant'. A certain kind of Object may contain an array of other objects.

A hint:

class Object {
public:
   enum etype { cInt, cString, cArray, cDictionary };
   virtual etype type() const = 0;
   virtual ~Object(){} // don't forget virtual destructor
   // maybe some reference counter functions?...
};

class Variable {
public:
    string name;
    Object* value;
};

class Array : public Object {
   std::map<size_t, Object*> objects_; //or smart pointers...
public:
   virtual etype type() const { return cArray; }
   Object* get( size_t i ) const { return objects_[i]; }
   void put( size_t i, Object* o ) { objects_[i] = o;  }
};

class Int : public Object {
public:
    virtual etype type() const { return cInt; }  
    int value_;
};