add Markdown lib

[couchdbimport.git] / CouchProjects / Fabric / SpecialNodes.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.

*/


// Branching node
class If : public RuntimeNode
{
public:

        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                frame.boolVal = false;

                return m_pFirstChild;
        }

        const RuntimeNode* NextNodeToExecute(StackFrame& frame, const RuntimeNode* pPreviousExecuteNode, const List* pPreviousValue) const
        {
                if (frame.boolVal) {
                        // This means the node just executed must be the desired return result.
                        frame.PushArg(pPreviousValue);
                        return NULL; // no more nodes to execute
                }
                else {
                        if (pPreviousExecuteNode->GetNextSibling() == NULL) {
                                // this means we are an else clause
                                frame.PushArg(pPreviousValue);
                                return NULL;
                        } else if (pPreviousValue->ToBool()) {
                                // We hit a true conditional.
                                // Signal we hit a true conditional for the next time through
                                frame.boolVal = true;

                                // execute the body of the clause
                                return pPreviousExecuteNode->GetNextSibling();
                        }
                        else {
                                // conditional wasn't true, skip over the body onto the next
                                // conditional (which will be null if there is no else clause)

                                return pPreviousExecuteNode->GetNextSibling()->GetNextSibling();
                        }
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                if (frame.ArgCount() == 0) {
                        // this happens when there is no true "if" or "else if" cases and no "else" found
                        return f->NilList();
                }
                return &frame.LastArg();
        }
};


// Early return: Return(Foo)
class Fun_return : public RuntimeNode
{       
public:

        const List* Execute(StackFrame& frame) const
        {
                f->SetEarlyReturnList(&frame.LastArg());
                return &frame.LastArg();
        }
};


// var := value;
class VariableAssignment : public RuntimeNode
{       
public:

        const List* Execute(StackFrame& frame) const
        {
                const List* pRetList = &frame.LastArg();
                f->SetVariableValue(GetTokenIdAtom(), pRetList);
                return pRetList;
        }
};

// var ?= value;
class VariableInit : public RuntimeNode
{       
public:
        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                const List* pExistingValue = f->GetValue(GetTokenText(), GetTokenIdAtom());
                if (pExistingValue) {
                        frame.pReturnList = pExistingValue;
                        return NULL;
                }
                else {
                        frame.pReturnList = NULL;
                        return m_pFirstChild;
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                if (frame.pReturnList) {
                        return frame.pReturnList;
                }
                else {
                        const List* pRetList = &frame.LastArg();
                        f->SetVariableValue(GetTokenIdAtom(), pRetList);
                        return pRetList;
                }
        }
};

class SelectStatement : public RuntimeNode
{
        const List* Execute(StackFrame& frame) const
        {
                if (frame.ArgCount() == 0) {
                        // "SELECT *" case
                        f->SetSelected(true);
                        return f->TrueList();
                }

                const List& list = frame.LastArg();

                if (list.ToBool()) {
                        f->SetSelected(true);
                }
                else {
                        f->SetSelected(false);
                        f->SetEarlyReturnList(&list); // causes abortion of execution
                }
                return &list;
        }
};

class Column : public RuntimeNode
{
        NodeType GetNodeType() const
        {
                return NodeType_ColumnAssignment;
        }

        const List* Execute(StackFrame& frame) const
        {
                const List* pList = f->GetValue(GetTokenText(), GetTokenIdAtom());
                f->AppendColumnList(pList);
                return pList;
        }
};


class ColumnAssignment : public RuntimeNode
{
        NodeType GetNodeType() const
        {
                return NodeType_ColumnAssignment;
        }

        const List* Execute(StackFrame& frame) const
        {
                const List* pList = &frame.LastArg();
                f->AppendColumnList(pList);
                return pList;
        }
};



class ColumnInit : public RuntimeNode
{
        NodeType GetNodeType() const
        {
                return NodeType_ColumnAssignment;
        }

        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                const List* pExistingValue = f->GetValue(GetTokenText(),  GetTokenIdAtom());
                if (pExistingValue) {
                        frame.pReturnList = pExistingValue;
                        return NULL;
                }
                else {
                        frame.pReturnList = NULL;
                        return m_pFirstChild;
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                if (frame.pReturnList) {
                        f->AppendColumnList(frame.pReturnList);
                        return frame.pReturnList;
                }
                else {
                        const List* pRetList = &frame.LastArg();
                        f->AppendColumnList(pRetList);
                        return pRetList;
                }
        }
};

// FIELD var := value;
class FieldAssignment : public RuntimeNode
{       
public:

        const List* Execute(StackFrame& frame) const
        {
                f->SetVariableValue(GetTokenIdAtom(), NULL); // clear out the local var
                const List* pRet = &frame.LastArg();
                f->GetDocument().SetValue(GetTokenText(), pRet);
                return pRet;
        }
};

class FieldInit : public RuntimeNode
{

        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                const List* pExistingValue = f->GetDocument().GetValue(ma, GetTokenText());
                if (pExistingValue) {
                        frame.pReturnList = pExistingValue;
                        return NULL;
                }
                else {
                        frame.pReturnList = NULL;
                        return m_pFirstChild;
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                if (frame.pReturnList) {
                        return frame.pReturnList;
                }
                else {
                        f->SetVariableValue(GetTokenIdAtom(), NULL); // clear out the local var
                        const List* pRetList = &frame.LastArg();
                        f->GetDocument().SetValue(GetTokenText(), pRetList);
                        return pRetList;
                }
        }
};

class UnknownFunction : public RuntimeNode
{
        const List* pErrorList;
public:
        void CompilerValidateArgsAndInit()
        {
                // we make this a runtime error instead of compile time
                // so a future script written for a future Fabric engine
                // can still run if properly written and degrade gracefully
                // if language features aren't available

                StringBuilder str(ma, 50);
                str += "No built-in function \"";
                str += GetTokenText();
                str += "\" found.";
                
                pErrorList = new(&f->indefMa) List(&f->indefMa, ErrorElement("UnknownFunction", str));
        }
        const List* Execute(StackFrame& frame) const
        {
                
                return pErrorList;
        }
};


class StringLiteral : public RuntimeNode
{
        const List* pLiteral;
public:
        void CompilerValidateArgsAndInit()
        {
                ASSERT(m_numChildren == 0);
                const TextElement& token = GetTokenText();
                char* newString = new(&f->indefMa) char[token.Length()];
                char* out = newString;
                const char* in = token.Ptr();
                const char* inEnd = in + token.Length();

                // NOTE, we need not do error checking on the input characters, they have
                // already been validated for correctness.
                // (impossible input example: "string with single trailing slash\")


                while (in < inEnd) {
                        if (*in == '\\') {
                                in++;
                                switch (*in) {
                                        case 'n':
                                                *out = '\n';
                                                break;
                                        case 't':
                                                *out = '\t';
                                                break;
                                        default:
                                                *out = *in;
                                }
                        }
                        else {
                                *out = *in;
                        }
                        out++;
                        in++;
                }
                pLiteral = new(&f->indefMa) List(&f->indefMa, TextElement(newString, out - newString));
        }

        const List* Execute(StackFrame& frame) const
        {
                return pLiteral;
        }
};

class DateTimeLiteral : public RuntimeNode
{
        
public:

        const List* Execute(StackFrame& frame) const
        {
                return f->FalseList();
        }
};

class NumberLiteral : public RuntimeNode
{
        const List* pLiteral;
public:
        void CompilerValidateArgsAndInit()
        {
                ASSERT(m_numChildren == 0);
                pLiteral = new(&f->indefMa) List(&f->indefMa, GetTokenText().ToNumber());
        }

        const List* Execute(StackFrame& frame) const
        {
                return pLiteral;
        }
};

//function Foo(arg) {
// expr;
//};
class UserFunction : public RuntimeNode
{
        UserFunctionDescriptor* m_pFunctionDescriptor;
public:
        void CompilerValidateArgsAndInit()
        {
                ASSERT(m_numChildren >= 1);             

                m_pFunctionDescriptor = new(&f->indefMa) UserFunctionDescriptor(&f->indefMa);

                m_pFunctionDescriptor->m_argIds.reserve(m_numChildren - 1);

                const RuntimeNode* pChildNode = m_pFirstChild;

                // if pChildNode->GetNextSibling() is null, then it means its the last
                // child node and its not an arg id
                while (pChildNode->GetNextSibling()) {
                        m_pFunctionDescriptor->m_argIds.push_back(pChildNode->GetTokenIdAtom());
                        pChildNode = pChildNode->GetNextSibling();
                }

                // pChildNode now points to the last arg, the actual function expression
                // so store if of in the function descriptor (its the actual function really)
                m_pFunctionDescriptor->pRuntimeNode = pChildNode;
        }

