VOP/VOP_CodeGenerator.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 __VOP_CodeGenerator_h__
#define __VOP_CodeGenerator_h__

#include "VOP_API.h"
#include "VOP_Error.h"
#include "VOP_Node.h"
#include "VOP_Parameter.h"
#include "VOP_ParmGenerator.h"
#include <OP/OP_Node.h>
#include <PI/PI_EditScriptedParms.h>
#include <PI/PI_OldParms.h>
#include <UT/UT_Assert.h>

#include <map>
#include <string>

// The names of the parameters for setting the min and max inputs for the
// operator type defined by a VOP Network.
#define VOP_MININPUTS_NAME      "mininputs"
#define VOP_MAXINPUTS_NAME      "maxinputs"

class UT_IStream;
class UT_WorkArgs;
class UT_StringArray;
class CH_LocalVariable;
class OP_OTLDefinition;
class OP_Network;
class VOP_Collect;
class VOP_Node;
class VOP_Language;
class VOP_CodeGenerator;
class VOP_CodeVarMapper;
class VOP_CodeVarMapperContext;
class VOP_CodeVarLookupData;
class VOP_CodeCompilerArgs;
class VOP_LanguageContextTypeList;
class VOP_ParmContextInfo;

typedef std::map < VOP_ContextType, std::string > TContextTypeStringMap;

class VOP_API VOP_CodeParm
{
public:
    typedef enum {
        ENDGROUP,
        STARTGROUP,
        ENTRY
    } VOP_CodeParmType;

    VOP_CodeParm()
        : myType(ENDGROUP), myNodeId(OP_INVALID_NODE_ID) { }
    VOP_CodeParm(const char *groupname)
        : myType(STARTGROUP), myName(groupname, 1), 
          myNodeId(OP_INVALID_NODE_ID) 
        { }
    VOP_CodeParm(VOP_ParmGenerator *vop)
        : myType(ENTRY), myNodeId(vop->getUniqueId()) { 
            myName = vop->getParmNameCache();
        }
    VOP_CodeParm(const VOP_CodeParm &src)
        : myType(src.myType), myName(src.myName, 1), myNodeId(src.myNodeId) { }

    VOP_CodeParmType     getType() const
                         { return myType; }
    const char          *getName() const
                         { return myName; }
    void                 setName(const char *name)
                         { myName.harden(name); }
    VOP_ParmGenerator   *getOp() const
                         { 
                             OP_Node *node = OP_Node::lookupNode(myNodeId);
                             if (!node)
                                 return NULL;

                             return dynamic_cast<VOP_ParmGenerator *>(node); 
                         }
    int                  getOpId() const
                         { return myNodeId; }
    bool                 operator==(const VOP_CodeParm &s) const
                         {
                             return myType == s.myType &&
                                    myNodeId == s.myNodeId &&
                                    myName == s.myName;
                         }
    bool                 operator!=(const VOP_CodeParm &s) const
                         { return !(*this == s); }
    const VOP_CodeParm  &operator=(const VOP_CodeParm &src)
                         {
                             myType = src.myType;
                             myName.harden(src.myName);
                             myNodeId = src.myNodeId;
                             return *this;
                         }

private:
    VOP_CodeParmType     myType;
    UT_String            myName;
    int                  myNodeId;
};

class VOP_CodeParmList
{
public:
                         VOP_CodeParmList()
                         { }
                         VOP_CodeParmList(const VOP_CodeParmList &src_list)
                         {      
                            clear();

                            int i;
                            for (i=0; i<src_list.entries(); i++)
                                append(src_list(i));
                         }
                        ~VOP_CodeParmList()
                         { clear(); }

    const VOP_CodeParmList      &operator=(const VOP_CodeParmList &src)
                                {
                                    if (&src != this)
                                    {
                                        int             i;
                                        clear();
                                        for (i=0; i<src.entries(); i++)
                                            append(src(i));
                                    }
                                    return *this;
                                }
    bool                 operator==(const VOP_CodeParmList &src) const
                         {
                             int                i;
                             if (entries() != src.entries())
                                 return false;
                             for (i = 0; i < entries(); ++i)
                                 if ((*this)(i) != src(i))
                                     return false;
                             return true;
                         }
    bool                 operator!=(const VOP_CodeParmList &s) const
                            { return !(*this == s); }

