script3.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 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, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  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 GNU
// ccScript.  If you copy code from other releases into a copy of GNU
// 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 GNU 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_SCRIPT3_H_
#define CCXX_SCRIPT3_H_

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

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

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

#define TRAP_BITS (sizeof(unsigned long) * 8)
#define SCRIPT_INDEX_SIZE KEYDATA_INDEX_SIZE
#define SCRIPT_MAX_ARGS 250
#define SCRIPT_TEMP_SPACE 16
#define SCRIPT_STACK_SIZE 32
#define SCRIPT_ROUTE_SLOTS 16
#define SCRIPT_EXEC_WRAPPER
#define SCRIPT_APPS_WRAPPER
#define SCRIPT_RIPPLE_LEVEL 2
#define SCRIPT_RIPPLE_KEYDATA
#define SCRIPT_BINDER_SELECT
#define SCRIPT_SERVER_PREFIX
#define SCRIPT_DEFINE_TOKENS

#ifndef CCXX_PACKING
#if defined(__GNUC__)
#define CCXX_PACKED
#elif !defined(__hpux) && !defined(_AIX)
#define CCXX_PACKED
#endif
#endif

namespace ost {

class __EXPORT ScriptRegistry;
class __EXPORT ScriptCommand;
class __EXPORT ScriptImage;
class __EXPORT ScriptInterp;
class __EXPORT ScriptSymbols;
class __EXPORT ScriptProperty;
class __EXPORT ScriptThread;
class __EXPORT ScriptCompiler;

class __EXPORT Script
{
public:
        class __EXPORT Line;
        class __EXPORT Name;

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

        enum scrAccess {
                scrPUBLIC,
                scrPROTECTED,
                scrPRIVATE,
                scrFUNCTION,
                scrLOCAL
        };

        typedef enum scrAccess scrAccess;

        enum symType {
                symNORMAL = 0,
                symCONST,
                symDYNAMIC,
                symFIFO,
                symSEQUENCE,
                symSTACK,
                symCOUNTER,
                symPOINTER,
                symREF,
                symARRAY,
                symASSOC,
                symINITIAL,
                symNUMBER,
                symLOCK,
                symPROPERTY,
                symORIGINAL,
                symMODIFIED,
                symTIMER,
                symBOOL
        };

        typedef enum symType symType;

        typedef struct _symbol {
                struct _symbol *next;
                const char *id;
                unsigned short size;
                symType type: 8;
                char data[1];
        }       Symbol;

#ifdef CCXX_PACKED
#pragma pack(1)
#endif

        typedef struct _array {
                unsigned short head, tail, rec, count;
        }       Array;

#ifdef  CCXX_PACKED
#pragma pack()
#endif

public:
        class __EXPORT Line
        {
        public:
                Line *next;
                union {
                        ScriptRegistry *registry;
                        Method method;
                        Name *name;
                }       scr;
                const char *cmd, **args;
                unsigned long cmask, mask;
                unsigned short loop, line, lnum;
                unsigned short argc;
        };

        class __EXPORT NamedEvent
        {
        public:
                NamedEvent *next;
                Line *line;
                char type;
                const char *name;
        };

        class __EXPORT Name
        {
        public:
                Name *next;
                NamedEvent *events;
                Line *first, *select;
                Line *trap[TRAP_BITS];
                unsigned long mask;
                const char *name, *filename;
                scrAccess access;
        };

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

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

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

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

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

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

                Package(const char *name);
        };

        static bool fastStart;
        static bool useBigmem;
        static unsigned fastStepping;
        static unsigned autoStepping;
        static size_t pagesize;
        static unsigned symsize;
        static unsigned symlimit;

        static bool isScript(Name *scr);
        static bool isSymbol(const char *id);
        static bool use(const char *name);
        static unsigned getIndex(const char *id);
        static Symbol *deref(Symbol *sym);
        static bool commit(Symbol *sym, const char *value);
        static bool append(Symbol *sym, const char *value);
        static bool symindex(Symbol *sym, short offset);
        static const char *extract(Symbol *sym);
        static unsigned count(Symbol *sym);
        static unsigned storage(Symbol *sym);
        static void clear(Symbol *sym);
        static char decimal;
        static bool use_definitions;
        static bool use_macros;
        static bool use_prefix;
        static bool use_merge;
        static bool use_funcs;
        static const char *plugins;
        static const char *altplugins;
        static const char *access_user;
        static const char *access_pass;
        static const char *access_host;
        static bool exec_funcs;
        static const char *exec_extensions;
        static const char *exec_token;
        static const char *exec_prefix;
        static const char *exit_token;
        static const char *apps_extensions;
        static const char *apps_prefix;

