bayonnescript.h

Go to the documentation of this file.

// Copyright (C) 1999-2001 Open Source Telecom Corporation.
//  
// 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 2 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, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception to the GNU General Public License, permission is 
// granted for additional uses of the text contained in its release 
// of ccscript.
// 
// The exception is that, if you link the ccscript library with other
// files to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the ccscript library code into it.
// 
// This exception does not however invalidate any other reasons why
// the executable file might be covered by the GNU General Public License.
// 
// This exception applies only to the code released under the
// name ccscript.  If you copy code from other releases into a copy of
// ccscript, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
// 
// If you write modifications of your own for ccscript, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.  

#ifndef CCXX_BAYONNESCRIPT_H_
#define CCXX_BAYONNESCRIPT_H_

#ifndef CCXX_MISC_H_
#include <cc++/misc.h>
#endif

#ifndef CCXX_FILE_H_
#include <cc++/file.h>
#endif

#ifndef CCXX_BUFFER_H_
#include <cc++/buffer.h>
#endif

#include <iostream>
#include <fstream>

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

class __EXPORT ScriptCommand;
class __EXPORT ScriptImage;
class __EXPORT ScriptInterp;
class __EXPORT ScriptData;

#define MAX_LOCKS 8
#define TRAP_BITS (sizeof(unsigned long) * 8)
#define SCRIPT_STACK_SIZE 31
#define SCRIPT_TEMP_SPACE 16
#define KEYWORD_INDEX_SIZE 37
#define SYMBOL_INDEX_SIZE 187
#define SCRIPT_INDEX_SIZE KEYWORD_INDEX_SIZE
#define SCRIPT_MAX_ARGS 256
#define SCRIPT_RELEASE  3

class __EXPORT Script
{
protected:
        class __EXPORT Line;

public:
        typedef bool (ScriptInterp::*Method)(void);
        typedef char *(ScriptCommand::*Check)(Line *line, ScriptImage *img);
        typedef bool (*Cond)(ScriptInterp *interp, const char *v);
        typedef long (*Function)(long *args, unsigned prec);
        typedef char *(*Meta)(ScriptInterp *interp, const char *token);
        typedef const char * (*Parse)(ScriptImage *img, const char *token);
        typedef void (*Init)(void);

        enum    SymType
        {
                NORMAL = 0,
                ALIAS,
                FIFO,
                SEQUENCE,
                STACK,
                COUNTER,
                POINTER,
                REF,
                CACHE,
                ARRAY,
                RECORD
        };
        typedef enum SymType SymType;

#pragma pack(1)
        typedef struct _symbol
        {
                struct _symbol *next;
                const char *id;
                struct
                {
                        unsigned size : 16;
                        bool initial : 1;
                        bool system : 1;
                        bool readonly : 1;
                        bool commit : 1;
                        bool large : 1;
                        SymType type : 6;
                } flags;
                char data[1];
        }       Symbol;

        class __EXPORT Test
        {
        public:
                const char *id;
                Cond handler;
                Test *next;
        };

        class __EXPORT Attr
        {
        public:
                const char *id;
                Meta meta;
                Attr *next;
        };

        class __EXPORT Fun
        {
        public:
                const char *id;
                unsigned args;
                Function fn;
                Fun *next;
        };

        class __EXPORT PreParse
        {
        public:
                const char *id;
                Parse parse;
                PreParse *next;
        };

        class __EXPORT InitScript
        {
        public:
                Init handler;
                InitScript *next;
        };

protected:
        class __EXPORT Line
        {
        public:
                Line *next;
                unsigned long cmask;
                unsigned long mask;
                bool hold : 1;
                bool sync : 1;
                unsigned loop : 14;
                unsigned argc : 8;
                unsigned line : 10;
                unsigned lnum : 14;
                Method method;
                char *cmd;
                char **args;
        };

public:
        class __EXPORT Name
        {
        public:
                class __EXPORT Event
                {
                public:
                        Event *next;
                        Line *line;
                        char type;
                        const char *name;
                }       *events;

                Name *next;
                Line *first;
                Line *trap[TRAP_BITS];
                unsigned long mask;
                char *name;
                char *filename;
                enum Mode
                {
                        mORIGINAL,
                        mCOPIED,
                        mCOPY,
                        mDATA
                } mode : 4;
                enum Access
                {
                        aPUBLIC,
                        aPROTECTED,
                        aPRIVATE,
                        aFUNCTION
                } access : 4;
                typedef enum Mode Mode;
                typedef enum Access Access;
        };