    void                 append(const VOP_CodeParm &parm)
                         {
                             VOP_CodeParm *new_parm;
                             new_parm = new VOP_CodeParm(parm);

                             myParms.append(new_parm);
                             myParmNodes.addSymbol(
                                UT_Hash_Int(new_parm->getOpId()),
                                UT_Thing(new_parm));
                         }
    void                 insert(const VOP_CodeParm &parm, int idx)
                         {
                             VOP_CodeParm *new_parm;
                             new_parm = new VOP_CodeParm(parm);

                             myParms.insert(new_parm, idx);
                             myParmNodes.addSymbol(
                                UT_Hash_Int(new_parm->getOpId()),
                                UT_Thing(new_parm));
                         }
    void                 move(int first, int last, int newpos)
                         {
                             myParms.move(first, last, newpos);
                         }
    void                 remove(int idx)
                         {
                             VOP_CodeParm   *parm;
                             int             node_id;

                             node_id = myParms(idx)->getOpId();
                             parm = myParms(idx);

                             myParms.removeIndex(idx);
                             myParmNodes.deleteSymbol(UT_Hash_Int(node_id));
                             delete parm;
                         }
    void                 clear()
                         {
                             int i;
                             for (i=0; i<myParms.entries(); i++)
                                 delete myParms(i);
                             myParms.clear();
                             myParmNodes.clear();
                         }

    /// Return the list index of the requested parameter.
    /// Return -1 if no parameter with the name equal to `parm_name`
    /// can be found in the list.
    int                  getParmIndex(const char *parm_name) const
                         {
                             if (!parm_name)
                                 return -1;

                             for (int i=0; i<myParms.entries(); i++)
                             {
                                 const char *code_parm_name;
                                 code_parm_name = myParms(i)->getName();
                                if (!code_parm_name)
                                    continue;

                                 if (::strcmp(code_parm_name, parm_name) == 0)
                                     return i;
                             }

                             return -1;
                         }

    /// Return the name of the parameter generated by the given node.
    /// If no such parameter exists, then return NULL.
    const char          *getParmName(int node_id) const
                         {
                            VOP_CodeParm    *code_parm;
                            UT_Thing         thing;

                            if (!myParmNodes.findSymbol(
                                UT_Hash_Int(node_id), &thing))
                                return NULL;

                            code_parm = thing.asPointer<VOP_CodeParm>();
                            return code_parm->getName();
                         }

    const VOP_CodeParm  &operator()(int idx) const
                         {
                             return *myParms(idx);
                         }
    VOP_CodeParm        &operator()(int idx)
                         {
                             return *myParms(idx);
                         }
    int                  entries() const
                         {
                             return myParms.entries();
                         }
    bool                 hasNode(int node_id) const
                         {
                             UT_Thing    thing;

                             return myParmNodes.findSymbol(
                                UT_Hash_Int(node_id), &thing) != 0;
                         }
    bool                 hasParmName(const char *parm_name) const
                         {
                            if (!parm_name)
                                return false;

                            for (int i=0; i<myParms.entries(); i++)
                            {
                                const char *code_parm_name;
                                code_parm_name = myParms(i)->getName();
                                if (!code_parm_name)
                                    continue;

                                if (::strcmp(code_parm_name, parm_name) == 0)
                                    return true;
                            }

                            return false;
                         }



private:
    UT_PtrArray<VOP_CodeParm*>           myParms;
    UT_HashTable                         myParmNodes;
};

class VOP_API VOP_CodeOperatorFilter : public OP_OperatorFilter
{
public:
    VOP_CodeOperatorFilter(const char *optypename, VOP_CodeGenerator *owner);
    virtual ~VOP_CodeOperatorFilter();