        virtual const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                // we never execute our args, we wait until called.
                return NULL;
        }

        const List* Execute(StackFrame& frame) const
        {
                f->SetUserFunction(GetTokenIdAtom(), m_pFunctionDescriptor);

                return NULL;
        };
};

// %UserFunction(args);
class UserFunctionCall : public RuntimeNode
{
        IdAtom m_argCountIdAtom;
        const List* m_pArgCountList;
public:
        
        NodeType GetNodeType() const
        {
                return NodeType_UserFunctionCall;
        }

        void CompilerValidateArgsAndInit()
        {

                ASSERT(m_tokenText.Ptr()[0] == '%');

                // strip off the leading % sign.
                m_tokenText = TextElement(m_tokenText.Ptr() + 1, m_tokenText.Length() - 1);

                m_argCountIdAtom = f->GetIdAtom(TEXT_ELEMENT("$argcount"));

                m_pArgCountList = new(&f->indefMa) List(&f->indefMa, NumberElement(m_numChildren));
                
        }

        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                // init our frame vars
                frame.boolVal = false;

                if (m_pFirstChild == NULL) {
                        // no args from the caller
                        const UserFunctionDescriptor* pUserFunction = f->GetUserFunction(GetTokenIdAtom());
                        if (pUserFunction) {
                                // we have a function, create a variable map for it and save off the old one
                                f->PushVariableScope();
                                
                                f->SetVariableValue(m_argCountIdAtom, m_pArgCountList);

                                // we don't have any args to put into the variable map
                                return pUserFunction->pRuntimeNode;
                        }
                        else {
                                return NULL;
                        }
                }
                return m_pFirstChild;
        }

        const RuntimeNode* NextNodeToExecute(StackFrame& frame, const RuntimeNode* pPreviousExecuteNode, const List* pPreviousValue) const
        {
                frame.PushArg(pPreviousValue);

                if (frame.boolVal) {
                        // we just executed the function, return baby!!!                        
                        f->PopVariableScope();
                        return NULL;
                }

                if (pPreviousExecuteNode->GetNextSibling() != NULL) {
                        return pPreviousExecuteNode->GetNextSibling();
                }

                const UserFunctionDescriptor* pUserFunction = f->GetUserFunction(GetTokenIdAtom());

                if (pUserFunction) {
                        f->PushVariableScope();
                        
                        const List** args = frame.ArgArray();
                        size_t argCount = frame.ArgCount();
                        
                        // we can have less specified args than actual args being passed in
                        if (pUserFunction->m_argIds.size() < argCount) {
                                argCount = pUserFunction->m_argIds.size();
                        }

                        // and set the variables to the function arg ids
                        for (size_t i = 0; i < argCount; i++) {
                                f->SetVariableValue(pUserFunction->m_argIds[i], args[i]);
                        }
                        
                        // store the number of args in the variable $ArgCount
                        f->SetVariableValue(m_argCountIdAtom, m_pArgCountList);

                        VariableScope& scope = f->GetCurrentScope();
                        scope.inputArgs.reserve(argCount);                      
                        scope.inputArgs.insert(scope.inputArgs.begin(), args, args + argCount);

                        // clear off our args, they are now stored in the varaible scope
                        frame.ClearArgs();

                        frame.boolVal = true; // signal that we are about to execute the function

                        return pUserFunction->pRuntimeNode;

                }
                else {
                        // no function found. Clear the args and return no node
                        
                        frame.ClearArgs();

                        return NULL;
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                ASSERT(frame.ArgCount() <= 1);

                if (frame.ArgCount() == 0) {
                        // we have no arg to return because the function wasn't found
                        StringBuilder str(ma, 50);
                        str += "No user function \"%";
                        str += GetTokenText();
                        str += "\" found.";

                        return new(ma) List(ma, ErrorElement("UnknownFunction", str));
                }

                return &frame.LastArg();
        }
};

// Expressions between curly braces:
// {x:=1;x + 1}; // result value is 2
class NestedExprs : public RuntimeNode
{
public:
        const List* Execute(StackFrame& frame) const
        {
                ASSERT(frame.ArgCount() != 0);

                return &frame.LastArg();
        }
};

