ccscript.h

Go to the documentation of this file.

// Copyright (C) 2008-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef _CCSCRIPT_H_
#define _CCSCRIPT_H_

#ifndef UCOMMON_UCOMMON_H_
#include <ucommon/ucommon.h>
#endif

namespace ucommon {

class __EXPORT Script : public CountedObject, public memalloc
{
public:
    class interp;
    class header;
    class checks;

    typedef bool (Script::interp::*method_t)(void);

    typedef struct line {
        struct line *next;
        union {
            const char *cmd;
            header *sub;
        };
        char **argv;
        unsigned short loop, argc;
        unsigned lnum, mask;
        method_t method;
    } line_t;

    typedef const char *(*check_t)(Script *img, Script::header *scr, Script::line_t *line);

    typedef struct keyword
    {
        const char *name;           
        method_t method;    
        check_t check;              
        struct keyword *next;       
    } keyword_t;

    class __EXPORT strict : public LinkedObject
    {
    private:
        __DELETE_DEFAULTS(strict);

    public:
        const char *id;

        static bool find(Script *img, header *scr, const char *id);
        static void createVar(Script *img, header *scr, const char *id);
        static void createSym(Script *img, header *scr, const char *id);
        static void createAny(Script *img, header *scr, const char *id);
        static void createGlobal(Script *img, const char *id);

        void put(FILE *fp, const char *header);
    };

    class __EXPORT symbol : public LinkedObject
    {
    private:
        __DELETE_DEFAULTS(symbol);

    public:
        const char *name;   
        char *data;         
        unsigned size;      
        header *scope;      
    };

    class __EXPORT event : public LinkedObject
    {
    private:
        __DELETE_DEFAULTS(event);

    public:
        line_t *first;
        const char *name;
    };

    typedef event event_t;

    class __EXPORT header : public LinkedObject
    {
    private:
        __DELETE_DEFAULTS(header);

    public:
        LinkedObject *scoped;   
        LinkedObject *events;   
        LinkedObject *methods;  
        line_t *first;          
        const char *file;       
        const char *name;       
        unsigned resmask;       
        inline void link(header *scr)
            {Next = scr;}
    };

    class __EXPORT checks
    {
    private:
        __DELETE_DEFAULTS(checks);

    public:
        static bool isValue(const char *text);
        static bool isText(const char *text);

        static const char *chkPush(Script *img, header *scr, line_t *line);
        static const char *chkApply(Script *img, header *scr, line_t *line);
        static const char *chkIgnore(Script *img, header *scr, line_t *line);
        static const char *chkNop(Script *img, header *scr, line_t *line);
        static const char *chkExit(Script *img, header *scr, line_t *line);
        static const char *chkVar(Script *img, header *scr, line_t *line);
        static const char *chkConst(Script *img, header *scr, line_t *line);
        static const char *chkSet(Script *img, header *scr, line_t *line);
        static const char *chkClear(Script *img, header *scr, line_t *line);
        static const char *chkError(Script *img, header *scr, line_t *line);
        static const char *chkPack(Script *img, header *scr, line_t *line);
        static const char *chkExpand(Script *img, header *scr, line_t *line);
        static const char *chkGosub(Script *img, header *src, line_t *line);
        static const char *chkGoto(Script *img, header *scr, line_t *line);
        static const char *chkDo(Script *img, header *scr, line_t *line);
        static const char *chkUntil(Script *img, header *scr, line_t *line);
        static const char *chkWhile(Script *ing, header *scr, line_t *line);
        static const char *chkConditional(Script *img, header *scr, line_t *line);
        static const char *chkContinue(Script *img, header *scr, line_t *line);
        static const char *chkBreak(Script *img, header *scr, line_t *line);
        static const char *chkLoop(Script *img, header *scr, line_t *line);
        static const char *chkPrevious(Script *img, header *scr, line_t *line);
        static const char *chkIndex(Script *img, header *scr, line_t *line);
        static const char *chkForeach(Script *img, header *scr, line_t *line);
        static const char *chkCase(Script *img, header *scr, line_t *line);
        static const char *chkEndcase(Script *img, header *scr, line_t *line);
        static const char *chkOtherwise(Script *img, header *scr, line_t *line);
        static const char *chkIf(Script *img, header *scr, line_t *line);
        static const char *chkElif(Script *img, header *scr, line_t *line);
        static const char *chkElse(Script *img, header *scr, line_t *line);
        static const char *chkEndif(Script *img, header *scr, line_t *line);
        static const char *chkDefine(Script *img, header *scr, line_t *line);
        static const char *chkInvoke(Script *img, header *scr, line_t *line);
        static const char *chkWhen(Script *img, header *scr, line_t *line);
        static const char *chkStrict(Script *img, header *scr, line_t *line);
        static const char *chkExpr(Script *img, header *scr, line_t *line);
        static const char *chkRef(Script *img, header *scr, line_t *line);
        static const char *chkIgnmask(Script *img, header *scr, line_t *line);
    };

    typedef struct {
        header *scr;            
        header *scope;          
        event_t *event;         
        line_t *line;           
        line_t *ignore;         
        unsigned short index;   
        unsigned short base;    
        unsigned short resmask; 
    } stack_t;

