yatescript.h

 
#ifndef __YATESCRIPT_H
#define __YATESCRIPT_H
 
#include <yateclass.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYSCRIPT_EXPORTS
#define YSCRIPT_API __declspec(dllexport)
#else
#ifndef LIBYSCRIPT_STATIC
#define YSCRIPT_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YSCRIPT_API
#define YSCRIPT_API
#endif

namespace TelEngine {
 
class ExpEvaluator;
class ExpOperation;
class ScriptMutex;

class YSCRIPT_API ExpExtender
{
public:
    virtual ~ExpExtender()
        { }

    virtual RefObject* refObj();

    virtual bool hasField(ObjList& stack, const String& name, GenObject* context) const;

    virtual NamedString* getField(ObjList& stack, const String& name, GenObject* context) const;

    virtual bool runFunction(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runField(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runAssign(ObjList& stack, const ExpOperation& oper, GenObject* context);
};

class YSCRIPT_API ParsePoint
{
public:
    explicit inline ParsePoint(const char*& expr, ExpEvaluator* eval = 0, unsigned int lineNo = 0,
                        const char* fileName = 0, const char* seps = 0)
        : m_expr(expr), m_searchedSeps(seps), m_count(0), m_foundSep(0), m_lineNo(lineNo), m_eval(eval), m_fileName(fileName)
        { }

    ParsePoint& operator=(ParsePoint& parsePoint);

    ParsePoint& operator=(unsigned int line);

    inline operator const char*&()
        { return m_expr; }

    inline ParsePoint& operator=(const char* newExpr)
    {
        m_expr = newExpr;
        return *this;
    }

    inline ParsePoint& operator++() // prefix
    {
        ++m_expr;
        return *this;
    }

    inline ParsePoint& operator++(int unused) // postfix
    {
        ++m_expr;
        return *this;
    }

    inline char firstChar()
        { return *m_expr; }

    inline unsigned lineNumber() const
        { return m_lineNo; }

    const char* m_expr;

    const char* m_searchedSeps;

    unsigned int m_count;

    char m_foundSep;

    unsigned int m_lineNo;

    ExpEvaluator* m_eval;

    String m_fileName;
};

class YSCRIPT_API ExpEvaluator : public DebugEnabler
{
    friend class ParsePoint;
public:
    enum Parser {
        C,
        SQL,
    };

    enum Opcode {
        // FORTH style notation of effect on stack, C-syntax expression
        OpcNone = 0,// ( --- )
        OpcNull,    // ( --- A)
        OpcPush,    // ( --- A)
        OpcDrop,    // (A --- )
        OpcDup,     // (A --- A A)
        OpcSwap,    // (A B --- B A)
        OpcRot,     // (A B C --- B C A)
        OpcOver,    // (A B --- A B A)
        // Arithmetic operators
        OpcAdd,     // (A B --- A+B)
        OpcSub,     // (A B --- A-B)
        OpcMul,     // (A B --- A*B)
        OpcDiv,     // (A B --- A/B)
        OpcMod,     // (A B --- A%B)
        OpcNeg,     // (A --- -A)
        OpcIncPre,  // (A --- ++A)
        OpcDecPre,  // (A --- --A)
        OpcIncPost, // (A --- A++)
        OpcDecPost, // (A --- A--)
        // Bitwise logic operators
        OpcAnd,     // (A B --- A&B)
        OpcOr,      // (A B --- A|B)
        OpcXor,     // (A B --- A^B)
        OpcNot,     // (A --- ~A)
        OpcShl,     // (A B --- A<<B)
        OpcShr,     // (A B --- A>>B)
        // Boolean logic operators
        OpcLAnd,    // (A B --- A&&B)
        OpcLOr,     // (A B --- A||B)
        OpcLXor,    // (A B --- A^^B)
        OpcLNot,    // (A --- !A)
        // String concatenation
        OpcCat,     // (A B --- A.B)
        // String matching
        OpcReM,     // (A B --- Amatch/B/)
        OpcReIM,    // (A B --- Amatch_insensitive/B/)
        OpcReNm,    // (A B --- A!match/B/)
        OpcReINm,   // (A B --- A!match_insensitive/B/)
        OpcLike,    // (A B --- AlikeB)
        OpcILike,   // (A B --- Alike_insensitiveB)
        OpcNLike,   // (A B --- A!likeB)
        OpcNIlike,  // (A B --- A!like_insensitiveB)
        // Comparation operators
        OpcEq,      // (A B --- A==B)
        OpcNe,      // (A B --- A!=B)
        OpcGt,      // (A B --- A>B)
        OpcLt,      // (A B --- A<B)
        OpcGe,      // (A B --- A>=B)
        OpcLe,      // (A B --- A<=B)
        // Ternary conditional operator
        OpcCond,    // (A B C --- A?B:C)
        // Field naming operator
        OpcAs,      // (A B --- A[name=B])
        // Field replacement
        OpcField,   // (A --- A)
        // Call of function with N parameters
        OpcFunc,    // (... funcN --- func(...))
        // Label for a jump
        OpcLabel,   // ( --- )
        // Push with deep copy
        OpcCopy,    // ( --- CopiedA)
        // Nullish coalescing
        OpcNullish, // (A B --- A??B)
        // Field assignment - can be ORed with other binary operators
        OpcAssign  = 0x0100, // (A B --- B,(&A=B))
        // Private extension area for derived classes
        OpcPrivate = 0x1000
    };

    explicit ExpEvaluator(const TokenDict* operators = 0, const TokenDict* unaryOps = 0);

    explicit ExpEvaluator(Parser style);

    ExpEvaluator(const ExpEvaluator& original);

    virtual ~ExpEvaluator();

    int compile(ParsePoint& expr, GenObject* context = 0);

    bool evaluate(ObjList* results, GenObject* context = 0) const;

    inline bool evaluate(ObjList& results, GenObject* context = 0) const
        { return evaluate(&results,context); }

    int evaluate(NamedList& results, unsigned int index = 0, const char* prefix = 0, GenObject* context = 0) const;

    int evaluate(Array& results, unsigned int index, GenObject* context = 0) const;

    inline bool simplify()
        { return trySimplify(); }

    inline bool inError() const
        { return m_inError; }

    inline unsigned int lineNumber() const
        { return m_lineNo; }

    virtual bool null() const;

    void dump(const ObjList& codes, String& res, bool lineNo = false) const;

    virtual void dump(String& res, bool lineNo = false) const;

    inline String dump(const ObjList& codes, bool lineNo = false) const
        { String s; dump(codes,s,lineNo); return s; }

    inline String dump(bool lineNo = false) const
        { String s; dump(s,lineNo); return s; }

    inline const TokenDict* operators() const
        { return m_operators; }

    inline const TokenDict* unaryOps() const
        { return m_unaryOps; }

    inline ExpExtender* extender() const
        { return m_extender; }

    void extender(ExpExtender* ext);

    static unsigned int getLineOf(ExpOperation* op1, ExpOperation* op2 = 0, ExpOperation* op3 = 0);

    static void pushOne(ObjList& stack, ExpOperation* oper);

    static ExpOperation* popOne(ObjList& stack);

    static ExpOperation* popAny(ObjList& stack);

    virtual ExpOperation* popValue(ObjList& stack, GenObject* context = 0) const;

    virtual bool runOperation(ObjList& stack, const ExpOperation& oper, GenObject* context = 0) const;

    virtual bool runAllFields(ObjList& stack, GenObject* context = 0) const;
 
protected:
    virtual char skipWhites(ParsePoint& expr);

    inline static char condLower(char chr, bool makeLower)
        { return (makeLower && ('A' <= chr) && (chr <= 'Z')) ? (chr + ('a' - 'A')) : chr; }

    Opcode getOperator(const char*& expr, const TokenDict* operators, bool caseInsensitive = false) const;

    virtual bool keywordLetter(char c) const;

    virtual bool keywordDigit(char c) const;

    virtual bool keywordChar(char c) const;

    virtual int getKeyword(const char* str) const;

    bool gotError(const char* error = 0, const char* text = 0, unsigned int line = 0) const;

    bool gotError(const char* error = 0, const char* text = 0, unsigned int line = 0);

    inline bool gotError(const char* error, unsigned int line) const
        { return gotError(error, 0, line); }

    inline bool gotError(const char* error, unsigned int line)
        { return gotError(error, 0, line); }

    virtual void formatLineNo(String& buf, unsigned int line) const;

    bool runCompile(ParsePoint& expr, char stop, GenObject* nested = 0);

    virtual bool runCompile(ParsePoint& expr, const char* stop = 0, GenObject* nested = 0);

    virtual char skipComments(ParsePoint& expr, GenObject* context = 0);

    virtual int preProcess(ParsePoint& expr, GenObject* context = 0);

    virtual Opcode getOperator(ParsePoint& expr);

    virtual Opcode getUnaryOperator(ParsePoint& expr);

    virtual Opcode getPostfixOperator(ParsePoint& expr, int precedence = 0);

    virtual const char* getOperator(Opcode oper) const;

    virtual int getPrecedence(Opcode oper) const;

    virtual bool getRightAssoc(Opcode oper) const;

    virtual bool getSeparator(ParsePoint& expr, bool remove);

    virtual bool getInstruction(ParsePoint& expr, char stop = 0, GenObject* nested = 0);

    virtual bool getOperand(ParsePoint& expr, bool endOk = true, int precedence = 0);

    virtual bool getSimple(ParsePoint& expr, bool constOnly = false);

    virtual bool getNumber(ParsePoint& expr);

    virtual bool getString(ParsePoint& expr);

    virtual bool getFunction(ParsePoint& expr);

    virtual bool getString(const char*& expr, String& str);

    virtual bool getEscape(const char*& expr, String& str, char sep);

    virtual bool getField(ParsePoint& expr);

    void addOpcode(ExpOperation* oper, unsigned int line = 0);

    ExpOperation* addOpcode(Opcode oper, bool barrier = false, unsigned int line = 0);

    ExpOperation* addOpcode(Opcode oper, int64_t value, bool barrier = false);

    ExpOperation* addOpcode(const String& value);

    ExpOperation* addOpcode(int64_t value);

    ExpOperation* addOpcode(bool value);

    ExpOperation* addOpcode(Opcode oper, const String& name, int64_t value = 0,
        bool barrier = false, unsigned int line = 0);

    ExpOperation* popOpcode();

    virtual bool trySimplify();

    virtual bool runEvaluate(const ObjList& opcodes, ObjList& stack, GenObject* context = 0) const;

    virtual bool runEvaluate(const ObjVector& opcodes, ObjList& stack, GenObject* context = 0, unsigned int index = 0) const;

    virtual bool runEvaluate(ObjList& stack, GenObject* context = 0) const;

    virtual bool runFunction(ObjList& stack, const ExpOperation& oper, GenObject* context = 0) const;

    virtual bool runField(ObjList& stack, const ExpOperation& oper, GenObject* context = 0) const;

    virtual bool runAssign(ObjList& stack, const ExpOperation& oper, GenObject* context = 0) const;

    virtual void dump(const ExpOperation& oper, String& res, bool lineNo = false) const;

    const TokenDict* m_operators;

    const TokenDict* m_unaryOps;

    ObjList m_opcodes;

    ObjList* m_lastOpcode;

    bool m_inError;

    unsigned int m_lineNo;
 
private:
    bool getOperandInternal(ParsePoint& expr, bool endOk, int precedence);
    ExpExtender* m_extender;
};

class YSCRIPT_API ExpOperation : public NamedString
{
    friend class ExpEvaluator;
    YCLASS(ExpOperation,NamedString)
public:
    inline static int64_t nonInteger()
        { return LLONG_MIN; }

    inline ExpOperation(const ExpOperation& original)
        : NamedString(original.name(),original),
          m_opcode(original.opcode()), m_number(original.number()), m_bool(original.isBoolean()),
          m_isNumber(original.isNumber()), m_lineNo(original.lineNumber()), m_barrier(original.barrier())
        { }

    inline ExpOperation(const ExpOperation& original, const char* name, bool copyType = true)
        : NamedString(name,original),
          m_opcode(copyType ? original.opcode() : ExpEvaluator::OpcPush),
          m_number(original.number()), m_bool(original.isBoolean()),
          m_isNumber(original.isNumber()), m_lineNo(original.lineNumber()), m_barrier(original.barrier())
        { }

    inline explicit ExpOperation(const String& value, const char* name = 0, bool autoNum = false)
        : NamedString(name,value),
          m_opcode(ExpEvaluator::OpcPush),
          m_number(autoNum ? value.toInt64(nonInteger()) : nonInteger()),
          m_bool(autoNum && value.isBoolean()),
          m_isNumber(autoNum && (value == YSTRING("NaN") || m_number != nonInteger())),
          m_lineNo(0), m_barrier(false)
        { if (m_bool) { m_number = value.toBoolean() ? 1 : 0; m_isNumber = true;} }

    inline explicit ExpOperation(const char* value, const char* name = 0)
        : NamedString(name,value),
          m_opcode(ExpEvaluator::OpcPush), m_number(nonInteger()), m_bool(false),
          m_isNumber(false), m_lineNo(0), m_barrier(false)
        { }

    inline explicit ExpOperation(int64_t value, const char* name = 0)
        : NamedString(name,"NaN"),
          m_opcode(ExpEvaluator::OpcPush),
          m_number(value), m_bool(false), m_isNumber(true), m_lineNo(0), m_barrier(false)
        { if (value != nonInteger()) String::operator=(value); }

    inline explicit ExpOperation(bool value, const char* name = 0)
        : NamedString(name,String::boolText(value)),
          m_opcode(ExpEvaluator::OpcPush),
          m_number(value ? 1 : 0), m_bool(true), m_isNumber(true),
          m_lineNo(0), m_barrier(false)
        { }

    inline ExpOperation(ExpEvaluator::Opcode oper, const char* name = 0, int64_t value = nonInteger(), bool barrier = false)
        : NamedString(name,""),
          m_opcode(oper), m_number(value), m_bool(false), m_isNumber(false),
          m_lineNo(0), m_barrier(barrier)
        { }

    inline ExpOperation(ExpEvaluator::Opcode oper, const char* name, const char* value, bool barrier = false)
        : NamedString(name,value),
          m_opcode(oper), m_number(nonInteger()), m_bool(false), m_isNumber(false),
          m_lineNo(0), m_barrier(barrier)
        { }

    inline ExpOperation(ExpEvaluator::Opcode oper, const char* name, const char* value, int64_t number, bool barrier)
        : NamedString(name,value),
          m_opcode(oper), m_number(number), m_bool(false), m_isNumber(true),
          m_lineNo(0), m_barrier(barrier)
        { }

    inline ExpEvaluator::Opcode opcode() const
        { return m_opcode; }

    inline bool isInteger() const
        { return m_number != nonInteger(); }

    inline int64_t number() const
        { return m_number; }

    inline bool isBoolean() const
        { return m_bool; }

    inline bool isNumber() const
        { return m_isNumber; }

    inline bool barrier() const
        { return m_barrier; }

    inline unsigned int lineNumber() const
        { return m_lineNo; }

    inline void lineNumber(unsigned int line)
        { m_lineNo = line; }

    inline int64_t operator=(int64_t num)
        { m_number = num; String::operator=(num); m_isNumber = true; return num; }

    virtual int64_t valInteger(int64_t defVal = 0) const;

    virtual int64_t toNumber() const;

    virtual bool valBoolean(bool defVal = false) const;

    virtual const char* typeOf() const;

    virtual ExpOperation* clone(const char* name) const;

    inline ExpOperation* clone() const
        { return clone(name()); }

    virtual ExpOperation* copy(ScriptMutex* mtx) const
        { return clone(); }
 
private:
    ExpEvaluator::Opcode m_opcode;
    int64_t m_number;
    bool m_bool;
    bool m_isNumber;
    unsigned int m_lineNo;
    bool m_barrier;
};

class YSCRIPT_API ExpFunction : public ExpOperation
{
    YCLASS(ExpFunction,ExpOperation)
public:
    inline ExpFunction(const char* name, long int argc = 0, bool barrier = false)
        : ExpOperation(ExpEvaluator::OpcFunc,name,argc,barrier)
        { if (name) (*this) << "[function " << name << "()]"; }

    virtual bool valBoolean(bool defVal = false) const
        { return true; }

    virtual ExpOperation* clone(const char* name) const;
};

class YSCRIPT_API ExpWrapper : public ExpOperation
{
public:
    inline ExpWrapper(GenObject* object, const char* name = 0, bool barrier = false)
        : ExpOperation(ExpEvaluator::OpcPush,name,
            object ? object->toString().c_str() : (const char*)0,barrier),
          m_object(object)
        { }

    inline ExpWrapper(ExpEvaluator::Opcode opcode, GenObject* object, const char* name = 0)
        : ExpOperation(opcode,name,object ? object->toString().c_str() : (const char*)0,false),
          m_object(object)
        { }

    virtual ~ExpWrapper()
        { TelEngine::destruct(m_object); }

    virtual void* getObject(const String& name) const;

    virtual bool valBoolean(bool defVal = false) const;

    virtual const char* typeOf() const;

    virtual ExpOperation* clone(const char* name) const;

    virtual ExpOperation* copy(ScriptMutex* mtx) const;

    GenObject* object() const
        { return m_object; }
 
private:
    GenObject* m_object;
};

class YSCRIPT_API TableEvaluator
{
public:
    TableEvaluator(const TableEvaluator& original);

    TableEvaluator(ExpEvaluator::Parser style);

    TableEvaluator(const TokenDict* operators, const TokenDict* unaryOps);

    virtual ~TableEvaluator();

    virtual bool evalWhere(GenObject* context = 0);

    virtual bool evalSelect(ObjList& results, GenObject* context = 0);

    virtual unsigned int evalLimit(GenObject* context = 0);

    void extender(ExpExtender* ext);
 
protected:
    ExpEvaluator m_select;
    ExpEvaluator m_where;
    ExpEvaluator m_limit;
    unsigned int m_limitVal;
};
 
class ScriptRun;

class YSCRIPT_API ScriptMutex : public Mutex
{
public:
    inline ScriptMutex(bool recursive, const char* name)
        : Mutex(recursive,name), m_objTrack(false)
        { }

    virtual void objCreated(GenObject* obj) = 0;

    virtual void objDeleted(GenObject* obj) = 0;

    inline bool objTrack() const
        { return m_objTrack; }
 
protected:
    bool m_objTrack;
};
 

class YSCRIPT_API ScriptContext : public RefObject, public ExpExtender
{
public:
    inline explicit ScriptContext(const char* name = 0)
        : m_params(name)
        { }

    inline NamedList& params()
        { return m_params; }

    inline const NamedList& params() const
        { return m_params; }

    virtual NamedList* nativeParams() const
        { return 0; }

    virtual const String& toString() const
        { return m_params; }

    virtual void* getObject(const String& name) const;

    virtual RefObject* refObj()
        { return this; }

    virtual ScriptMutex* mutex() = 0;

    virtual bool hasField(ObjList& stack, const String& name, GenObject* context) const;

    virtual NamedString* getField(ObjList& stack, const String& name, GenObject* context) const;

    virtual void fillFieldNames(ObjList& names);

    static void fillFieldNames(ObjList& names, const NamedList& list, bool checkDupl = true, const char* skip = 0);

    static void fillFieldNames(ObjList& names, const HashList& list);

    virtual bool runFunction(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runField(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runAssign(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool copyFields(ObjList& stack, const ScriptContext& original, GenObject* context);

    virtual void addFields(const NamedList& list, const char* skipPrefix = "__");

    bool runMatchingField(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual void createdObj(GenObject* obj)
        {  }

    virtual void deletedObj(GenObject* obj)
        {  }

    virtual void trackObjs(unsigned int track = 0)
        {  }

    virtual ObjList* countAllocations()
        { return 0; }
 
private:
    NamedList m_params;
};

class YSCRIPT_API ScriptCode : public RefObject
{
    YCLASS(ScriptCode,RefObject)
public:
    virtual bool initialize(ScriptContext* context) const = 0;

    virtual bool evaluate(ScriptRun& runner, ObjList& results) const = 0;

    virtual ScriptRun* createRunner(ScriptContext* context, const char* title = 0)
        { return 0; }

    virtual void getFileLine(unsigned int line, String& fileName, unsigned int& fileLine, bool wholePath = true)
        { }
};

class YSCRIPT_API ScriptStack : public ObjList
{
    YCLASS(ScriptStack,ObjList)
    YNOCOPY(ScriptStack);
public:
    ScriptStack(ScriptRun* owner)
        : m_runner(owner)
        { }

    inline ScriptRun* runner()
        { return m_runner; }
 
private:
    ScriptRun* m_runner;
};

class YSCRIPT_API ScriptAsync : public GenObject
{
    YCLASS(ScriptAsync,GenObject)
public:
    ScriptAsync(ScriptRun* owner)
        : m_runner(owner)
        { }

    virtual ~ScriptAsync()
        { }

    inline ScriptRun* runner()
        { return m_runner; }

    virtual bool run() = 0;
 
private:
    ScriptRun* m_runner;
};

class YSCRIPT_API ScriptRun : public GenObject, public ScriptMutex
{
    friend class ScriptCode;
    YCLASS(ScriptRun,GenObject)
    YNOCOPY(ScriptRun);
public:
    enum Status {
        Invalid,
        Running,
        Incomplete,
        Succeeded,
        Failed,
    };

    ScriptRun(ScriptCode* code, ScriptContext* context = 0);

    virtual ~ScriptRun();

    inline ScriptCode* code() const
        { return m_code; }

    inline ScriptContext* context() const
        { return m_context; }

    inline Status state() const
        { return m_state; }

    static const char* textState(Status state);

    inline const char* textState() const
        { return textState(m_state); }

    inline ObjList& stack()
        { return m_stack; }

    inline const ObjList& stack() const
        { return m_stack; }

    inline ScriptRun* clone() const
        { return new ScriptRun(code(),context()); }

    virtual Status reset(bool init = false);

    virtual Status execute();

    virtual Status run(bool init = true);

    virtual bool pause();

    virtual Status call(const String& name, ObjList& args,
        ExpOperation* thisObj = 0, ExpOperation* scopeObj = 0);

    virtual bool callable(const String& name);

    virtual bool insertAsync(ScriptAsync* oper);

    virtual bool appendAsync(ScriptAsync* oper);

    virtual unsigned int currentLineNo() const
        { return 0; }

    virtual const String& currentFileName(bool wholePath = false) const
        { return String::empty(); }

    virtual const String& traceId() const
        { return m_traceId; }

    virtual void setTraceId(const String& tid)
        { m_traceId = tid; }

    bool runAssign(const ExpOperation& oper, GenObject* context = 0);
 
    void objCreated(GenObject* obj)
        { if (m_context) m_context->createdObj(obj); };
    void objDeleted(GenObject* obj)
        { if (m_context) m_context->deletedObj(obj); };
 
protected:
    virtual Status resume();
 
private:
    ScriptCode* m_code;
    ScriptContext* m_context;
    Status m_state;
    ObjList m_stack;
    ObjList m_async;
    String m_traceId;
};

class YSCRIPT_API ScriptParser : public GenObject
{
    YCLASS(ScriptParser,GenObject)
public:
    virtual ~ScriptParser();

    virtual bool parse(const char* text, bool fragment = false, const char* file = 0, int len = -1) = 0;

    virtual bool parseFile(const char* name, bool fragment = false);

    inline void clear()
        { setCode(0); }

    inline ScriptCode* code() const
        { return m_code; }

    inline void setMaxFileLen(unsigned int len)
        { m_maxFileLen = len; }

    inline unsigned int maxFileLen() const
        { return m_maxFileLen; }

    virtual ScriptContext* createContext() const;

    virtual ScriptRun* createRunner(ScriptCode* code, ScriptContext* context = 0, const char* title = 0) const;

    inline ScriptRun* createRunner(ScriptContext* context = 0, const char* title = 0) const
        { return createRunner(code(),context,title); }

    virtual bool callable(const String& name);
 
protected:
    inline ScriptParser()
        : m_code(0), m_maxFileLen(500000)
        { }

    void setCode(ScriptCode* code);
 
private:
    ScriptCode* m_code;
    unsigned int m_maxFileLen;
};
 
class JsFunction;

class YSCRIPT_API JsObject : public ScriptContext
{
    friend class JsFunction;
    YCLASS(JsObject,ScriptContext)
public:
    enum DumpFlags {
        DumpFunc = 0x01,                 // Dump functions
        DumpProp = 0x02,                 // Dump non functions (data)
        DumpRecursive = 0x10,            // Dump recursive (stop on root if not set)
        DumpType = 0x20,                 // Dump type (apply to functions also),
        DumpProto = 0x40,                // Dump prototype
        DumpPropObjType = 0x80,          // Dump non basic type for DumpPropOnly whithout DumpType 
        // Masks
        DumpFuncOnly = DumpRecursive | DumpProto | DumpFunc,
        DumpPropOnly = DumpRecursive | DumpPropObjType | DumpProp,
    };

    JsObject(const char* name = "Object", ScriptMutex* mtx = 0, bool frozen = false);

    JsObject(ScriptMutex* mtx, const char* name, unsigned int line, bool frozen = 0);

    JsObject(GenObject* context, unsigned int line, ScriptMutex* mtx = 0, bool frozen = false);

    virtual ~JsObject();

    virtual ScriptMutex* mutex()
        { return m_mutex; }

    virtual JsObject* clone(const char* name, const ExpOperation& oper ) const
        { return new JsObject(m_mutex,name,oper.lineNumber()); }

    inline JsObject* clone(const ExpOperation& oper) const
        { return clone(toString(),oper); }

    void setPrototype(GenObject* context, const String& objName);

    virtual JsObject* copy(ScriptMutex* mtx, const ExpOperation& oper) const;

    virtual void fillFieldNames(ObjList& names);

    virtual const HashList* getHashListParams() const;

    virtual bool hasField(ObjList& stack, const String& name, GenObject* context) const;

    virtual NamedString* getField(ObjList& stack, const String& name, GenObject* context) const;

    virtual void initConstructor(JsFunction* construct)
        { }

    virtual JsObject* runConstructor(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runFunction(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runField(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runAssign(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual ExpOperation* popValue(ObjList& stack, GenObject* context = 0);

    virtual void clearField(const String& name)
        { params().clearParam(name); }

    inline bool setIntField(const char* name, int64_t val)
    {
        if (!name)
            return false;
        params().setParam(new ExpOperation(val,name));
        return true;
    }

    inline bool setBoolField(const char* name, bool val)
    {
        if (!name)
            return false;
        params().setParam(new ExpOperation(val,name));
        return true;
 
    }

    inline bool setStringField(const char* name, const char* val)
    {
        if (!name)
            return false;
        params().setParam(new ExpOperation(val,name));
        return true;
    }

    inline bool setObjField(const char* name, JsObject* obj)
    {
        if (!(name && obj))
            return false;
        params().setParam(new ExpWrapper(obj,name));
        return true;
    }

    bool getIntField(const String& name, int64_t& val);

    bool getBoolField(const String&  name, bool& val);

    bool getStringField(const String& name, String& val);

    bool getObjField(const String& name, JsObject*& obj);

    inline bool frozen() const
        { return m_frozen; }

    inline void freeze()
        { m_frozen = true; }

    inline void lineNo(unsigned int line)
        { m_lineNo = line; }

    inline unsigned int lineNo() const
        { return m_lineNo; }

    static void addObject(NamedList& params, const char* name, JsObject* obj);

    static void addConstructor(NamedList& params, const char* name, JsObject* obj);

    static int extractArgs(JsObject* obj, ObjList& stack, const ExpOperation& oper,
        GenObject* context, ObjList& arguments);

    inline int extractArgs(ObjList& stack, const ExpOperation& oper, GenObject* context, ObjList& arguments)
        { return extractArgs(this,stack,oper,context,arguments); }

    static JsObject* buildCallContext(ScriptMutex* mtx, JsObject* thisObj = 0);

    static void initialize(ScriptContext* context);

    static void setLineForObj(JsObject* obj,unsigned int lineNo, bool recursive);

    inline static const String& protoName()
        { return s_protoName; }

    static void deepCopyParams(NamedList& dst, const NamedList& src, ScriptMutex* mtx);

    static void dumpRecursive(const GenObject* obj, String& buf, unsigned int flags = 0xffffffff);

    static void printRecursive(const GenObject* obj, unsigned int flags = 0xffffffff);

    static ExpOperation* toJSON(const ExpOperation* oper, int spaces);
 
protected:
    virtual bool runNative(ObjList& stack, const ExpOperation& oper, GenObject* context);

    inline ScriptMutex* mutex() const
        { return m_mutex; }

    inline void setMutex(ScriptMutex* mtx)
        { m_mutex = mtx; }

    static inline void toJSON(const NamedString* ns, String& buf, int spaces, int indent = 0)
        { internalToJSON(ns,true,buf,spaces,indent); }

    static String strEscape(const char* str);
 
private:
    static void internalToJSON(const GenObject* obj, bool isStr, String& buf, int spaces, int indent = 0);    
    static const String s_protoName;
    bool m_frozen;
    ScriptMutex* m_mutex;
    unsigned int m_lineNo; // creation line for this object;
};

class YSCRIPT_API JsFunction : public JsObject
{
    YCLASS(JsFunction,JsObject)
public:
    JsFunction(ScriptMutex* mtx = 0);

    JsFunction(ScriptMutex* mtx, const char* name, unsigned int line, ObjList* args = 0, long int lbl = 0,
        ScriptCode* code = 0);

    virtual bool runDefined(ObjList& stack, const ExpOperation& oper, GenObject* context, JsObject* thisObj = 0);

    virtual void initConstructor(JsFunction* construct);

    inline const ExpFunction* getFunc() const
        { return &m_func; }

    inline void firstName(const char* name)
        { if (m_func.name().null()) const_cast<String&>(m_func.name()) = name; }

    inline const String* formalName(unsigned int index) const
        { return static_cast<const String*>(m_formal[index]); }

    inline long int label() const
        { return m_label; }

    inline JsObject* copy(ScriptMutex* mtx, const ExpOperation& oper) const
        { return copy(mtx,0,oper); }

    virtual JsObject* copy(ScriptMutex* mtx, const char* name, const ExpOperation& oper) const;

    virtual JsFunction* cloneFunction(const ExpOperation& oper, ScriptMutex* mtx = 0);
 
protected:
    virtual bool runNative(ObjList& stack, const ExpOperation& oper, GenObject* context);
 
private:
    void init();
    ObjList m_formal;
    long int m_label;
    ScriptCode* m_code;
    ExpFunction m_func;
};

class YSCRIPT_API JsArray : public JsObject
{
    friend class JsObject;
    YCLASS(JsArray,JsObject)
public:

    JsArray(GenObject* context, unsigned int line, ScriptMutex* mtx = 0);

    inline JsArray(ScriptMutex* mtx, const char* name, unsigned int line, bool frozen = false)
        : JsObject(mtx,name,line,frozen), m_length(0)
        { }

    inline int32_t length() const
        { return m_length; }

    inline void setLength(int32_t len)
        { m_length = len; }

    void push(ExpOperation* item);

    virtual JsObject* copy(ScriptMutex* mtx, const ExpOperation& oper) const;

    virtual bool runAssign(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual bool runField(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual void initConstructor(JsFunction* construct);

    virtual JsObject* runConstructor(ObjList& stack, const ExpOperation& oper, GenObject* context);
 
protected:

    virtual JsObject* clone(const char* name, const ExpOperation& oper) const
        { return new JsArray(mutex(),name,oper.lineNumber()); }

    bool runNative(ObjList& stack, const ExpOperation& oper, GenObject* context);
 
private:

    JsArray(ScriptMutex* mtx = 0);
 
    bool runNativeSlice(ObjList& stack, const ExpOperation& oper, GenObject* context);
    bool runNativeSplice(ObjList& stack, const ExpOperation& oper, GenObject* context);
    bool runNativeSort(ObjList& stack, const ExpOperation& oper, GenObject* context);
    int32_t m_length;
};

class YSCRIPT_API JsRegExp : public JsObject
{
    YCLASS(JsRegExp,JsObject)
public:
    JsRegExp(ScriptMutex* mtx = 0);

    JsRegExp(ScriptMutex* mtx, const char* name, unsigned int line, const char* rexp = 0, bool insensitive = false,
        bool extended = true, bool frozen = false);

    JsRegExp(ScriptMutex* mtx, unsigned int line, const Regexp& rexp, bool frozen = false);

    inline const Regexp& regexp() const
        { return m_regexp; }

    inline Regexp& regexp()
        { return m_regexp; }

    virtual bool runAssign(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual JsObject* runConstructor(ObjList& stack, const ExpOperation& oper, GenObject* context);

    virtual JsObject* copy(ScriptMutex* mtx, const ExpOperation& oper) const;
 
protected:
    virtual JsObject* clone(const char* name, const ExpOperation& oper) const
        { return new JsRegExp(mutex(),name,oper.lineNumber(),m_regexp.c_str(),
            m_regexp.isCaseInsensitive(),m_regexp.isExtended()); }

    bool runNative(ObjList& stack, const ExpOperation& oper, GenObject* context);
 
private:
    Regexp m_regexp;
};

class YSCRIPT_API JsParser : public ScriptParser
{
    YCLASS(JsParser,ScriptParser)
public:
    inline JsParser(bool allowLink = true, bool allowTrace = false)
        : m_allowLink(allowLink), m_allowTrace(allowTrace)
        { }

    virtual bool parse(const char* text, bool fragment = false, const char* file = 0, int len = -1);

    virtual ScriptContext* createContext() const;

    virtual ScriptRun* createRunner(ScriptCode* code, ScriptContext* context = 0, const char* title = 0) const;

    inline ScriptRun* createRunner(ScriptContext* context = 0, const char* title = 0) const
        { return createRunner(code(),context,title); }

    virtual bool callable(const String& name);

    void adjustPath(String& script, bool extraInc = false) const;

    inline const String& basePath() const
        { return m_basePath; }

    inline const String& includePath() const
        { return m_includePath; }

    inline void basePath(const char* path, const char* incPath = 0)
        { m_basePath = path; m_includePath = incPath; }

    inline const String& parsedFile() const
        { return m_parsedFile; }

    bool scriptChanged(const char* file) const;

    inline bool scriptChanged(const char* file, const String& path, const String& incPath = String::empty()) const
        { return (path != m_basePath) || (incPath != m_includePath) || scriptChanged(file); }

    inline void link(bool allowed = true)
        { m_allowLink = allowed; }

    inline void trace(bool allowed = true)
        { m_allowTrace = allowed; }

    static ScriptRun::Status eval(const String& text, ExpOperation** result = 0, ScriptContext* context = 0);

    static ExpOperation* parseJSON(const char* text, ScriptMutex* mtx = 0, ObjList* stack = 0,
            GenObject* context = 0, const ExpOperation* op = 0);

    static ExpOperation* nullClone(const char* name = 0);

    static JsObject* nullObject();

    static bool isNull(const ExpOperation& oper);

    static bool isUndefined(const ExpOperation& oper);

    static bool isMissing(const ExpOperation& oper);

    inline static bool isMissing(const ExpOperation* oper)
        { return !oper || isMissing(*oper); }

    inline static bool isPresent(const ExpOperation& oper)
        { return !isMissing(oper); }

    inline static bool isPresent(const ExpOperation* oper)
        { return oper && !isMissing(*oper); }

    inline static bool isEmpty(const ExpOperation& oper)
        { return oper.null() || isMissing(oper); }

    inline static bool isEmpty(const ExpOperation* oper)
        { return TelEngine::null(oper) || isMissing(*oper); }

    inline static bool isFilled(const ExpOperation& oper)
        { return oper && !isMissing(oper); }

    inline static bool isFilled(const ExpOperation* oper)
        { return !isEmpty(oper); }
 
private:
    String m_basePath;
    String m_includePath;
    String m_parsedFile;
    bool m_allowLink;
    bool m_allowTrace;
};
 
}; // namespace TelEngine
 
#endif /* __YATESCRIPT_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */