POP/POP_VariableList.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 */

#ifndef __POP_VariableList_h__
#define __POP_VariableList_h__

#include "POP_API.h"
#include <UT/UT_IncludeFileManager.h>
#include <UT/UT_String.h>

class UT_String;
class POP_Node;

// This class holds the relevent info to track each pop variable:
class POP_API POP_AccessEntry
{
public:
    POP_AccessEntry(const char *name, const char *attrib, const char *builder, 
                    const char *type, int size)
    {
        myName = name;                          myType = type;  
        myBuilder = builder;                    mySize = size;
        myAttrib = attrib;
        myName.harden();                        myType.harden();
        myBuilder.harden();                     myAttrib.harden();
    }
    UT_String    myName;                // Eg: pos
    UT_String    myAttrib;              // Eg: P
    UT_String    myBuilder;             // Eg: getPos()
    UT_String    myType;                // Eg: UT_Vector4
    int          mySize;                // Eg: 1

    int          myUsed, myUsedAtAll;
};

class POP_API POP_VariableEntry
{
public:
    POP_VariableEntry(const char *name, const char *requires,
                      const char *builder, const char *type = "float")
    {
        myName = name;                          myRequires = requires;  
        myBuilder = builder;                    myType = type;
        myName.harden();                        myRequires.harden();
        myBuilder.harden();                     myType.harden();
    }
    
    UT_String    myName;                // Eg: TX
    UT_String    myRequires;            // Eg: pos, the access type
    UT_String    myBuilder;             // Eg: pos->x(), the access func
    UT_String    myType;                // Eg: float

    int          getUsed() const { return myUsed & 1; }
    int          getUsedAtAll() const { return myUsedAtAll & 1; }

    // Shift the myUsed flags.
    void         pushStatus() { myUsed <<= 1; myUsedAtAll <<= 1; }
    void         popStatus()  { myUsed >>= 1; myUsedAtAll >>= 1; }

    int          myUsed, myPointVarying, myUsedAtAll;
};

class POP_API POP_StreamEntry
{
public:
    POP_StreamEntry(const char *name)
    {
        myName = name;
        myName.harden();
        myCook = 1;
        myDisplay = 1;
    }

    void         setCook(int cook) { myCook = cook; }
    int          getCook() const { return myCook; }

    void         setDisplay(int display) { myDisplay = display; }
    int          getDisplay() const { return myDisplay; }

    UT_String    myName;
    int          myCook;        // Do I get cooked?
    int          myDisplay;     // Should I be displayed?
};

class POP_API POP_GlobalEntry
{
public:
    POP_GlobalEntry(const char *name, const char *builder, int varying = 0, 
                    int framevarying = 0)
    {
        myName = name;                   myBuilder = builder;
        myVarying = varying;
        myFrameVarying = framevarying;
        myName.harden();                 myBuilder.harden();
    }

    UT_String            myName;                // What follows the $
    UT_String            myBuilder;             // Code to read it.
    int                  myVarying;             // Do we vary by point?
    int                  myFrameVarying;        // Do we vary by frame?
};

class POP_API POP_AttributeEntry
{
public:
    POP_AttributeEntry(const char *name, const char *builder = 0, int size = 1)
    {
        myName = name;          mySize = size;
        myBuilder = builder;
        myName.harden();        myBuilder.harden();
        myUsed = myUsedAtAll = 0;
    }

    UT_String            myName;        // name, Ie: "v"
    int                  mySize;        // Number of floats, ie: 3
    UT_String            myBuilder;     // Build function, ie: addPos
    int                  myUsed, myUsedAtAll;
};

// Must match up with entry structure in $EXPR/evparse.C::ev_FUNCLUT
class POP_API POP_FuncEntry
{
public:
    POP_FuncEntry(const char *name, const char *baseprefix)
    {
        myName = name;          myBasePrefix = baseprefix;
        myName.harden();        myBasePrefix.harden();
    }

    UT_String            myName;
    UT_String            myBasePrefix;
};


class POP_API POP_VariableList
{
public:
    POP_VariableList();
    virtual ~POP_VariableList();

    void                 addDefaultGlobals();

    int                  load(const char *fname);

    int                  addVariable(const char *name, const char *requires, 
                                     const char *builder, int pointvarying = 1);
    int                  addAccess(const char *name, const char *attrib,
                                     const char *builder, const char *type,
                                     int size = 1);
    int                  addStream(const UT_String &name);
    int                  addGlobal(const char *name, const char *builder,
                                   int varying = 0, int framevarying = 0);
    int                  addAttribute(const char *name, 
                                      const char *builder,
                                      int size = 1);
    int                  addFuncXlate(const char *function, const char *xlate,
                                      const char *prefix);
    int                  addParam(const char *name, const char *type);
    int                  addPreDefine(const char *name);

    POP_VariableEntry   *findVariable(const char *name) const;
    POP_AccessEntry     *findAccess(const char *name) const;
    POP_StreamEntry     *findStream(const char *name) const;
    POP_GlobalEntry     *findGlobal(const char *name) const;
    POP_AttributeEntry  *findAttribute(const char *name) const;
    POP_FuncEntry       *findFuncXlate(const char *function) const;

