CH/CH_Expression.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:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Channel Library (C++)
 *
 * COMMENTS:    This might want to be moved into the utility library
 *              if possible.
 *
 * CLASSES:
 *      CH_ExprVariable:
 *              Used for looking up variable names in expressions
 *      CH_Expression:
 *              A class for evaluating expressions.
 * 
 */

#ifndef __CH_Expression_h__
#define __CH_Expression_h__

#include "CH_API.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_String.h>
#include "CH_ExprLanguage.h"

class EV_FUNCTION;
class UT_IStream;
class EV_EXPRESSION;
class PY_CompiledCode;

class CH_API CH_Expression
{
public:
    CH_Expression(const char *expr, CH_ExprLanguage language);
   ~CH_Expression();

    void                 save(ostream &os, int binary, bool compiled) const;
    bool                 load(UT_IStream &is);

    const char          *getExpression() const;
    void                 setExpression(const char *expr,
                                       CH_ExprLanguage language);
    unsigned             getExpressionFlag() const;
    void                 setExpressionFlag(int flag);

    CH_ExprLanguage      getLanguage() const;
    void                 setLanguage(CH_ExprLanguage language);

    void                 unresolveLocalVars(int thread);

    unsigned             isCompiled() const;
    unsigned             isHardwired() const;

    /// Evaluate as a float
    float                evaluate(int thread);
    /// Evaluate as a string
    void                 evaluateString(UT_String &result, int thread);

    void                 dirtyExprCache();

    int                  modified() const;
    int                  usesInValue();
    int                  usesOutValue();
    int                  usesValues();
    int                  usesSlopes();
    int                  usesAccels();
    int                  usesKnots();

    void                 buildOpDependencies(void *ref_id, int thread);
    int                  changeOpRef(const char *new_fullpath,
                                     const char *old_fullpath,
                                     const char *old_cwd,
                                     const char *chan_name,
                                     const char *old_chan_name,
                                     int thread);

    void                *getSingleFunctionInstanceData(
                            EV_FUNCTION *func, int thread, UT_String &argument);

    int                  findString(const char *str, bool fullword,
                                    bool usewildcards) const;
    int                  changeString(const char *from, const char *to,
                                      bool fullword, int thread);

    const char          *getReferencePath() const;
    void                 setReferencePath(const char *path);

    CH_Expression       &operator=(const CH_Expression &from)
                         {
                            const char  *src;
                            if (src = from.getExpression())
                                setExpression(src, from.getLanguage());
                            return *this;
                         }
    
    operator const char *() const { return getExpression(); }

    // This static method is called to add time dependency flags to the
    // currently evaluating expression, flag it as using input slopes, etc.
    // The flags use thread-local storage, so python code making HOM calls
    // from different threads won't accidentally set each others' flags.
    static void          addExprFlags(int flags, int thread);

    // This method lets you get at the flags directly.  The Python sop,
    // for example, needs to know if the code set the time-dependent flag
    // when it evaluated, so it needs to clear the flags beforehand, check
    // them after the cook, and restore them.
    static int          &exprFlags();

    // THIS FUNCTION IS DEPRECATED!! Only left here for backwards
    // compatibility. The proper way to mark expression evaluation as time
    // dependent is to turn on the CH_EXPRTIME flag in the expression callback
    // using the EV_FUNCTION *func like so: func->myFlags |= CH_EXPRTIME.
    //
    // Old Note: HDK users may rely on setTimeDependency(), even if we don't
    // call it directly.  It's a shortcut for addExprFlags(CH_EXPRTIME);
    static SYS_DEPRECATED void setTimeDependency();

private:
    void changeExpr(const char *source, int thread);

    CH_ExprLanguage      myLanguage;
    EV_EXPRESSION       *myExpr;
    PY_CompiledCode     *myPyExpr;
    UT_String            myReferencePath;

    friend ostream      &operator<<(ostream &os, const CH_Expression &d)
                        {
                            d.save(os, 0, false);
                            return os;
                        }
};

#endif

---