        static const char *etc_prefix;
        static const char *var_prefix;
        static const char *log_prefix;

        static void addFunction(const char *name, unsigned count, Function i);
        static void addConditional(const char *name, Cond test);

        static bool isPrivate(Name *scr);
        static bool isFunction(Name *scr);

protected:
        static Test *test;
        static Fun *ifun;

};

class __EXPORT ScriptSymbols : public MemPager, public Script
{
protected:
        Symbol *index[SCRIPT_INDEX_SIZE + 1];

        void purge(void);

public:
        ScriptSymbols();
        ~ScriptSymbols();

        inline const char *cstring(const char *str)
                {return MemPager::alloc(str);};

        unsigned gathertype(Symbol **idx, unsigned max, const char *prefix, symType group);
        unsigned gather(Symbol **idx, unsigned max, const char *prefix, const char *suffix);
        Symbol *find(const char *id, unsigned short size = 0);
        Symbol *make(const char *id, unsigned short size);

        Symbol *setReference(const char *id, Symbol *target);
};

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

#ifdef  CCXX_PACKED
#pragma pack(1)
#endif

        typedef struct _keyword {
                struct _keyword *next;
                Method method;
                Check check;
                bool init : 1;
                char keyword[1];
        }       Keyword;

#ifdef  CCXX_PACKED
#pragma pack()
#endif

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

protected:
        bool ripple;
        unsigned activity;      // activity counter
        static ScriptCommand *runtime;

        virtual const char *getExternal(const char *opt);

public:
        virtual bool isInput(Line *line);

        Method getHandler(const char *keyword);

        bool control(char **args);

        inline ScriptImage *getActive(void)
                {return active;};

        const char *getTrapName(unsigned id);

        void aliasModule(const char *id, const char *use);

protected:
        bool isInitial(const char *keyword);

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

        virtual unsigned getTrapId(const char *name);

        virtual unsigned long getTrapDefault(void);

        virtual unsigned long getTrapHandler(Name *script);

        virtual unsigned long getTrapMask(unsigned id);

        virtual unsigned long getTrapModifier(const char *name);

        virtual unsigned long getTrapMask(const char *name);

        static bool hasKeywords(Line *line);

public:
        static const char *findKeyword(Line *line, const char *keyword);

        static const char *findKeyword(ScriptImage *img, Line *line, const char *keyword);

        virtual void errlog(const char *level, const char *text);

public:
        static bool useKeywords(Line *line, const char *list);

        static unsigned getCount(Line *line);

        static const char *getMember(Line *line);


protected:
        static bool useMember(Line *line, const char *list);

        static const char *getOption(Line *line, unsigned *index);

        void load(Script::Define *keywords);

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

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

        bool isInherited(unsigned id);

        virtual const char *check(Check chk, Line *line, ScriptImage *img);

public:
        ScriptCommand();

        ScriptCommand(ScriptCommand *ini);

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

};

class __EXPORT ScriptBinder : public Script
{
private:
        friend class __EXPORT ScriptInterp;
        friend class __EXPORT ScriptCompiler;
        friend class __EXPORT ScriptCommand;

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

protected:
        void bind(Script::Define *extensions);

        virtual void attach(ScriptInterp *interp);
        virtual void detach(ScriptInterp *interp);
        virtual bool select(ScriptInterp *interp);
        virtual bool reload(ScriptCompiler *img);
        virtual bool control(ScriptImage *img, char **args);
        virtual void down(void);
        virtual const char *use(Line *line, ScriptImage *img);

public:
        ScriptBinder(const char *id = NULL);
        ScriptBinder(Script::Define *extensions);
        virtual ~ScriptBinder();

        static const char *check(Line *line, ScriptImage *img);
        static void shutdown(void);
        static bool rebuild(ScriptCompiler *img);
};

class __EXPORT ScriptRuntime : public ScriptCommand
{
public:
        ScriptRuntime();
};

class __EXPORT ScriptRipple : public ScriptCommand
{
public:
        ScriptRipple();
};

class __EXPORT ScriptChecks : public ScriptCommand
{
public:
        const char *chkIgnore(Line *line, ScriptImage *img);

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

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

        const char *chkProperty(Line *line, ScriptImage *img);

        const char *chkFirstVar(Line *line, ScriptImage *img);

        const char *chkType(Line *line, ScriptImage *img);

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

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

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

        const char *chkAllVars(Line *line, ScriptImage *img);

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

        const char *chkOnlyArgs(Line *line, ScriptImage *img);

        const char *chkOnlyOneArg(Line *line, ScriptImage *img);