        class __EXPORT Initial
        {
        public:
                const char *name;
                unsigned size;
                const char *value;
        };

        class __EXPORT Define
        {
        public:
                const char *keyword;
                Method method;
                Check check;
        };

public:

#pragma pack()

        class __EXPORT Locks : private ThreadLock, private MemPager
        {
        private:
                typedef struct _lock
                {
                        struct _lock *next;
                        unsigned count;
                        ScriptInterp *owner;
                        char id[1];
                }       lck;

                unsigned count;
                unsigned getIndex(const char *id);
                lck *hash[KEYWORD_INDEX_SIZE];

        public:
                void release(ScriptInterp *interp);
                bool lock(ScriptInterp *interp, const char *id);
                bool unlock(ScriptInterp *interp, const char *id);

                Locks();
        };

        class __EXPORT Package : public DSO
        {
        public:
                static Package *first;
                Package *next;
                char *filename;

                Package(const char *name);
        };

        static bool use(const char *name);

        class __EXPORT Property
        {
        private:
                friend class __EXPORT ScriptInterp;

                static Property *first;
                Property *next;
                const char *id;

        protected:
                virtual void setProperty(char *data, char *temp, unsigned size) = 0;

                virtual long getValue(const char *data)
                        {return atol(data);};

                virtual void setValue(char *data, unsigned len, long value)
                        {snprintf(data, len + 1, "%ld", value);};

                virtual bool isProperty(const char *data)
                        {return false;};

                virtual void getProperty(char *data, char *temp, unsigned size) = 0;

//              virtual void adjProperty(char *data, size_t size, int adjust)
//                      {return;};

                virtual long adjustValue(long value)
                        {return value;};

                virtual unsigned getPropertySize(void)
                        {return 0;};

                Property(const char *name);

        public:
                static Property* find(const char *name);        
        };
};



class __EXPORT ScriptModule : public Script
{
private:
        friend class __EXPORT ScriptInterp;
        friend class __EXPORT ScriptCommand;
        friend class __EXPORT ScriptImage;
        static ScriptModule *first;
        static PreParse *preparse;
        static InitScript *inits;
        ScriptModule *next;
        const char *cmd;
        Method handler;         // posted handler to invoke

protected:
        virtual void moduleAttach(ScriptInterp *interp)
                {return;};

        virtual void moduleDetach(ScriptInterp *interp, const char *id)
                {return;};

public:
        virtual char *parseScript(ScriptInterp *interp, Line *line)
                {return NULL;};

protected:
        virtual char *checkScript(Line *line, ScriptImage *img)
                {return NULL;};

        ScriptModule(const char *name, Script::Method method = NULL);

public:
        static ScriptModule *find(const char *name);

        static void addPreparse(const char *id, Parse p);

        static void addInit(Init p);

        static void init(void);


};

class __EXPORT ScriptCommand : public Keydata, public Mutex, public Script
{
private:
        friend class __EXPORT ScriptImage;
        friend class __EXPORT ScriptInterp;
        friend class __EXPORT ScriptModule;

#pragma pack(1)
        typedef struct _keyword
        {
                struct _keyword *next;
                Method method;
                Check check;
                char keyword[1];
        }       Keyword;
#pragma pack()


        ThreadQueue *tq;
        Keyword *keywords[KEYWORD_INDEX_SIZE];
        char *traps[TRAP_BITS];
        ScriptImage *active;
        int keyword_count;
        int trap_count;
        unsigned long imask;
        bool copied;
        unsigned dbcount;
        void *dbc;

protected:
        unsigned activity;      // activity counter

        Method getHandler(const char *keyword);

        char *check(char *command, Line *line, ScriptImage *img);

        virtual unsigned getTrapId(const char *trap);

        virtual unsigned long getTrapDefault(void)
                {return 0x00000003;};

        virtual unsigned long getTrapHandler(Name *scr)
                {return getTrapDefault();}

        virtual unsigned long getTrapMask(unsigned id);

        virtual unsigned long getTrapModifier(const char *trapname)
                {return getTrapMask(trapname);};

        virtual unsigned long getTrapMask(const char *trapname);

public:
        char *chkIgnore(Line *line, ScriptImage *img);

        char *chkModule(Line *line, ScriptImage *img);

