aboutsummaryrefslogblamecommitdiff
path: root/types.h
blob: 151924231b00a2ae7cea139638764d1454846516 (plain) (tree)


























                                


                                 






















                                                                            
                











                                               



































































































                                                                            
                   












                                                                
                                  





















































































































                                                                                   
                                     
                                
                                     

                                            



                                                        





















                                                                         
                                          








                                                                              
                       










                                                                               
                                  






                                                                               
                                            












                                                                          

                                  



















































































































































                                                                    
#ifndef TYPES_H
#define TYPES_H

#include "model.h"
#include <string>
#include <list>
#include <map>
#include <vector>
#include <set>
#include <gmpxx.h>

using std::list;
using std::string;
using std::map;
using std::vector;
using std::set;

const int CLS_OPT_OBJ = 1 << 3;
const int CLS_PROM_OBJ = 1 << 9;

const int CLS_SYM_OBJ = 1 << 2;
const int CLS_NUM_OBJ = 1 << 4;
const int CLS_BOOL_OBJ = 1 << 5;
const int CLS_CHAR_OBJ = 1 << 6;
const int CLS_STR_OBJ = 1 << 7;
const int CLS_VECT_OBJ = 1 << 8;

const int CLS_CONT_OBJ = 1 << 9;
const int CLS_ENVT_OBJ = 1 << 10;

static const int NUM_LVL_COMP = 0;
static const int NUM_LVL_REAL = 1;
static const int NUM_LVL_RAT = 2;
static const int NUM_LVL_INT = 3;

typedef set<EvalObj*> EvalObjAddrHash;
typedef vector<EvalObj*> EvalObjVec;
typedef map<string, EvalObj*> Str2EvalObj;
typedef EvalObj* (*BuiltinProc)(Pair *, const string &);

class PairReprCons;
/** @class Pair
 * Pair construct, which can be used to represent a list, or further
 * more, a syntax tree
 * (car . cdr) in Scheme
 */
class Pair : public EvalObj {/*{{{*/
    public:
        EvalObj *car;                   /**< car (as in Scheme) */
        EvalObj *cdr;                      /**< cdr (as in Scheme) */
        Pair* next;                     /**< The next branch in effect */

        Pair(EvalObj *car, EvalObj *cdr);  /**< Create a Pair (car . cdr) */
        ~Pair();
        ReprCons *get_repr_cons();
};/*}}}*/

/** @class EmptyList
 * The empty list (special situation of a list)
 */
class EmptyList: public Pair {/*{{{*/
    public:
        EmptyList();
        ReprCons *get_repr_cons();
};/*}}}*/

class ReprCons {/*{{{*/
    public:
        EvalObj *ori;
        bool done;
        string repr;
        ReprCons(bool done, EvalObj *ori = NULL);
        virtual EvalObj *next(const string &prev) = 0;
};/*}}}*/

class ReprStr : public ReprCons {/*{{{*/
    public:
        ReprStr(string repr);
        EvalObj *next(const string &prev);
};/*}}}*/

class PairReprCons : public ReprCons {/*{{{*/
    private:
        int state;
        EvalObj *ptr;
    public:
        PairReprCons(Pair *ptr, EvalObj *ori);
        EvalObj *next(const string &prev);
};/*}}}*/

class VecObj;
class VectReprCons : public ReprCons {/*{{{*/
    private:
        VecObj *ptr;
        size_t idx;
    public:
        VectReprCons(VecObj *ptr, EvalObj *ori);
        EvalObj *next(const string &prev);
};/*}}}*/

/** @class ParseBracket
 * To indiate a left bracket when parsing, used in the parse_stack
 */
class ParseBracket : public FrameObj {/*{{{*/
    public:
        unsigned char btype;            /**< The type of the bracket */
        /** Construct a ParseBracket object */
        ParseBracket(unsigned char btype);
};/*}}}*/

/** @class UnspecObj
 * The "unspecified" value returned by some builtin procedures
 */
class UnspecObj: public EvalObj {/*{{{*/
    public:
        UnspecObj();
        ReprCons *get_repr_cons();
};/*}}}*/

/** @class SymObj
 * Symbols
 */
class SymObj: public EvalObj {/*{{{*/
    public:
        string val;

        SymObj(const string &);
        ReprCons *get_repr_cons();
};/*}}}*/

// Everything is cons
class Environment;
class Continuation;

/** @class OptObj
 * "Operators" in general sense
 */
class OptObj: public EvalObj {/*{{{*/
    public:
        OptObj();
        /**
         * The function is called when an operation is needed.
         * @param args The argument list (the first one is the opt itself)
         * @param envt The current environment (may be modified)
         * @param cont The current continuation (may be modified)
         * @param top_ptr Pointing to the top of the stack (may be modified)
         * @return New value for pc register
         */
        virtual Pair *call(Pair *args, Environment * &envt,
                            Continuation * &cont, FrameObj ** &top_ptr) = 0;
};/*}}}*/

/** @class ProcObj
 * User-defined procedures
 */
class ProcObj: public OptObj {/*{{{*/
    public:
        /** The procedure body, a list of expressions to be evaluated */
        Pair *body;
        /** The arguments: <list> | var1 ... | var1 var2 ... . varn */
        EvalObj *params;
        /** Pointer to the environment */
        Environment *envt;

        /** Conctructs a ProcObj */
        ProcObj(Pair *body, Environment *envt, EvalObj *params);
        ~ProcObj();
        Pair *call(Pair *args, Environment * &envt,
                    Continuation * &cont, FrameObj ** &top_ptr);
        ReprCons *get_repr_cons();
};/*}}}*/

/** @class SpecialOptObj
 * Special builtin syntax (`if`, `define`, `lambda`, etc.)
 */
class SpecialOptObj: public OptObj {/*{{{*/
    protected:
        string name;
    public:
        SpecialOptObj(string name);
        ReprCons *get_repr_cons();
};/*}}}*/

/** @class BuiltinProcObj
 * Wrapping class for builtin procedures (arithmetic operators, etc.)
 */
class BuiltinProcObj: public OptObj {/*{{{*/
    private:
        /** The function that tackle the inputs in effect */
        BuiltinProc handler;
        string name;
    public:
        /**
         * Make a BuiltinProcObj which invokes proc when called
         * @param proc the actual handler
         * @param name the name of this built-in procedure
         */
        BuiltinProcObj(BuiltinProc proc, string name);
        Pair *call(Pair *args, Environment * &envt,
                    Continuation * &cont, FrameObj ** &top_ptr);
        ReprCons *get_repr_cons();
};/*}}}*/

/** @class BoolObj
 * Booleans
 */
class BoolObj: public EvalObj {/*{{{*/
    public:
        bool