        const char *chkRefArgs(Line *line, ScriptImage *img);

        const char *chkSlog(Line *line, ScriptImage *img);

        const char *chkExpression(Line *line, ScriptImage *img);

        const char *chkConditional(Line *line, ScriptImage *img);

        const char *chkGoto(Line *line, ScriptImage *img);

        const char *chkLabel(Line *line, ScriptImage *img);

        const char *chkCall(Line *line, ScriptImage *img);

        const char *chkReturn(Line *line, ScriptImage *img);

        const char *chkRestart(Line *line, ScriptImage *img);

        const char *chkVar(Line *line, ScriptImage *img);

        const char *chkVarType(Line *line, ScriptImage *img);

        const char *chkDecimal(Line *line, ScriptImage *img);

        const char *chkNumber(Line *line, ScriptImage *img);

        const char *chkString(Line *line, ScriptImage *img);

        const char *chkChar(Line *line, ScriptImage *img);

        const char *chkExpr(Line *line, ScriptImage *img);

        const char *chkIndex(Line *line, ScriptImage *img);

        const char *chkError(Line *line, ScriptImage *img);

        const char *chkConst(Line *line, ScriptImage *img);

        const char *chkSequence(Line *line, ScriptImage *img);

        const char *chkSignal(Line *line, ScriptImage *img);

        const char *chkThrow(Line *line, ScriptImage *img);

        const char *chkSet(Line *line, ScriptImage *img);

        const char *chkRepeat(Line *line, ScriptImage *img);

        const char *chkArray(Line *line, ScriptImage *img);

        const char *chkFor(Line *line, ScriptImage *img);

        const char *chkForeach(Line *line, ScriptImage *img);

        const char *chkCat(Line *line, ScriptImage *img);

        const char *chkRemove(Line *line, ScriptImage *img);

        const char *chkOnlyCommand(Line *line, ScriptImage *img);

        const char *chkCounter(Line *line, ScriptImage *img);

        const char *chkTimer(Line *line, ScriptImage *img);

        const char *chkClear(Line *line, ScriptImage *img);

        const char *chkPack(Line *line, ScriptImage *img);

        const char *chkConstruct(Line *line, ScriptImage *img);

        const char *chkLock(Line *line, ScriptImage *img);

        const char *chkSession(Line *line, ScriptImage *img);

        const char *chkKeywords(Line *line, ScriptImage *img);

        const char *chkDefine(Line *line, ScriptImage *img);
};

class __EXPORT ScriptObject : public Script
{
private:
        friend class __EXPORT ScriptImage;
        ScriptObject *next;

protected:
        ScriptObject(ScriptImage *image);
        virtual ~ScriptObject();
};

class __EXPORT ScriptImage : public Keydata, public Script, public Assoc
{
protected:
        friend class __EXPORT ScriptObject;

        ScriptCommand *cmds;
        unsigned refcount;
        Name *index[SCRIPT_INDEX_SIZE + 1], *current;
        Line *select, *selecting, *registration;
        Line *advertising[SCRIPT_ROUTE_SLOTS];
        Mutex duplock;
        ScriptObject *objects;
        static unsigned long serial;
        unsigned long instance;

        class   __EXPORT InitialList : public Script::Initial
        {
        public:
                InitialList *next;
        }       *ilist;

        friend class __EXPORT ScriptInterp;

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

public:
        void *getMemory(size_t size);

        const char *dupString(const char *str);

        virtual void fastBranch(ScriptInterp *interp);

        inline Name *getCurrent(void)
                {return current;};

        void addSelect(Line *line);

        void addRegistration(Line *line);

        ScriptRegistry *getRegistry(void);

        void addRoute(Line *line, unsigned pri);

        inline Line *getSelect(void)
                {return select;};

        inline Line *getRegistration(void)
                {return registration;};

        inline Line *getRoute(unsigned pri)
                {return advertising[pri];};

        inline unsigned long getInstance(void)
                {return instance;};

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

        ~ScriptImage();

        void purge(void);

        void commit(void);

        void load(Initial *ilist);

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

        virtual Name *getScript(const char *name);

        inline ScriptCommand *getCommand(void)
                {return cmds;};

        bool isRipple(void)
                {return cmds->ripple;};

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

        inline void incRef(void)
                {++refcount;};

        inline void decRef(void)
                {--refcount;};

        inline bool isRef(void)
                {return (bool)(refcount > 0);};

        inline ScriptImage *getActive(void)
                {return cmds->getActive();};
};