    virtual bool         allowOperatorAsChild(OP_Operator *op);

private:
    UT_StringArray       myVopnetTypes;
    VOP_CodeGenerator   *myOwner;
};


class VOP_API VOP_CodeGenerator
{
public:
    /// Constructor
    /// @param owner    The network based on which the code is generated (whose
    ///                 outupt node is used during code generation, etc)
    /// @param context_type A list of context type for a specific language,
    ///                 which the generator will generate code for. For
    ///                 single-context shaders, the list will have a single
    ///                 entry, while multi-context shaders will have several.
    ///                 The code generator will take ownership of that 
    ///                 context type list object and will delete it in the
    ///                 destructor.
    /// @param mininputs    Minimum number of inputs to the owner
    /// @param maxinputs    Maximum number of input to the owner
                         VOP_CodeGenerator(OP_Network *owner,
                                   VOP_LanguageContextTypeList * context_type,
                                   int mininputs,
                                   int maxinputs);
    virtual             ~VOP_CodeGenerator(void);

    OP_OperatorFilter   *getOperatorFilter();
    UT_ErrorManager     &getErrorManager();

    void                 beforeAddNode(OP_Node *node);
    void                 afterAddNode(OP_Node *node);
    void                 appendCompileErrors(OP_NodeInfoParms &info,
                                            bool addseparator) const;

    /// Sometimes a VOP needs to change its variable tables (i.e. an
    /// encapsulated shader)
    void                 resetTables(VOP_Node *node);

    /// Functions for controlling when a code generator is updated.
    /// The code pattern is something like this:
    ///     int update_id = codegenerator->beginUpdate();
    ///     ...
    ///     if (errors_needs_to_update)
    ///         codegenerator->setNeedsErrorUpdate();
    ///     ...
    ///     if (parm_needs_to_update)
    ///         codegenerator->setNeedsParmUpdate();
    ///     ...
    ///     if (code_needs_to_update)
    ///         codegenerator->setNeedsCodeUpdate();
    ///     ...
    ///     codegenerator->endUpdate(update_id);
    /// @{
    int                 beginUpdate();
    void                endUpdate(int update_level);

    void                clearAllUpdateFlags()
                        {
                            myNeedsErrorUpdate = false;
                            myNeedsParmUpdate = false;
                            myNeedsCodeUpdate = false;
                        }
    void                setNeedsErrorUpdate()
                        {
                            UT_ASSERT(myUpdateLevel > 0);
                            myNeedsErrorUpdate = true;
                        }
    void                setNeedsParmUpdate()
                        {
                            UT_ASSERT(myUpdateLevel > 0);
                            myNeedsParmUpdate = true;
                        }
    void                setNeedsCodeUpdate()
                        {
                            UT_ASSERT(myUpdateLevel > 0);
                            myNeedsCodeUpdate = true;
                        }
    void                performFullUpdate()
                        {
                            int update_id = beginUpdate();
                            setNeedsErrorUpdate();
                            setNeedsParmUpdate();
                            setNeedsCodeUpdate();
                            endUpdate(update_id);
                        }
    /// @}

    /// @{
    /// A flag to indicate if the cached parameters may have outdated parm
    /// tag that specifies parameter's shading contexts. Only shop clerk
    /// is interested in this tag and currently manages the updating itself.
    void                 setContextParmTagDirty()
                         {
                             myContextParmTagDirty = true;
                         }
    bool                 isContextParmTagDirty() const
                         {
                             return myContextParmTagDirty;
                         }
    /// @}

    void                 ownerChanged(OP_EventType reason, void *data);
    void                 ownerFinishedLoadingNetwork();
    void                 generateVopErrors();
    bool                 getVariableString(int index, UT_String &value);

    /// Update the definition and layout of the parameters exported
    /// by the VOP network.  Exported parameters are ones that are defined
    /// by Parameter VOPs in the network.  The parameter layout is stored
    /// in the owner node's parameter layout.
    void                 updateExportedParameters();

