compiler.h

C-Talk is interpreted scripting language with C-like syntax and dynamic type checking. Variables in

    ~CtkSynchronizedStmt() { 
        delete mutex;
        delete stmt;
    }
};

struct CtkBinaryExpr : CtkExpr {
    CtkExpr* left;
    CtkExpr* right;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);
 
    CtkBinaryExpr(CtkExpr* left, CtkExpr* right) { 
	this->left = left;
	this->right = right;
    }
    ~CtkBinaryExpr() { 
        delete left;
        delete right;
    }
};

struct CtkAddExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkAddExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkSubExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSubExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkMulExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkMulExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};
    
struct CtkDivExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkDivExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkModExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkModExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkOrExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkOrExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};
    
struct CtkAndExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkAndExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkXorExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkXorExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};


struct CtkShlExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkShlExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};
    
struct CtkShrExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkShrExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkEqExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkEqExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkNeExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkNeExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkGtExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkGtExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkGeExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkGeExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkLtExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkLtExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};
    
struct CtkLeExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkLeExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};


struct CtkLandExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkLandExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};


struct CtkLorExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkLorExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkAssignExpr : CtkBinaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual void compile(CtkCompiler* compiler, CompileCtx);

    CtkAssignExpr(CtkExpr* left, CtkExpr* right) : CtkBinaryExpr(left, right) {}
};

struct CtkSetAddExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetAddExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetSubExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetSubExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetMulExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetMulExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetDivExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetDivExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetModExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetModExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetOrExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetOrExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetXorExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetXorExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetAndExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetAndExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetShlExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetShlExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkSetShrExpr : CtkAssignExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkSetShrExpr(CtkExpr* left, CtkExpr* right) : CtkAssignExpr(left, right) {}
};

struct CtkCondExpr : CtkExpr {
    CtkExpr* cond;
    CtkExpr* trueExpr;
    CtkExpr* falseExpr;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkCondExpr(CtkExpr* cond, CtkExpr* trueExpr, CtkExpr* falseExpr) { 
	this->cond = cond;
	this->trueExpr = trueExpr;
	this->falseExpr = falseExpr;
    }
    ~CtkCondExpr() { 
        delete cond;
        delete trueExpr;
        delete falseExpr;
    }
};

struct CtkUnaryExpr : CtkExpr { 
    CtkExpr* expr;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    CtkUnaryExpr(CtkExpr* expr) { 
	this->expr = expr;
    }
    ~CtkUnaryExpr() { 
        delete expr;
    }
};

struct CtkNegExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkNegExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkPreIncExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    CtkPreIncExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkPreDecExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    CtkPreDecExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkPostIncExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    CtkPostIncExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkPostDecExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    CtkPostDecExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkNotExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkNotExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkComExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkComExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkEnvExpr : CtkUnaryExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual CtkObject getLvalue(CtkFrame* frame);
    virtual void      setLvalue(CtkFrame* frame, CtkObject value);
    virtual void      assign(CtkFrame* frame, CtkObject value);
    virtual bool      isLvalue();

    CtkEnvExpr(CtkExpr* expr) : CtkUnaryExpr(expr) {}
};

struct CtkArrayAccessExpr : CtkExpr { 
    CtkExpr* array;
    CtkExpr* index;

    virtual void      compile(CtkCompiler* compiler, CompileCtx ctx);
    virtual CtkObject getRvalue(CtkFrame* frame);
    virtual CtkObject getLvalue(CtkFrame* frame);
    virtual void      setLvalue(CtkFrame* frame, CtkObject value);
    virtual void      assign(CtkFrame* frame, CtkObject value);
    virtual bool      isLvalue();

    CtkArrayAccessExpr(CtkExpr* array, CtkExpr* index) { 
	this->array = array;
	this->index = index;
    }
    ~CtkArrayAccessExpr() { 
        delete array;
        delete index;
    }
};
    
struct CtkFuncCallExpr : CtkExpr { 
    CtkExpr* func;
    CtkExpr* args;
    int      nArgs;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkFuncCallExpr(CtkExpr* func, CtkExpr* args) { 
	this->func = func;
	this->args = args;
    }
    ~CtkFuncCallExpr() {
        delete func;
        CtkExpr* arg, *next;
        for (arg = args; arg != NULL; arg = next) { 
            next = arg->next;
            delete arg;
        }
    }
};
    
struct CtkRunThreadExpr : CtkFuncCallExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);    

    CtkRunThreadExpr(CtkExpr* func, CtkExpr* args) : CtkFuncCallExpr(func, args) {}
};
    
struct CtkArrayElemExpr : CtkExpr { 
    CtkExpr* key;
    CtkExpr* value;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    CtkArrayElemExpr(CtkExpr* key, CtkExpr* value) { 
	this->key = key;
	this->value = value;
    }
    ~CtkArrayElemExpr() { 
        delete key;
        delete value;
    }
};


struct CtkArrayConst: CtkExpr { 
    CtkArrayElemExpr* elements;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);
    virtual CtkObject getRvalue(CtkFrame* frame);

    void enumerate();

    CtkArrayConst(CtkArrayElemExpr* elements) { 
	this->elements = elements;
    }
    ~CtkArrayConst() { 
        CtkExpr* elem, *next;
        for (elem = elements; elem != NULL; elem = next) { 
            next = elem->next;
            delete elem;
        }
    }
};

struct CtkStringConst : CtkExpr { 
    CtkObject value;
    
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkStringConst(char* s) { 
        MAKE_STRING(value, s);	
    }
    ~CtkStringConst() { 
        ctkDeallocateStringLiteral(value.u.svalue);
    }
};

struct CtkIntConst : CtkExpr { 
    CtkObject value;
    
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkIntConst(ctk_integer i) { 
	MAKE_INTEGER(value, i);	
    }
};

struct CtkRealConst : CtkExpr { 
    CtkObject value;
    
    virtual CtkObject getRvalue(CtkFrame* frame);

    CtkRealConst(ctk_real r) { 
	MAKE_REAL(value, r);	
    }
};

struct CtkNullConst : CtkExpr { 
    virtual CtkObject getRvalue(CtkFrame* frame);
};

struct CtkVariable : CtkExpr { 
    CtkToken*     tok; 
    CtkFrame*     module;
    CtkPrimitive* prim;
    CtkFuncDef*   func;
    int           level;
    int           index;

    virtual void compile(CtkCompiler* compiler, CompileCtx ctx);

    virtual CtkObject   getRvalue(CtkFrame* frame);
    virtual CtkObject   getLvalue(CtkFrame* frame);
    virtual void        setLvalue(CtkFrame* frame, CtkObject value);
    virtual void        assign(CtkFrame* frame, CtkObject value);
    virtual bool        isLvalue();
    virtual CtkFuncDef* getFuncDef();

    CtkVariable(CtkToken* tok) { 
	this->tok = tok;
	module = NULL;
	prim = NULL;
    }
};

extern int yylex();

#endif