class __EXPORT ScriptCompiler : public ScriptImage
{
protected:
        std::ifstream scrSource;
        std::istream *scrStream;
        char *buffer;
        unsigned bufsize;
        char *bp;
        bool quote;
        unsigned paren;
        unsigned inccount;
        const char *incfiles[256];

        typedef struct _merge {
                struct _merge *next;
                Name *target;
                const char *source;
                const char *prefix;
        }       merge_t;

        merge_t *mlist;

        friend class __EXPORT ScriptInterp;

        virtual bool checkSegment(Name *scr);

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

        virtual void fastBranch(ScriptInterp *interp);

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

        Name *include(const char *name);

        int compile(const char *file);

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

        int compileDefinitions(const char *file);

        int compile(std::istream *stream, char *name, const char *file = NULL);

        void commit(void);

        virtual const char *getDefined(const char *token);

        const char *preproc(const char *token);

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

class __EXPORT ScriptInterp : public Mutex, public ScriptSymbols
{
protected:
        friend class __EXPORT ScriptThread;
        friend class __EXPORT ScriptCommand;
        friend class __EXPORT ScriptBinder;

public:
        class __EXPORT Frame
        {
        public:
                Name *script;
                Line *line, *first;
                unsigned short index;
                ScriptSymbols *local;
                unsigned long mask;
                bool caseflag : 1;
                bool tranflag : 1;
                bool unused1 : 1;
                bool unused2 : 1;
                unsigned decimal : 4;
                unsigned base : 8;
        };

        static long getRealValue(double val, unsigned prec);
        static double getDouble(long value, unsigned prec);
        static long getInteger(long value, unsigned prec);
        static long getTens(unsigned prec);
        long getIntValue(const char *text, unsigned prec, ScriptProperty *property = NULL);
        int numericExpression(long *list, int max, unsigned prec, ScriptProperty *property = NULL);
        bool conditionalExpression(void);
        bool conditional(void);

protected:
        Mutex *lock;    // any additional lock that is siezed
        ScriptCommand *cmd;
        ScriptImage *image;
        ScriptInterp *session;
        ScriptThread *thread;
        Frame frame[SCRIPT_STACK_SIZE];
        char *temps[SCRIPT_TEMP_SPACE];
        unsigned tempidx;
        unsigned stack;
        bool initialized, trace, exiting, updated;
        unsigned long sequence;
        char logname[32];

public:
        virtual unsigned getId(void);

        inline unsigned long getSequence(void)
                {return sequence;};

        virtual const char *getLogname(void)
                {return logname;};

        virtual ScriptInterp *getInterp(const char *id);

        virtual const char *getExternal(const char *opt);

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

protected:
        virtual ScriptSymbols *getSymbols(const char *id);

        ScriptSymbols *getLocal(void);

public:
        const char *getMember(void);
        const char *getKeyword(const char *kw);
        const char *getKeyoption(const char *kw);
        const char *getValue(const char *def = NULL);
        const char *getOption(const char *def = NULL);
        const char *hasOption(void);
        const char *getContent(const char *opt);
        const char *getSymContent(const char *opt);
        Symbol *getKeysymbol(const char *kw, unsigned size = 0);
        Symbol *getSymbol(unsigned short size = 0);
        char getPackToken(void);

protected:
        void initRuntime(Name *name);

        virtual void initialize(void);

public:
        inline Frame *getFrame(void)
                {return &frame[stack];};

        inline Line *getLine(void)
                {return frame[stack].line;};

        void setFrame(void);

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

        inline bool getTrace(void)
                {return trace;};

        bool execute(Method method);

protected:
        bool push(void);

        bool pull(void);

        void clearStack(void);

        void advance(void);

        void skip(void);

        void error(const char *error);

        bool scriptEvent(const char *name, bool inhereted = true);

        void gotoEvent(NamedEvent *event);

        void trap(unsigned id);

        bool tryCatch(const char *id);

        void trap(const char *name);

public:
        virtual void logmissing(const char *id, const char *level = "undefined", const char *group = "symbol");
        virtual void logerror(const char *msg, const char *name = NULL);

        Symbol *mapSymbol(const char *id, unsigned short = 0);
        Symbol *mapDirect(const char *id, unsigned short = 0);

protected:
        virtual bool isLocked(const char *id);
        virtual const char *remapLocal(void);
        virtual bool exit(void);
        virtual void enterThread(ScriptThread *thread);
        virtual void exitThread(const char *msg);
        virtual void waitThread(void);
        virtual void startThread(void);

        bool eventThread(const char *evt, bool flag = true);

        bool redirect(const char *scr);

        void ripple(void);

        bool redirect(bool evflag);