// this the "element in list" portion of a forall statement:
// forall(x in listx) {...};
class ForAllIn : public RuntimeNode
{
public:

        size_t increment;

        NodeType GetNodeType() const
        {
                return NodeType_ForAllInNode;
        }

        virtual void CompilerValidateArgsAndInit()
        {
                ASSERT(m_numChildren == 1 || m_numChildren == 2);

                if (m_numChildren == 2) {
                        // the by-increment clause is specified, gets it value

                        const RuntimeNode* pArg = m_pFirstChild->GetNextSibling();
                        int inc = (int)pArg->GetTokenText().ToNumber();
                        if (inc <= 0) {
                                // zero/negative is not allowed! (maybe negative could have special meaning someday?)
                                throw Formula::SyntaxException("The \"by\" clause must be a positive integer.");
                        }
                        else {
                                increment = (size_t)inc;
                        }
                }
                else {
                        increment = 1;
                }
        }

        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                return m_pFirstChild;
        }

        const RuntimeNode* NextNodeToExecute(StackFrame& frame, const RuntimeNode* pPreviousExecuteNode, const List* pPreviousValue) const
        {
                frame.PushArg(pPreviousValue);

                return NULL;
        }

        const List* Execute(StackFrame& frame) const
        {
                ASSERT(frame.ArgCount() == 1);
                return &frame.LastArg();
        }
};

class ForAll : public RuntimeNode
{       
public:
        const RuntimeNode* NextNodeToExecute(StackFrame& frame, const RuntimeNode* pPreviousExecuteNode, const List* pPreviousValue) const
        {
                size_t numberOfForAllInNodes = m_numChildren - 1;

                frame.PushArg(pPreviousValue);

                if (frame.ArgCount() < numberOfForAllInNodes) {
                        // We still have at least one more forallIn node to execute
                        // before we get to the body loop.;
                        return pPreviousExecuteNode->GetNextSibling();
                }
                else {
                        if (frame.ArgCount() == numberOfForAllInNodes) {
                                // we just executed the very last forallin node
                                // now initialize for the loop body

                                // for each subsequent time through, this will be true:
                                // frame.ArgCount() + 1 == numberOfForAllInNodes

                                size_t maxSize = 0;
                                size_t maxIterations = 0;

                                const ForAllIn* pForAllInNode = (const ForAllIn*)m_pFirstChild;
                                for (size_t i = 0; i < frame.ArgCount(); i++) {
                                        const List& arg = frame.GetArg(i);

                                        size_t increment = pForAllInNode->increment;
                                        size_t iterations = arg.size()/increment;

                                        if(iterations*increment != arg.size()) {
                                                // iterations was trucated down because the division
                                                // has a remainder, so add one.
                                                iterations++;
                                        }
                                        
                                        maxSize = std::max(arg.size(), maxSize);
                                        maxIterations = std::max(iterations, maxIterations);

                                        pForAllInNode = (const ForAllIn*)pForAllInNode->GetNextSibling();
                                }

                                frame.forAllLoopData.currentIteration = 0;
                                frame.forAllLoopData.totalIterations = maxIterations;
                                frame.forAllLoopData.pReturnList = new(ma) List(ma);
                                frame.forAllLoopData.pReturnList->Reserve(maxSize);
                        }
                        else {
                                frame.forAllLoopData.pReturnList->Append(*pPreviousValue);
                                frame.forAllLoopData.currentIteration++;
                                frame.PopArg(); // don't leave the previousvalue on the stack
                        }
                        if (frame.forAllLoopData.currentIteration == frame.forAllLoopData.totalIterations) {
                                // we are done!
                                // clear off the stack
                                // and return
                                frame.ClearArgs();
                                frame.PushArg(frame.forAllLoopData.pReturnList);
                                return NULL;
                        }

                        // now populate the loop variables

                        ASSERT(frame.ArgCount() == numberOfForAllInNodes);

                        const ForAllIn* pForAllInNode = (const ForAllIn*)m_pFirstChild;
                        size_t iteration = frame.forAllLoopData.currentIteration;

                        for (size_t i = 0; i < numberOfForAllInNodes; i++) {
                                size_t increment = pForAllInNode->increment;
                                size_t offset = iteration*increment;
                                const List& list = frame.GetArg(i);

                                List* pNewSubvalue = new(ma) List(ma);
                                pNewSubvalue->Reserve(increment);

                                for (size_t j = 0; j < increment; j++) {
                                        if (list.size() > offset + j) {
                                                pNewSubvalue->Add(list[offset + j]);
                                        }
                                }

                                // now set the loop variable with the new value
                                f->SetVariableValue(pForAllInNode->GetTokenIdAtom(), pNewSubvalue);
                                
                                pForAllInNode = (const ForAllIn*)pForAllInNode->GetNextSibling();
                        }

                        if (pPreviousExecuteNode->GetNextSibling() == NULL) {
                                return pPreviousExecuteNode;
                        }
                        else {
                                return pPreviousExecuteNode->GetNextSibling();
                        }
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                return &frame.LastArg();
        }
};

class VariableReference : public RuntimeNode
{       
public:

        virtual NodeType GetNodeType() const
        {
                return NodeType_VariableReferenceNode;
        }

        const List* Execute(StackFrame& frame) const
        {
                return f->GetValue(GetTokenText(), GetTokenIdAtom());
        }
};


class OuterFormula : public RuntimeNode
{
        const List* Execute(StackFrame& frame) const
        {
                // get our return value, if set
                const List* pReturn = f->GetCurrentScope().pReturnList;

                if (pReturn == NULL) {
                        // the return value wasn't explicitly set
                        if (frame.ArgCount() != 0) {
                                // return the last arg
                                pReturn = &frame.LastArg();
                        }
                }
                return pReturn;
        }
};

class KeywordLiteral : public RuntimeNode
{       const List* pKeyword;
public:
        void CompilerValidateArgsAndInit()
        {
                ASSERT(m_numChildren == 0);

                // convert our text to a KeywordElement and put that element into a Value.
                // That is the value that will be returned when Execute is called.

                KeywordElement keyword(f->GetIdAtom(GetTokenText()), GetTokenText().ToNullTermStr(ma));

                pKeyword = new(&f->indefMa) List(&f->indefMa,keyword);

        }

        const List* Execute(StackFrame& frame) const
        {
                return pKeyword;
        }
};

class Fun_assert : public RuntimeNode
{
public:
        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                if (f->GetFailedAssertHandler()) {
                        return m_pFirstChild;
                }
                else {
                        return NULL;
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                
                if (frame.ArgCount() > 0) {
                        FailedAssertHandler* pHandler = f->GetFailedAssertHandler();
                        // We can't have args unless we also have a FailedAssertHandler
                        // the code in FirstNodeToExecute ensures that
                        ASSERT(pHandler);

                        for (size_t i = 0; i < frame.ArgCount(); i++) {
                                const List* pList = &frame.GetArg(i);

                                if (!pList->ToBool()) {
                                        pHandler->HandleFailedAssert();
                                }
                        }
                }
                
                return f->TrueList();
        }       
};


class Fun_assertfalse : public RuntimeNode
{
public:
        const RuntimeNode* FirstNodeToExecute(StackFrame& frame) const
        {
                if (f->GetFailedAssertHandler()) {
                        return m_pFirstChild;
                }
                else {
                        return NULL;
                }
        }

        const List* Execute(StackFrame& frame) const
        {
                
                if (frame.ArgCount() > 0) {
                        FailedAssertHandler* pHandler = f->GetFailedAssertHandler();
                        // We can't have args unless we also have a FailedAssertHandler
                        // the code in FirstNodeToExecute ensures that
                        ASSERT(pHandler);

                        for (size_t i = 0; i < frame.ArgCount(); i++) {
                                const List* pList = &frame.GetArg(i);

                                if (pList->ToBool()) {
                                        pHandler->HandleFailedAssert();
                                }
                        }
                }
                
                return f->TrueList();
        }       
};


class TrueLiteral : public RuntimeNode
{
public:
        const List* Execute(StackFrame& frame) const
        {
                return f->TrueList();
        }
};

class FalseLiteral : public RuntimeNode
{
public:
        const List* Execute(StackFrame& frame) const
        {
                return f->FalseList();
        }
};


class NilLiteral : public RuntimeNode
{
public:
        const List* Execute(StackFrame& frame) const
        {
                return f->NilList();
        }
};