        char *chkUse(Line *line, ScriptImage *img);

        char *chkHasModify(Line *line, ScriptImage *img);

        char *chkHasVars(Line *line, ScriptImage *img);

        char *chkHasList(Line *line, ScriptImage *img);

        char *chkNoArgs(Line *line, ScriptImage *img);

        char *chkHasArgs(Line *line, ScriptImage *img);

protected:
        void load(Script::Define *keywords);

        int trap(const char *name, bool inherited = true);

        inline int getCount(void)
                {return trap_count;};

        bool isInherited(unsigned id);

        virtual char *check(Check chk, Line *line, ScriptImage *img)
                {return (this->*(chk))(line, img);};

        ScriptCommand();

        ScriptCommand(ScriptCommand *ini);

public:
        Mutex dblock;   // database lock object.

        inline unsigned getActivity(void)
                {return activity;};

        inline bool isCopied(void)
                {return copied;};

        void *getDatabase(void);

        void setDatabase(void *dbc);

        void *endDatabase(void);

        bool setThreadQueue(ThreadQueue *tq);

        inline ThreadQueue *getThreadQueue(void)
                {return tq;};
};

class __EXPORT ScriptSymbol : public SharedMemPager, public Script
{
private:
        friend class __EXPORT ScriptInterp;

        unsigned symsize, symlimit;
        Symbol *index[SYMBOL_INDEX_SIZE + 1];
        char _idname[33];
        const char *setName(const char *id);

        unsigned getIndex(const char *symbol);

protected:
        Symbol **record;

public:
        virtual Symbol *getEntry(const char *symbol, unsigned size = 0);

        void setExclusive(bool enable);

public:
        virtual void commit(Symbol *sym);

        inline unsigned getSymbolSize(void)
                {return symsize;};

        ScriptSymbol(unsigned size, size_t pgsize = 1024, const char *name = NULL);
        ~ScriptSymbol();

        void *getPointer(const char *symbol);

        bool setPointer(const char *symbol, void *data);

        bool setStruct(const char *symbol);

        char *getSymbol(const char *symbol);

        char *setSymbol(const char *symbol, const char *value = "");

        char *setConst(const char *symbol, const char *value = "");

        bool makeArray(const char *id, unsigned char count, unsigned short recsize);

        bool makeSequence(const char *id, unsigned char count, unsigned char recsize);

        /*
         * Creating a cache object (looping lifo)
         *
         * @return false if fail.
         * @param name of cache.
         * @param max. number of sequences.
         * @param size of cache data record.
         */
        bool makeCache(const char *id, unsigned char count, unsigned char recsize);

        bool makeStack(const char *id, unsigned char count, unsigned char recsize);

        bool makeFifo(const char *id, unsigned char count, unsigned char recsize);

        bool makeCounter(const char *id);

        bool postSymbol(Symbol *sym, const char *value);


        bool removeSymbol(Symbol *sym, const char *value);

        char *readSymbol(Symbol *sym);

        bool setAlias(const char *symbol, const char *source);

        bool swapSymbol(const char *oldname, const char *newname);

        Symbol *getAlias(const char *symbol);

        char *setSymbol(const char *symbol, int size = 0);

        void clrSymbol(const char *id);

        void purge(void);

        unsigned gather(Symbol **index, unsigned max, const char *prefrix, const char *suffix = "");
};

class __EXPORT ScriptImage : public Keydata, public Script
{
protected:
        std::ifstream scrSource;
        std::istream *scrStream;
        ScriptCommand *cmds;
        int refcount;
        Name *index[SCRIPT_INDEX_SIZE + 1];
        char *buffer;
        unsigned bufsize;
        char *bp;
        bool quote;
        unsigned paren;
        Mutex duplock;
        unsigned inccount;
        const char *incfiles[256];
        
        class   InitialList : public Script::Initial
        {
        public:
                InitialList *next;
        }       *ilist;

        friend class __EXPORT ScriptInterp;
        friend class __EXPORT ScriptModule;

public:
        char *getToken(char **pre = NULL);

protected:
        Method getHandler(const char *keyword)
                {return cmds->getHandler(keyword);};

        ScriptImage(ScriptCommand *cmdset, const char *symset);

        void purge(void);

        Name *include(const char *scrfile);

        int compile(const char *scrfile);

        int compile(const char *scrfile, char *name);

        int compile(std::istream *str, char *name, const char *scrname = NULL);