    /// Update the layout of the exported parameters using the layout,
    /// `new_parm_layout`, that is passed in.  The new layout is applied
    /// to the owner node's parameter layout and can contain a mix of
    /// exported parameters and regular parameters.  Use `old_parms` to
    /// supply a list of parameters that are to be renamed/deleted from
    /// the layout.  Set `apply_changes_to_parm_vops` to true if you want
    /// to apply the changes from `old_parms` to the defining Parameter VOPs.
    void                 updateExportedParameterLayout(
                            const PI_EditScriptedParms &new_parm_layout,
                            const PI_OldParms &old_parms,
                            bool apply_changes_to_parm_vops=false);

    /// Return the definition and layout of the parameters that are exported 
    /// by the VOP network.  The layout can contain a mix of exported
    /// and regular parameters.
    ///
    /// You can optionally set `use_incoming_layout` to true if you want 
    /// to use the layout already defined by `parm_layout` instead of 
    /// the parameter layout stored on the owner node.  In that case, 
    /// the exported parameter definitions are merged into the incoming
    /// layout with new parameters being added to the end.
    void                 getExportedParameterLayout(
                            PI_EditScriptedParms &parm_layout,
                            bool use_incoming_layout=false);

    const char          *getEnglishName();
    /// @{
    /// The function name is mangled for some renderers (i.e. RSL) since basing
    /// the function name on the node name is not safe.  However, some places
    /// require the node name -- unmangled (i.e. dialog scripts).
    const char          *getFunctionName(UT_WorkBuffer &storage) const;
    const char          *getInternalFunctionName(UT_WorkBuffer &storage) const;
    /// @}
    /// The function path is the leading path to the shader
    const char          *getFunctionPath(UT_WorkBuffer &storage) const;
    int                  getMinimumInputs() const;
    int                  getMaximumInputs() const;
    void                 getInternalOperatorInfo(OP_OTLDefinition &info);
    void                 getInternalScriptDefinition(UT_String &definition);

    /// Returns ture if the generator can generate code for the given type.
    bool                 canGenerateCode( VOP_Type shader_type) const;

    void                 setVexCodeDirty();
    bool                 outputVexCode(ostream &os, const char *shadername,
                                       VOP_ContextType context_type = 
                                            VOP_CONTEXT_TYPE_INVALID);

    /// Generates a VFL code and writes it to the os. 
    /// @param  shadername      The name of the shader function.
    /// @param  context_type    For multi-context materials, this is the shader
    ///             context for which to generate code.
    /// @param  skipheader      If true the file comment will be skpped;
    ///             the file comment contains info about original
    ///             node, file name, and generation time stamp.
    /// @param  output_node_name    Optional, this is a hint that specifies 
    ///             the name of the output node for which to generate the code.
    ///             If the node by this name is found and it supports the 
    ///             context type (if given), then it is used for gathering
    ///             nodes that participate in VFL code generation. 
    ///             If the node by this name cannot be used, then a Collect VOP
    ///             node will be used. And if there is no collect node
    ///             a (arbitrary) output node supporting the context type
    ///             will be used.
    void                 outputVflCode(ostream &os, const char *shadername,
                                       VOP_ContextType context_type = 
                                            VOP_CONTEXT_TYPE_INVALID,
                                       bool skipheader = false,
                                       const char * output_node_name = NULL);

    /// Return the time stamp from when VEX code was last generated or -1
    /// if no cached code exists
    int                  getCachedCodeTimeStamp(VOP_ContextType context_type) const;

    /// Output the dialog script of the exported parameter layout.
    void                 outputExportedParameterLayout(ostream &os);

    void                 generateRslObject(UT_String &ofile,
                                           const char *cache_directory,
                                           const char *renderer,
                                           int major_version,
                                           int minor_version,
                                           const char *shaderpath,
                                           const char *shadername,
                                           VOP_ContextType context_type,
                                           bool ignore_dirty_flag,
                                           UT_String *error_return);

