compiler.h

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

#ifndef __COMPILER_H__
#define __COMPILER_H__

#include "ctalk.h"
#include "sync.h"
#include "memmgr.h"
#include "scanner.h"

enum CompileCtx { 
    CC_RVALUE,
    CC_LVALUE
}; 

enum JumpType { 
    JMP_NEXT, 
    JMP_RETURN, 
    JMP_BREAK, 
    JMP_CONTINUE, 
    JMP_EXCEPTION
};

struct CtkToken { 
    unsigned  hash;
    int       symId;
    int       tag;
    char*     name;
    CtkToken* next;
};

struct CtkTokenList { 
    CtkTokenList* next;
    CtkToken*     tkn;

    CtkTokenList(CtkToken* t, CtkTokenList* tail) { 
	tkn = t;
	next = tail;
    }
};
 
struct CtkExpr;
struct CtkStmt;
struct CtkFuncDef;

struct CtkSymbol { 
    CtkToken*   tok;
    CtkSymbol*  next;
    int         index;   // index of variable in the frame
    CtkFuncDef* func;

    CtkSymbol(CtkToken* t, int idx, CtkSymbol* chain) { 
	tok = t;
	index = idx;
	next = chain;
	func = NULL;
    }
};

struct CtkContext { 
    CtkContext* exterior;
    int         nSymbols;
    CtkSymbol*  symbols;

    CtkContext() { 
	exterior = NULL;
	nSymbols = 0;
	symbols = NULL;
    }
    ~CtkContext() { 
        CtkSymbol *sym, *next;
        for (sym = symbols; sym != NULL; sym = next) { 
            next = sym->next;
            delete sym;
        }
    }
};

struct CtkFrame;
struct CtkProgram;

struct CtkModule { 
    CtkToken*   tkn;
    CtkModule*  next;
    CtkFrame*   frame;
    CtkContext* ctx;
    CtkProgram* prog;
    char*       path;

    CtkModule(CtkToken* t, char const* modPath, CtkModule* chain) { 
	tkn = t;
	path = new char[strlen(modPath) + 1];
	strcpy(path, modPath);
	next = chain;
	frame = NULL;
	ctx = NULL;
    }
    ~CtkModule();
};

struct CtkImport { 
    CtkModule*  module;
    CtkImport*  next; 

    CtkImport(CtkModule* mod, CtkImport* chain) {
	module = mod;
	next = chain;
    }
};

struct CtkPath { 
    CtkPath*    next;
    char*       dir;

    CtkPath(char* path, CtkPath* chain) { 
	next = chain;
	dir = path;
    }
};
    


struct CtkCompiler { 
    mutex_t      mutex;
    CtkContext*  currCtx;
    int          currLevel;
    CtkProgram*  program;
    CtkImport*   importList;
    CtkModule*   modules;
    CtkPath*     path;
    CtkModule*   currModule;

    CtkModule*   compile(CtkToken* moduleName);
    CtkModule*   compile(char const* moduleName);
    
    void         compileBlock(CtkStmt* stmts);

    void         error(char const* errtext, CtkNode* node);

    void         reset();

    static CtkCompiler instance;
};

struct CtkStmt : CtkNode { 
    CtkStmt* next;

    virtual JumpType execute(CtkFrame* frame);
    virtual void compile(CtkCompiler* compiler);

    JumpType  executeBlock(CtkFrame* frame);

    CtkStmt() { 
        line = CtkScanner::instance.yyline;
        next = NULL; 
    }
    virtual ~CtkStmt() {}
};


struct CtkProgram : CtkStmt { 
    CtkTokenList* modules;
    CtkStmt*      stmts;
    int           nVars;

    CtkProgram(CtkTokenList* modules, CtkStmt* stmts) { 
	this->modules = modules;
	this->stmts = stmts;
    }
    
    ~CtkProgram() { 
        CtkStmt *stmt, *nextStmt;
        for (stmt = stmts; stmt != NULL; stmt = nextStmt) { 
            nextStmt = stmt->next;
            delete stmt;
        }
        CtkTokenList *tkn, *nextTkn;
        for (tkn = modules; tkn != NULL; tkn = nextTkn) { 
            nextTkn = tkn->next;
            delete tkn;
        }            
    }
        
    virtual JumpType execute(CtkFrame* frame);
    
    virtual void compile(CtkCompiler* compiler);
};
    
struct CtkFuncDef : CtkStmt { 
    CtkToken*     tok; 
    CtkTokenList* params; 
    CtkStmt*      stmts;
    int           index;
    int           nParams;
    int           nLocals;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkFuncDef(CtkToken* tok, CtkTokenList* params, CtkStmt* stmts) { 
	this->tok = tok;
	this->params = params;
	this->stmts = stmts;
    }
    ~CtkFuncDef() { 
        CtkStmt *stmt, *nextStmt;
        for (stmt = stmts; stmt != NULL; stmt = nextStmt) { 
            nextStmt = stmt->next;
            delete stmt;
        }
        CtkTokenList *tkn, *nextTkn;
        for (tkn = params; tkn != NULL; tkn = nextTkn) { 
            nextTkn = tkn->next;
            delete tkn;
        }            
    }
};