    class __EXPORT interp : protected memalloc
    {
    public:
        typedef char num_t[16];

        interp();
        virtual ~interp();

        bool step(void);

        bool attach(Script *image, const char *entry = NULL);

        void detach(void);

        void initialize(void);

        bool error(const char *text);

        unsigned getResource(void);

        const char *getFilename(void);

    protected:
        symbol *find(const char *id);
        void skip(void);
        void push(void);
        bool trylabel(const char *id);
        bool tryexit(void);
        void pullScope(void);
        void pullBase(void);
        void pullLoop(void);
        bool pop(void);
        void setStack(header *scr, event *ev = NULL);

        bool scriptEvent(const char *name);

        event *scriptMethod(const char *name);

        stack_t *stack;
        object_pointer<Script> image;
        LinkedObject **syms;
        unsigned frame;

        char *getTemp(void);
        bool setConst(const char *id, const char *value);
        symbol *createSymbol(const char *id);
        symbol *getVar(const char *id, const char *value = NULL);
        const char *getValue(void);
        const char *getContent(void);
        const char *getContent(const char *text);
        const char *getKeyword(const char *id);
        method_t getLooping(void);
        bool isConditional(unsigned index);
        void setRef(header *scope, const char *id, char *data, unsigned size);
        void getParams(header *scope, line_t *line);
        void startScript(header *scr);

        virtual unsigned getTypesize(const char *type_id);
        virtual const char *getTypeinit(const char *type_id);
        virtual const char *getFormat(symbol *sym, const char *id, char *temp);
        virtual bool getCondition(const char *test, const char *value);
        const char *getIndex(void);

    private:
        __DELETE_COPY(interp);

        bool getExpression(unsigned index);

        char *errmsg;
        char *temps[3];
        unsigned tempindex;
    };

    class __EXPORT error : public OrderedObject
    {
    private:
        friend class Script;

        __DELETE_DEFAULTS(error);

        error(Script *img, unsigned line, const char *str);

    public:
        const char *filename;
        char *errmsg;
        unsigned errline;
    };

    class __EXPORT methods : public interp
    {
    private:
        __DELETE_DEFAULTS(methods);

    public:
        bool scrPush(void);
        bool scrApply(void);
        bool scrExpr(void);
        bool scrVar(void);
        bool scrSet(void);
        bool scrAdd(void);
        bool scrClear(void);
        bool scrConst(void);
        bool scrPause(void);
        bool scrNop(void);
        bool scrPack(void);
        bool scrExpand(void);
        bool scrExit(void);
        bool scrReturn(void);
        bool scrError(void);
        bool scrRestart(void);
        bool scrGosub(void);
        bool scrGoto(void);
        bool scrDo(void);
        bool scrLoop(void);
        bool scrUntil(void);
        bool scrWhile(void);
        bool scrBreak(void);
        bool scrContinue(void);
        bool scrForeach(void);
        bool scrPrevious(void);
        bool scrRepeat(void);
        bool scrIndex(void);
        bool scrCase(void);
        bool scrEndcase(void);
        bool scrOtherwise(void);
        bool scrIf(void);
        bool scrElif(void);
        bool scrElse(void);
        bool scrEndif(void);
        bool scrDefine(void);
        bool scrInvoke(void);
        bool scrWhen(void);
        bool scrRef(void);
        bool scrIgnore(void);
    };

    ~Script();

    static unsigned stepping;   
    static unsigned indexing;   
    static size_t paging;       
    static unsigned sizing;     
    static unsigned stacking;   
    static unsigned decimals;   
    LinkedObject *scheduler;    
    static Script *compile(Script *merge, const char *filename, Script *config = NULL);

    static void assign(keyword_t *list);

    static keyword_t *find(const char *id);

    static void init(void);

    static unsigned offset(const char *list, unsigned index);
    static void copy(const char *list, char *item, unsigned size);
    static unsigned count(const char *list);
    static const char *get(const char *list, unsigned offset);
    static char *get(char *list, unsigned offset);
    static header *find(Script *img, const char *id);
    static bool isEvent(header *scr, const char *id);

    header *first;
    LinkedObject **scripts;

    bool push(line_t *line);
    method_t pull(void);
    method_t looping(void);

    inline unsigned getErrors(void)
        {return errors;}

    inline LinkedObject *getListing(void)
        {return errlist.begin();}

    inline const char *getFilename(void)
        {return filename;}

    inline bool isStrict(void)
        {return global != NULL;}

    inline unsigned getLines(void)
        {return lines;}

private:
    friend class strict;
    friend class checks;
    friend class error;
    friend class interp;
    friend class methods;

    __DELETE_COPY(Script);

    Script();

    void errlog(unsigned line, const char *fmt, ...);

    unsigned long instance;
    unsigned errors;
    unsigned loop;
    unsigned lines;
    bool thencheck;
    line_t **stack;
    LinkedObject *global;
    OrderedIndex errlist;
    object_pointer<Script> shared;
    const char *filename;
    unsigned serial;
    LinkedObject *headers;
};

} // namespace ucommon

#endif