    // Get a list of all Parameter type VOPs.
    void                 getParameterNodes(VOP_CodeParmList &list,
                                           bool includeInvisible);

    // Returns our owner's output nodes.
    void                 getOutputNodes(VOP_NodeList & outputs) const;

    /// Return the collection VOP (or NULL if there is no collection)
    VOP_Collect         *getCollectNode() const;

    /// Return the code generating encapsulated shader for the given context
    /// (or NULL).
    VOP_Node            *getEncapsulatedShader(VOP_ContextType context) const;

    /// Return true if the owner has a node which defines a parameter
    /// with the given name.
    bool                 hasParmNode(const char *parm_name) const;

    /// Return a pointer to the Parameter VOP node that corresponds
    /// to the given parameter name.  Return NULL if no such node
    /// exists.
    VOP_ParmGenerator   *getParmNode(const char *parm_name) const;

    /// Return the exported parameter name associated with the specified node.
    /// Return NULL if the given node is not a parameter generator VOP
    /// for this code generator.
    const char          *getParmName(int node_id) const;

    // Expand the compiler & options using local variables.
    const char          *getCompiler(UT_String &compiler, fpreal now,
                                     const char *defcompiler);
    const char          *getCompiler(UT_WorkBuffer &wbuf, fpreal now,
                                     const char *defcompiler);

    /// Get a string containing the errors from our last compile.
    /// Returns true if there were any errors.
    bool                 getCompilerErrors(UT_String * errors) const;

    /// Get the VOP language generated by this code generator.
    const VOP_Language  *getLanguage() const
                         { return myLanguage; }

    /// Get the object representing the list of shader contexts (surface,
    /// displacement, etc) supported by this generator. The returned object
    /// also describes the language type supported by this generator.
    const VOP_LanguageContextTypeList * getLanguageContextTypeList() const
                         { return myContextTypeList; }

    /// Returs a language for which this generator produces code.
    VOP_LanguageType     getLanguageType() const;

    /// Returns true if it is a single-context vopnet that this generator
    /// produces code for. Otherwise (ie, multi-context) returns false.
    bool                 isSingleContextType() const;

    /// Returns true if the owner of the code generator displays parameters.
    /// This is currently true for VOPNET_Nodes.
    bool                 getOwnerHasParameters() const
                                { return myOwnerHasParameters; }

    /// Determine the VOP context type for single-context type vopnet generator.
    /// For generator of a multi-context vopnet returns
    /// VOP_CONTEXT_TYPE_INVALID, because the specific VOP context cannot be 
    /// reliably and unambiguously determined.
    VOP_ContextType      getVopContextType() const;

    /// Determine the VEX context type for single-context type vopnet generator.
    /// For generator of a multi-context vopnet (or for RSL vopnet) returns
    /// VEX_INVALID_CONTEXT, because the specific VEX context cannot be 
    /// reliably and unambiguously determined.
    VEX_ContextType      getVexContextType() const;

    /// Determine the VEX context type for single-context type vopnet generator.
    /// For generator of a multi-context vopnet (or for VEX vopnet) returns
    /// RSL_INVALID_CONTEXT, because the specific RSL context cannot be 
    /// reliably and unambiguously determined.
    RSL_ContextType      getRslContextType() const;

    /// Returns the compiler arguments.
    VOP_CodeCompilerArgs*getCompilerArgs()
                         { return myCompilerArgs; }

    // Functions to set the locked compiled code and dialog script. When
    // set, these values cause us to ignore our VOP nodes and always
    // return these locked values.
    void                 setLockedCompiledCode(const char *code, VOP_ContextType context_type);
    void                 setLockedCompiledDs(const char *ds);

    /// Utility function to get a code generator corresponding to the node.
    /// Returns own code generator if it exists, or creator's code generator.
    static VOP_CodeGenerator *      findCodeGenerator( const OP_Node * node );

    /// Obtains a list of known RSL context types (surface, displacement, etc).
    static void             getRegisteredRslContexts( 
                                UT_RefArray<RSL_ContextType> & context_types );
    /// Returns a name (token) for a given type.
    static const char       *getRslContextName( RSL_ContextType context_type );