        unsigned long getMask(void);

public:
        bool setNumber(const char *id, const char *value = NULL, unsigned dec = 0);
        bool setSymbol(const char *id, const char *value = NULL, unsigned short size = 0);
        bool setConst(const char *id, const char *value);
        bool putSymbol(const char *id, const char *value, unsigned short size = 0);
        bool getSymbol(const char *id, char *buffer, unsigned short max);
        bool catSymbol(const char *id, const char *value, unsigned short size = 0);

        const char *getSymbol(const char *id);

        Name *getScript(const char *name);

        ScriptInterp();

        bool step(void);
        bool attach(ScriptCommand *cmd, const char *scrname);
        void detach(void);
        void attach(ScriptCommand *cmd, ScriptImage *img, Name *scr);

        void release(void);

        bool signal(const char *name);

        bool signal(unsigned id);

        bool done(void);

        timeout_t getTimeout(void);

        virtual void branching(void);

        inline bool isRunning(void)
                {return (image != NULL) && initialized;};

        inline bool isExiting(void)
                {return exiting;};

        char *getTemp(void);

        unsigned getTempSize(void);
};

class __EXPORT ScriptMethods : public ScriptInterp
{
public:
        bool scrNop(void);
        bool scrError(void);
        bool scrExit(void);
        bool scrDecimal(void);
        bool scrDefine(void);
        bool scrVar(void);
        bool scrType(void);
        bool scrNumber(void);
        bool scrSlog(void);
        bool scrExpr(void);
        bool scrIndex(void);
        bool scrOffset(void);
        bool scrRef(void);
        bool scrRestart(void);
        bool scrInit(void);
        bool intGoto(void);
        bool scrGoto(void);
        bool scrCall(void);
        bool scrReturn(void);
        bool scrBegin(void);
        bool scrEnd(void);
        bool scrConst(void);
        bool scrSequence(void);
        bool scrSet(void);
        bool scrArray(void);
        bool scrClear(void);
        bool scrConstruct(void);
        bool scrDeconstruct(void);
        bool scrPack(void);
        bool scrUnpack(void);
        bool scrLock(void);
        bool scrSession(void);
        bool scrSignal(void);
        bool scrThrow(void);
        bool scrInvoke(void);
        bool scrCounter(void);
        bool scrTimer(void);
        bool scrCase(void);
        bool scrEndcase(void);
        bool scrRemove(void);
        bool scrDo(void);
        bool scrRepeat(void);
        bool scrFor(void);
        bool scrForeach(void);
        bool scrLoop(void);
        bool scrContinue(void);
        bool scrBreak(void);
        bool scrIf(void);
        bool scrIfThen(void);
        bool scrThen(void);
        bool scrElse(void);
        bool scrEndif(void);
};

class __EXPORT ScriptThread : public Thread, public Script
{
private:
        volatile bool exiting;
        size_t stacksize;

protected:
        friend class __EXPORT ScriptInterp;

        ScriptInterp *interp;

        void exit(const char *errmsg = NULL);

        void exitEvent(const char *evt, bool inherited = true);

        inline bool isExiting(void)
                {return exiting;};

        inline bool putSymbol(const char *id, const char *value, unsigned short size = 0)
                {return interp->putSymbol(id, value, size);};

        inline bool getSymbol(const char *id, char *buffer, unsigned short max)
                {return interp->getSymbol(id, buffer, max);};

        inline bool addSymbol(const char *id, char *buffer, unsigned short max)
                {return interp->getSymbol(id, buffer, max);};

        void block(void);

        void unblock(void);

        void lock(void);

        void release(void);

public:
        virtual timeout_t getTimeout(void);

        inline size_t getStack(void)
                {return stacksize;};

        ScriptThread(ScriptInterp *interp, int pri = 0, size_t stack = 0);
        ~ScriptThread();
};

class __EXPORT ScriptRegistry : public Script, public TimerPort
{
public:
        const char *protocol;
        timeout_t duration;
        Name *scr;              // script being registered
        Line *line;             // line of registry statement
};

class __EXPORT ScriptProperty : public Script
{
private:
        friend class ScriptInterp;

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

public:
        virtual void set(const char *data, char *temp, unsigned size) = 0;

        virtual unsigned prec(void);

        virtual void setValue(char *data, unsigned short size, long value);

        virtual bool isProperty(const char *data);

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

        virtual char token(void);

        virtual void adjust(char *data, size_t size, long adjustment);

        virtual long adjustValue(long value);

        virtual long getValue(const char *data);

        ScriptProperty(const char *name);
        virtual ~ScriptProperty();

        static ScriptProperty *find(const char *name);
};

}

#endif