    POP_AccessEntry     *useAccess(const char *name);
    POP_AccessEntry     *useSoftAccess(const char *name);
    POP_VariableEntry   *useVariable(const char *name);
    POP_AttributeEntry  *useAttribute(const char *name);

    int                  isAccessTypeUsedAtAll(const char *type);

    // Current state of the output code generator.
    void                 setBuildState(const char *name, int value);
    int                  testBuildState(const char *name) const;
    int                  getBuildState(const char *name) const;

    // Push the variable state flags:
    void                 pushVariableState();
    void                 popVariableState();

    int                  numvar() const { return myVariableList.entries(); }
    POP_VariableEntry   *variable(int idx) const
                                { return myVariableList(idx); }
    int                  numaccess() const { return myAccessList.entries(); }
    POP_AccessEntry     *access(int idx) const
                                { return myAccessList(idx); }
    int                  numstream() const { return myStreamList.entries(); }
    POP_StreamEntry     *stream(int idx)
                                { return myStreamList(idx); }
    int                  numglobal() const { return myGlobalList.entries(); }
    POP_GlobalEntry     *global(int idx)
                                { return myGlobalList(idx); }
    int                  numattribs() const { return myAttribList.entries(); }
    POP_AttributeEntry  *attrib(int idx)
                                { return myAttribList(idx); }
    int                  numfuncxlate() const 
                                { return myFuncXlateList.entries(); }
    POP_FuncEntry       *funcxlate(int idx)
                                { return myFuncXlateList(idx); }

    UT_SymbolTable      *getFuncXlateTable()
                                { return &myFuncXlateTable; }

    int                  numparam() const
                                { return myParamList.entries() / 2; }
    const char          *paramname(int idx) const
                                { return myParamList(idx*2); }
    const char          *paramtype(int idx) const
                                { return myParamList(idx*2+1); }
    int                  numpredefine() const
                                { return myPreDefineList.entries(); }
    const char          *predefine(int idx) const
                                { return myPreDefineList(idx); }

    // Output functions:
    void                 writeDeclarations(const char *ctxtname, 
                                            ostream &os) const;
    void                 writeVariableDeclarations(ostream &os) const;
    void                 writeAttributeInit(const char *ctxtname, 
                                            ostream &os) const;
    void                 writeLocalVarClass(const char *prefix, ostream &os) 
                                            const;

    UT_IncludeFileManager &getManager() { return myIncludeMgr; }

    // Stream management functions:
    void                 setGlobalPrefixStream(ostream * os)
                         { myGlobalPrefixStream = os; }
    void                 setGlobalSuffixStream(ostream * os)
                         { myGlobalSuffixStream = os; }
    void                 setHeaderStream(ostream *os)
                         { myHeaderStream = os; }

    ostream             *getGlobalPrefixStream()
                         { return myGlobalPrefixStream; }
    ostream             *getGlobalSuffixStream()
                         { return myGlobalSuffixStream; }
    ostream             *getHeaderStream()
                         { return myHeaderStream; }

    void                 setFunctionPrefix(const char *s)
                         { myFuncPrefix = s; }

    const char          *getFunctionPrefix() const
                         { return (const char *)myFuncPrefix; }

    void                 setChannelForce(int force) { myChannelForce = force; }
    int                  getChannelForce() const { return myChannelForce; }

    void                 resetUsed();
    void                 resetAll();

    // These track the stack frames of evaluated nodes and check
    // to see if a node has been evaluated 
    int                  hasNodeBeenWritten(POP_Node *node);
    void                 getNodeStreamName(UT_String &str, POP_Node *node);
    void                 markNodeWritten(const char *stream, POP_Node *node);
    void                 deferNode(POP_Node *node);
    POP_Node            *popDeferredNode();

    void                 pushNodeFrame();
    void                 popNodeFrame();
    
protected:
    UT_SymbolTable                      myAccessTable;
    UT_SymbolTable                      myVariableTable;
    UT_SymbolTable                      myStreamTable;
    UT_SymbolTable                      myGlobalTable;
    UT_SymbolTable                      myAttribTable;
    UT_SymbolTable                      myBuildStateTable;
    UT_SymbolTable                      myFuncXlateTable;
    UT_PtrArray<POP_VariableEntry *>    myVariableList;
    UT_PtrArray<POP_AccessEntry *>      myAccessList;
    UT_PtrArray<POP_StreamEntry *>      myStreamList;
    UT_PtrArray<POP_GlobalEntry *>      myGlobalList;
    UT_PtrArray<POP_AttributeEntry *>   myAttribList;
    UT_PtrArray<POP_FuncEntry *>        myFuncXlateList;
    UT_PtrArray<char *>                 myParamList;
    UT_PtrArray<char *>                 myPreDefineList;

    UT_PtrArray<UT_SymbolTable *>       myNodeStack;
    UT_PtrArray<char *>                 myNodeStackList;
    UT_PtrArray<UT_PtrArray<POP_Node *> *> myDeferredNodes;

    UT_IncludeFileManager               myIncludeMgr;

    int                                 myChannelForce;

    ostream                             *myGlobalPrefixStream;
    ostream                             *myGlobalSuffixStream;
    ostream                             *myHeaderStream;

    UT_String                            myFuncPrefix;
};

#endif

---