    /// Returns a context type based on context name (token) 
    static RSL_ContextType   getRslContextTypeFromName(  const char * name );

    /// Returns a context label token for a given type.
    static const char       *getRslContextLabel( RSL_ContextType context_type );

    // The local variables that must be defined by any code generator node.
    // These are the variables understood by the getVariableString function
    static CH_LocalVariable      theLocalVariables[];

    // Install commands specific to VOP code generators.
    static void                  installCommands();

    // This function converts a local VOP code generator to a global VOP code
    // generator that defines an operator type.
    static bool                  convertVopOpToVopOpType(OP_Node *node,
                                                         UT_String &err);

    // These variables define the parameter descriptions for the VOP
    // compiler parm used to specify how to compile VOP generated code.
    static PRM_Name              theVopCompilerName;
    static PRM_Default           theVopCompilerVexDefault;
    static PRM_Default           theVopCompilerRslDefault;
    static PRM_ChoiceList        theVopCompilerChoices;
    static PRM_Name              theVopForceCompileName;

    static bool                  forceCompile(OP_Node *node);
    static int                   forceCompile(void *data, int, fpreal,
                                              const PRM_Template *);

    /// Determines the vex context. In single-context vop, returns a vex type
    /// intrinsic to that vop. In multi-context vop, returns the vex type based
    /// on context_type passed as an argument.
    VEX_ContextType      pickVexContextType(VOP_ContextType context_type) const;

    /// Determines the rsl context. In single-context vop, returns a rsl type
    /// intrinsic to that vop. In multi-context vop, returns the rsl type based
    /// on context_type passed as an argument.
    RSL_ContextType      pickRslContextType(VOP_ContextType context_type) const;

    /// Determines the vop context (ie encode vex or rsl context type). 
    /// In single-context vop, returns a vex/rsl context type (encoded as vop
    /// type) intrinsic to that vop. In multi-context vop, returns the vop 
    /// type based passed as an argument.
    VOP_ContextType      pickContextType(VOP_ContextType context_type) const;

    // Locates a procedural shader by searching the VOP network an output node
    // of type "interpret_type" and tracing back to the first non-simple node.
    VOP_Node            *getProcedural(VOP_Type interpret_type) const;

    /// Gathers all the rendering properties nodes.
    void                 getPropertiesNodes(VOP_NodeList &properties);

    const VOP_CodeParmList      &getCodeParmList() const
                                    { return myExportedCodeParms; }

    bool isCompiled(VOP_ContextType context_type) { return myLockedCompiledCode[context_type].length() > 0; }

private:
    /// Get a list of all vop nodes participating in the shader. The list
    /// is sorted according to order in which the vfl code should be generated.
    /// NB: when nodes a no longer needed, use cleanupNodesForShaderOutput() 
    ///     to clean up the list of temporary nodes this method may create.
    bool                 getNodesForShader(VOP_NodeList &nodes, 
                                    VOP_ContextType picked_context_type,
                                    VOP_CodeVarMapperContext &varmap_context,
                                    const char *output_node_name);

    /// Clean up the list obtained with getNodesForShader()
    void                 cleanupNodesForShader(VOP_NodeList &nodes);

    void                 outputBodyCodeWithIndents(ostream &os,
                                UT_WorkBuffer &code);
    void                 outputVflHeaderComment(ostream &os);
    bool                 outputVflPragmasAndFunctionBlock(ostream &os,
                                const char *shadername,
                                VOP_ContextType context_type,
                                const char *output_node_name);
    void                 outputVflPragmas(ostream &os, 
                                const VOP_NodeList & nodes, 
                                VOP_ContextType context_type);
    bool                 outputVflFunctionBlock(ostream &os,
                                const VOP_NodeList & nodes, 
                                VOP_CodeVarMapperContext & root_varmap_context,
                                const char *shadername,
                                VOP_ContextType context_type);
    void                 outputVflFunctionDeclaration(ostream &os,
                                                const VOP_NodeList & nodes, 
                                                const char *shadername,
                                                VOP_ContextType context_type);
    void                 outputVflEmptyFunction(ostream &os,
                                                const char *shadername,
                                                VOP_ContextType context_type);
    void                 outputChildrenParameterBlocks(OP_Network *net,
                                                ostream &os);
    void                 outputParameterDeclarations(ostream &os,
                                                const VOP_NodeList & nodes, 
                                                const char *indent,
                                                VOP_ContextType context_type);
    void                 outputDSNodeInfo(ostream &os);

