preserve original author on edit

[couchdbimport.git] / CouchProjects / Fabric / Fabric.h

/*
Fabric formula engine
Copyright (C) 2006  Damien Katz

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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#ifndef FABRIC_H
#define FABRIC_H

#ifdef WIN32

#include "crtdbg.h"
#define ASSERT _ASSERT

#else

#include "assert.h"

#ifdef NDEBUG
#define ASSERT
#else
#define ASSERT assert
#endif

#endif

#include "Exceptions.h"
#include "MemoryPool.h"
#include "antlr/CommonAST.hpp"
#include "FabricSTL.h"
#include <string.h>



//forward declarations
class Document;
class List;
class RuntimeNode;
class TextElement;
class FailedAssertHandler;
class UserFunctionDescriptor;
class VariableScope;
class Destructable;

class TextElementILess
{
public:
        bool operator () (const TextElement& left, const TextElement& right) const;
};

typedef size_t IdAtom;
typedef fmap<const IdAtom, const UserFunctionDescriptor*> AtomUserFunctionMap;

enum FormulaType {
        kSimple,
        kTable
};

// This is the main interface class.
// It compiles and executes formulas, and keeps all the formula specific state
class Formula
{
public:
        static void ProcessInit();

        Formula();
        ~Formula();

        // Compiles a formula and sets up the runtime machinery to execute the formula
        void Compile(const char* pInputFormula, FormulaType formulaType = kSimple);

        // Executes the formula and returns the result of computation
        const List* Execute();

        bool IsReady();
        bool SelectCompute(Document& doc);
        const fvector<const List*>& GetColumns();
        void AppendColumnList(const List* pList);
        const char* CompileError();

        fvector<TextElement> GetColumnNames();

        void Reset();

        // Converts a string to a number that is unique to that string.
        // For each subsequent request using the same string (case insensitive)
        // results in the same atom
        IdAtom GetIdAtom(const TextElement& ident);

        // Set/Get variable values. The IdAtom versions are faster if you have
        // the IdAtom already computed, otherwise just use the text versions.
        const List* GetVariableValue(const TextElement& varId);
        void SetVariableValue(const TextElement& varId, const List* pList);
        const List* GetVariableValue(IdAtom varIdAtom);
        void SetVariableValue(IdAtom varIdAtom, const List* pList);

        // Get a value but first looking in the Variables, then in the document fields
        const List* GetValue(const TextElement& varId, IdAtom varIdAtom);

        // Get/Set the user function during runtime
        const UserFunctionDescriptor* GetUserFunction(IdAtom idAtom);
        void SetUserFunction(IdAtom idAtom, const UserFunctionDescriptor*);

        // Create/destoys variable scope
        void PushVariableScope();
        void PopVariableScope();

        VariableScope& GetCurrentScope();

        // Various commonly returned values. Functions should
        // return these to avoid allocating new values unnecessarily.
        const List* TrueList();
        const List* FalseList();
        const List* NilList();
        const List* BoolList(bool trueOrFalse);

        // Set a context document for the compuation
        void SetDocument(Document* pDoc);

        // Get the context document for the computation. If once doesn't exist,
        // fabric creates a special default one to use.
        Document& GetDocument();

        // Built in to Fabric are ASSERT and ASSERTFALSE, and they are used
        // by the test suite. When Fabric encounters an ASSERT but an assert
        // handler is not set, then the entire contained expression is skipped.
        FailedAssertHandler* GetFailedAssertHandler();
        void SetFailedAssertHandler(FailedAssertHandler* pHandler);

        void SetEarlyReturnList(const List* pList);
        
        class SyntaxException : public std::runtime_error
        {
        public:
                SyntaxException(const char* message)
                        : std::runtime_error(message)
                {}
        };

        void SetSelected(bool flag);
        bool GetSelected();

        void AddToDestructionQueue(Destructable* d);
        
        AllocOnlyMemoryPool<0xFFFF>     indefMa; // Memory only needed for the current formula execution
        AllocOnlyMemoryPool<0xFFFF>     transMa; // Memory needed across all formula executions
        MA* ma; // pointer to indefMa, for convenience

private:

        const List* Execute(const RuntimeNode* pRoot);
        RuntimeNode* BuildTree(antlr::RefAST pAST);
        
        // this in NewRuntimeNode.cpp
        RuntimeNode* NewRuntimeNode(int type, const char* pNodeText);
        
        fmap<const TextElement, IdAtom, TextElementILess> m_idAtoms;
        IdAtom m_nextIdAtom;

        VariableScope* m_pCurrentVarScope;

        AtomUserFunctionMap* m_pUserFunctions;

        RuntimeNode* m_pRootNode;

        char* m_pCompileError;

        const List* m_pTrueList;
        const List* m_pFalseList;
        const List* m_pNilList;

        const List* m_pEarlyReturnList;

        Document* m_pDoc;
        Document* m_pDefaultDoc;
        
        fvector<const List*> m_columnLists;

        fvector<Destructable*> m_destructables;

        bool m_selectedFlag;

        FailedAssertHandler* m_pFailedAssertHandler;
};


//
// UserFunctionDescriptor - Describes a user function.
//
class UserFunctionDescriptor
{
public:
        fvector<IdAtom> m_argIds; // the IdAtoms of the argument variable names
        const RuntimeNode* pRuntimeNode; // the actual function itself

        UserFunctionDescriptor(MA* ma)
                : m_argIds(ma)
        {}
};


//
// VariableScope - Contains the variables, input args 
//      and return value for the current scope.
//
class VariableScope
{
public:
        fmap<const IdAtom, const List*> map;

        VariableScope* pPrev;
        VariableScope* pNext;

        const List* pReturnList;

        fvector<const List*> inputArgs;

        
        VariableScope(MA* ma)
                : map(ma), pPrev(NULL), pNext(NULL), pReturnList(NULL), inputArgs(ma)
        {
        }
};


//
// FailedAssertHandler - Interface class so callers can dealing with failed
// asserts. Used only during testing.
//
class FailedAssertHandler
{
public:
        virtual void HandleFailedAssert() = 0;
};


class Destructable
{
public:
        virtual void Destruct() = 0;
};



template<class T> int cmp(const T& a, const T& b)
{
        if (a < b) {
                return -1;
        }
        if (b < a) {
                return 1;
        }
        return 0;
}



//*******************************************
// Inline functions below:
//*******************************************






#endif // FABRIC_H