struct CtkExpr : CtkNode { 
    CtkExpr* next;

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

    inline  bool testCondition(CtkFrame* frame) { 
	CtkObject result = getRvalue(frame);
	frame->thread->sp -= 1;
	return IS_TRUE(result);
    }

    inline void evaluate(CtkFrame* frame) { 
	getRvalue(frame);
	frame->thread->sp -= 1;
    }

    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();

    CtkExpr() { 
        next = NULL; 
        line = CtkScanner::instance.yyline;
    }
    virtual ~CtkExpr() {}
}; 

struct CtkIfStmt : CtkStmt { 
    CtkExpr* cond;
    CtkStmt* thenStmt;
    CtkStmt* elseStmt;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkIfStmt(CtkExpr* cond, CtkStmt* thenStmt, CtkStmt* elseStmt) { 
	this->cond = cond;
	this->thenStmt = thenStmt;
	this->elseStmt = elseStmt;
    }
    ~CtkIfStmt() { 
        delete cond;
        delete thenStmt;
        delete elseStmt;
    }
};

struct CtkForStmt : CtkStmt { 
    CtkExpr* init;
    CtkExpr* cond;
    CtkExpr* inc;
    CtkStmt* body;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkForStmt(CtkExpr* init, CtkExpr* cond, CtkExpr* inc, CtkStmt* body) { 
	this->init = init;
	this->cond = cond;
	this->inc  = inc;
	this->body = body;
    }
    ~CtkForStmt() { 
        delete init;
        delete cond;
        delete inc;
        delete body;
    }
};

struct CtkDoWhileStmt : CtkStmt { 
    CtkExpr* cond;
    CtkStmt* body;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkDoWhileStmt(CtkStmt* body, CtkExpr* cond) { 
	this->cond = cond;
	this->body = body;
    }
    ~CtkDoWhileStmt() { 
        delete cond;
        delete body;
    }       
};

struct CtkWhileStmt : CtkStmt { 
    CtkExpr* cond;
    CtkStmt* body;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkWhileStmt(CtkExpr* cond, CtkStmt* body) { 
	this->cond = cond;
	this->body = body;
    }
    ~CtkWhileStmt() { 
        delete cond;
        delete body;
    }       
};

struct CtkCaseStmt : CtkStmt { 
    CtkCaseStmt* next;
    CtkExpr*     selector;
    CtkStmt*     stmt;

    CtkCaseStmt(CtkExpr* selector, CtkStmt* stmt) { 
	next = NULL;
	this->selector = selector;
	this->stmt = stmt;
    }
    ~CtkCaseStmt() { 
        delete selector;
        delete stmt;
    }       
};

struct CtkSwitchStmt : CtkStmt { 
    CtkExpr* expr;
    CtkCaseStmt* cases;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkSwitchStmt(CtkExpr* expr, CtkCaseStmt* cases) { 
	this->expr = expr;
	this->cases = cases;
    }
    ~CtkSwitchStmt() { 
        delete expr;
        CtkCaseStmt *cs, *next;
        for (cs = cases; cs != NULL; cs = next) { 
            next = cs->next;
            delete cs;
        }
    }
};

struct CtkContinueStmt : CtkStmt { 
    virtual JumpType execute(CtkFrame* frame);
};


struct CtkBreakStmt : CtkStmt { 
    virtual JumpType execute(CtkFrame* frame);
};

struct CtkReturnStmt : CtkStmt { 
    CtkExpr* expr;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkReturnStmt(CtkExpr* expr = NULL) { 
	this->expr = expr;
    }
    ~CtkReturnStmt() { 
        delete expr;
    }
};
    
struct CtkThrowStmt : CtkStmt { 
    CtkExpr* except;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkThrowStmt(CtkExpr* except = NULL) { 
	this->except = except;
    }
    ~CtkThrowStmt() { 
        delete except;
    }
};

struct CtkTryStmt : CtkStmt { 
    CtkStmt*    stmt;
    CtkToken*   param;
    CtkStmt*    handler;
    int         symIdx;

    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkTryStmt(CtkStmt* stmt, CtkToken* param, CtkStmt* handler) { 
	this->stmt = stmt;
	this->param = param;
	this->handler = handler;
    }
    ~CtkTryStmt() { 
        delete stmt;
        delete handler;
    }
};

struct CtkExprStmt : CtkStmt { 
    CtkExpr* expr;
    
    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

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

struct CtkEmptyStmt : CtkStmt {};

struct CtkSynchronizedStmt : CtkStmt { 
    CtkExpr* mutex;
    CtkStmt* stmt;
    
    virtual void compile(CtkCompiler* compiler);
    virtual JumpType execute(CtkFrame* frame);

    CtkSynchronizedStmt(CtkExpr* mutex, CtkStmt* stmt) { 
	this->mutex = mutex;
	this->stmt = stmt;
    }