    void                 clearFileCache();

    /// Generate a dialog script for the defining VOP network
    /// and its Parameter VOP nodes.
    void                 generateScriptDefinition(UT_String &definition);

    /// Generate a dialog script for the defining VOP network,
    /// the Parameter VOP nodes, and the parameter layout set by
    /// the user on the owning VOPNET node.  The dialog script also
    /// includes spare parameters created on the owning node.
    void                 generateLayoutScriptDefinition(UT_String &definition);

    /// Builds an information about which parameters belong to which contexts.
    void                 buildParmContextInfo(VOP_ParmContextInfo &info);

    /// Obtains a list of all parameter nodes for the material (if it is 
    /// a material vopnet) or for the shader (if it is just a shader)
    void                 getParameterNodes(OP_Network *net,
                                           VOP_CodeParmList &list,
                                           ostream *os,
                                           bool includeInvisible,
                                           const VOP_ParmContextInfo &info);
    void                 getParameterNodes(VOP_CodeParmList &list,
                                           ostream *os,
                                           bool includeInvisible);
    void                 assignSubnetInOutVariables(VOP_Node *node,
                                        VOP_Node *subnet,
                                        UT_SymbolTable &localVarTables,
                                        VOP_CodeVarLookupData &data) const;

    /// Expand subnets and Fetch VOPs in the given list.
    /// Nodes contained in the subnets and nodes pulled in from the
    /// Fetch VOPs are inserted in the list.
    void                expandSubnetsAndFetchVOPs(VOP_NodeList &nodes,
                            VOP_ContextType context_type,
                            VOP_CodeVarMapperContext &root_context) const;

    // These functions are used for resolving variable names.
    static const char   *createUniqueVariableName(const char *str,
                                                  UT_SymbolTable &varTable);
    static const char   *doVariableReplacement(const char *str,
                                               void *userdata);

    /// Helper function for doVariableReplacment.
    /// Get the variable name for the given VOP and input index.
    /// Handle the cases where auto-convert nodes or Fetch VOPs are
    /// connected to the input.
    static void          resolveVariableFromNodeInput(VOP_Node *vop, 
                            int inputidx, VOP_CodeVarLookupData *data, 
                            VOP_CodeVarMapperContext *context, 
                            UT_String &variable);

    void                 addVariableNames(VOP_Node *vop,
                                          UT_SymbolTable &varTable,
                                          VOP_CodeVarMapper &varMapper,
                                          VOP_CodeVarMapperContext *context);

    /// Checks if the temporary files have been already created for this
    /// context, and returns them if so. If not, it creates the files, and 
    /// then returns them. The temporary files will store the vfl code that is
    /// passed to vcc compiler and any errors that occured during compilation.
    /// They are means of passing the source code to the compiler.
    void                 ensureTempFilesCreated(VOP_ContextType context_type,
                                                UT_String & vfl_file,
                                                UT_String & err_file);

    // Gets a suffix that disambiguates the files for the same function name 
    // but different context for a multi-context VOP. 
    void                 getRslFileSuffix( UT_String & suffix,
                                           VOP_ContextType context_type );

    // Cached data for a given context type. For VEX, this stores both vex code
    // and error messages. For RSL, only error messages, since object code ends
    // up in a .slo file.
    struct VOP_CodeCacheData
    {
        VOP_ContextType          myContextType;
        UT_String                myCode;
        UT_String                myErrorMessages;
        unsigned int             myTimeStamp;
    };