        void commit(void);

        virtual const char *getDefined(const char *token)
                {return getLast(token);};

        void load(Initial *ilist);

        void initial(const char *keyword, const char *value, unsigned size = 0);

        const char *preproc(const char *token);

public:
        virtual Name *getScript(const char *name);

        virtual Name *dupScript(const char *name, const char *target);

        unsigned gather(const char *suffix, Name **array, unsigned size);

        inline std::istream *getSource(void)
                {return (std::istream *)&scrSource;};
};

class __EXPORT ScriptInterp : public ScriptSymbol
{
private:
        friend class __EXPORT ScriptImage;
        friend class __EXPORT Script::Locks;
        friend class __EXPORT ScriptModule;
        friend class __EXPORT ScriptData;

#pragma pack(1)
        class __EXPORT Context
        {
        public:
                Name *script;
                Line *line, *read, *first;
                unsigned short index;
                ScriptSymbol *local;
                bool caseflag : 1;
                bool tranflag : 1;
                bool advance : 1;
                unsigned decimal : 3;
                unsigned base : 6;
                unsigned long mask;
        };
#pragma pack()

        static Attr *attr;
        static Test *test;
        static Fun *ifun;
        static Locks locks;

protected:
        ScriptCommand *cmd;
        ScriptImage *image;
        Context script[SCRIPT_STACK_SIZE + 1];
        char *temps[SCRIPT_TEMP_SPACE];
        int tempidx;
        unsigned stack;
        unsigned symsize;
        size_t pgsize;
        unsigned long signalmask;
        bool once, warn, trace, initialized;
        unsigned steps;
        ScriptSymbol *recmode;

        bool scrRestart(void);
        bool scrEnable(void);
        bool scrDisable(void);
        bool scrUse(void);
        bool scrLoadable(void);
        bool scrPack(void);
        bool scrUnpack(void);
        bool scrOn(void);
        bool scrSlog(void);
        bool scrBasename(void);
        bool scrDirname(void);
        bool scrFullpath(void);
        bool scrGather(void);
        bool scrDump(void);
        bool scrInc(void);
        bool scrDec(void);
        bool scrFifo(void);
        bool scrMin(void);
        bool scrMax(void);
        bool scrCounter(void);
        bool scrReset(void);
        bool scrRemove(void);
        bool scrPost(void);
        bool scrPostList(void);
        bool scrStack(void);
        bool scrCache(void);
        bool scrArray(void);
        bool scrIndex(void);
        bool scrSequence(void);
        bool scrDup(void);
        bool scrArm(void);
        bool scrDisarm(void);
        bool scrNumber(void);
        bool scrDecimal(void);
        bool scrLocal(void);
        bool scrSet(void);
        bool scrAlias(void);
        bool scrRef(void);
        bool scrConst(void);
        bool scrVar(void);
        bool scrSize(void);
        bool scrInit(void);
        bool scrClear(void);
        bool scrCall(void);
        bool scrHas(void);
        bool scrMissing(void);
        bool scrLabel(void);
        bool scrCase(void);
        bool scrEndcase(void);
        bool scrError(void);
        bool scrStruct(void);
        bool scrIfThen(void);
        bool scrThen(void);
        bool scrElse(void);
        bool scrEndif(void);
        bool scrBegin(void);
        bool scrEnd(void);
        bool scrFor(void);
        bool scrRead(void);
        bool scrMap(void);
        bool scrRepeat(void);
        bool scrForeach(void);
        bool scrFordata(void);
        bool scrFordatasource(void);
        bool scrForarray(void);
        bool scrTryeach(void);
        bool scrSwap(void);
        bool scrDo(void);
        bool scrLoop(void);
        bool scrBreak(void);
        bool scrContinue(void);
        bool scrReturn(void);
        bool scrPop(void);
        bool scrSelect(void);
        bool scrOnce(void);
        bool scrLock(void);
        bool scrTry(void);
        bool scrSkip(void);
        bool expConditional(void);

public:
        virtual const char *getPrefixPath(void)
                {return getKeyword("prefix");};
                
        static long getRealValue(double val, unsigned prec);
        long getIntValue(const char *text, unsigned prec, Property *property = NULL);
        int getExpression(long *list, int max, unsigned prec, Property *property = NULL);
        static double getDouble(long value, unsigned prec);
        static long getInteger(long value, unsigned prec);
        static long getTens(unsigned prec);