    // Utility functions for code cache manipulation.
    bool                hasCachedCode() const;
    VOP_CodeCacheData * findCachedCode( VOP_ContextType context_type ) const;
    VOP_CodeCacheData * addCachedCode( VOP_ContextType context_type,
                                       const char * code,
                                       const UT_String * errors );
    void                deleteCachedCode( VOP_ContextType context_type );
    VOP_CodeCacheData * removeCachedCode( VOP_ContextType context_type );
    void                addCachedCode( VOP_ContextType context_type,
                                       VOP_CodeCacheData * cache_data );
    void                clearCachedCode();

    /// Helper method to updateExportedParameters().
    /// Compare the old and new list of code parameters.
    /// Record any parameters that have been renamed or deleted
    /// and pass them back in `old_parms`.
    void                getRenamedAndDeletedParms(
                            const VOP_CodeParmList &old_code_parms,
                            const VOP_CodeParmList &new_code_parms,
                            PI_OldParms &old_parms) const;

    /// Helper method to updateExportedParameterLayout().
    /// Propagate parameter changes down to the Parameter VOPs.
    void                propagateChangesToParmVOPs(
                            const PI_OldParms &old_parms) const;

    /// Helper method to updateExportedParameterLayout().
    /// Merge two sets of spare parameters into one.
    /// The merged set is passed back as `merge_to`.
    void                mergeSpareParms(PI_EditScriptedParms &merge_to,
                            PI_EditScriptedParms &merge_from) const;

    /// Helper to test if a node parameter of a given index affects the
    /// generated shader VFL code, by switching between different
    /// Output VOP nodes. 
    bool                isMetaSwitchParm(long parm_index) const;

    /// Keeps code and other data relevant to the code generation and reuse.
    OP_Network                  *myOwner;
    VOP_LanguageContextTypeList *myContextTypeList;
    //UT_WorkBuffer              myLockedCompiledCode;
    TContextTypeStringMap        myLockedCompiledCode;
    UT_WorkBuffer                myLockedCompiledDs;
    UT_SymbolTable               myGlobalVariables;
    UT_SymbolTable               myLocalVariables;
    UT_SymbolTable               myLocalChannels;
    VOP_CodeOperatorFilter       myOperatorFilter;
    VOP_Language                *myLanguage;
    VOP_CodeCompilerArgs        *myCompilerArgs;
    UT_ErrorManager              myErrorManager;
    UT_PtrArray<VOP_CodeCacheData*> myCachedCode;
    UT_SymbolTable               myTempVflFiles;
    UT_SymbolTable               myTempErrFiles;
    UT_String                    myHipName;
    UT_String                    myCachedEnglishName;
    UT_String                    myCachedDialogScript;
    UT_String                    myCachedLayoutDialogScript;
    int                          myCachedMinInputs;
    int                          myCachedMaxInputs;
    int                          myMinimumNumberOfInputs;
    int                          myMaximumNumberOfInputs;
    VOP_CodeParmList             myExportedCodeParms;

    int                          myUpdateLevel;
    bool                         myNeedsErrorUpdate;
    bool                         myNeedsParmUpdate;
    bool                         myNeedsCodeUpdate;

    bool                         myOwnerHasParameters;
    bool                         myIsChangingOwnerSpareParms;
    bool                         myIsReCookingOwner;
    bool                         myNeedAutoConvertCleanup;

    bool                         myContextParmTagDirty;
};

class VOP_CodeGeneratorErrorThief
{
public:
                 VOP_CodeGeneratorErrorThief(OP_Node &node)
                     : myNode(node)
                 {
                 }
                ~VOP_CodeGeneratorErrorThief()
                 {
                     if( myNode.getVopCodeGenerator() )
                     {
                         myNode.stealErrors(
                                myNode.getVopCodeGenerator()->getErrorManager(),
                                true);
                     }
                 }

private:
    OP_Node     &myNode;
};

#endif

---