        static void addFunction(const char *name, unsigned count, Function i);
        static void addConditional(const char *name, Cond test);
        static void addAttribute(const char *name, Meta meta);
        friend class __EXPORT ScriptCommand;

protected:
        inline void setCommand(ScriptCommand *sc)
                {cmd = sc;};

        char _idname[33];
        unsigned char lckcount;
        ScriptData *datasource;

        ScriptInterp(ScriptCommand *cmd, unsigned symsize, size_t pgsize = 1024, const char *name = NULL);

        ~ScriptInterp();

public:
        void setLocal(void);

        void clrLocal(void);

        ScriptSymbol *getSymbols(void)
                {return script[stack].local;};

        bool setVariable(const char *id, unsigned size, const char *value = NULL);
                                                                                
        const char *getVariable(const char *id);

protected:
        bool getOnce(void);

        inline void Notify(unsigned long mask)
                {signalmask |= mask;};

        inline void Notify(const char *str)
                {signalmask |= cmd->getTrapMask(str);};

        unsigned long getMask(void);

        void setLine(Line *line);

        inline unsigned long getScriptMask(const char *id)
                {return cmd->getTrapMask(id);};

public:
        inline ScriptCommand *getCommand(void)
                {return cmd;};

protected:
        bool conditional(void);

        bool scrExit(void);

        bool scrGoto(void);

        bool scrRaise(void);

        bool intGoto(bool event = false);

        virtual void evtGoto(void)
                {return;};

public:
        virtual void cleardigits(bool all)
                {return;};

        virtual char getdigit(void)
                {return 0;};

protected:
        bool scrIf(void);

        bool ifGoto(void);

        bool scrData(void);

        virtual unsigned getId(void)
                {return 0;};


        virtual bool getGlobalTrap(unsigned id)
                {return false;};

public:
        bool setData(const char *scrname);

        char getPackToken(void);

        void clrTransactions(void)
                {script[stack].tranflag = false;};

        Symbol *initVariable(unsigned size = 0);

        void rewindTemp(void);

        void setTemp(const char *value);

public:
        void advance(void);

        void error(const char *error);

protected:
        void trap(unsigned id);

        void trap(const char *trapname);

        bool push(void);

        bool pull(void);

        void clearStack(void);

        unsigned long getScriptMask(void);

        bool signal(const char *trapname);

        virtual bool event(const char *evtname, bool inheret = true);

        bool signal(unsigned trapid);

        virtual bool execute(Method method)
                {return (this->*(method))();};

        virtual void stop(unsigned long mask)
                {return;};

        virtual void exit(void) = 0;

        Name *getScriptImage(const char *label);

        Name *getScriptCopy(const char *src);

        virtual void sleepScheduler(timeout_t timeout)
                {return;};

        virtual void stepScheduler(const char *trapname)
                {trap(trapname);};

        virtual void setExclusive(bool enable)
                {return;};

        void initRuntime(Name *name);

        virtual void initialize(void)
                {return;};

public:
        Symbol *getLocal(const char *name, unsigned size = 0);

        bool attach(const char *scrname);

        void detach(void);

        bool redirect(const char *scrname);

        bool step(void);

        inline bool isActive(void)
                {return (script[stack].line != NULL);};

        char *getOption(const char *def = NULL);

        char *getKeyword(const char *keyword);

        unsigned initKeywords(unsigned size);

        char *getValue(const char *def = NULL);

        char *getString(void);

        char *getTempBuffer(void);

        void missing(const char *sym);

        char *getContent(char *sym);

        inline Line *getScript(void)
                {return script[stack].line;};

        inline bool hasEvents(void)
                {return (script[stack].script->events != NULL);};

        const char *getMember(void);

        inline Name *getObject(void)
                {return script[stack].script;};

        inline ScriptImage *getImage(void)
                {return image;};

        inline void warning(bool enable)
                {warn = enable;};

        inline unsigned getDecimal(void)
                {return script[stack].decimal;};
};

class __EXPORT ScriptData : public Script
{
protected:
        friend class __EXPORT ScriptInterp;
        
        virtual bool isId(const char *id) = 0;

        virtual bool fetch(ScriptInterp *interp, unsigned row) = 0;

        inline void setSource(ScriptInterp *interp)
                {interp->datasource = this;};
};

#ifdef  CCXX_NAMESPACES
}
#endif

#endif

---