Windows Kernel

Development Platform:
Visual C++

emrule.h：Code Content
							/*****************************************************************************
    emrule.h
    Owner: DaleG
    Copyright (c) 1992-1997 Microsoft Corporation
    General Rule-Network Propagation Engine functions and prototypes
----------------------------------------------------------------------------
    NOTE:
    1.  BAD CODE, but it works: FIsDelayFactor(),LpruldependFromCDelay() and
        CDelayFromLpruldepend() rely upon the fact (?) that pointers
        on the machines we support are never (?) small integers.  But if
        this should ever prove false, it would be bad.  We should rewrite
        this to either have a RULDEP structure (as does the rule compiler),
        or make the list of dependencies indexes to rules, rather than
        pointers.
*****************************************************************************/
#ifndef EMRULE_H
#include "msodbglg.h"
#include "emkwd.h"
#include "emrulini.h"
#include "emrultk.h"
MSOEXTERN_C_BEGIN   // ***************** Begin extern "C" ********************
// REVIEW: configure this in makefile, so emtest (for example) can build
// debug without dynamic rules
#ifdef DEBUG
#ifndef YY_NODYNRULES
#define DYN_RULES 1
#endif
#endif
/*----------------------------------------------------------------------------
    System limits
----------------------------------------------------------------------------*/
#define wDelayMax           100                         // Maximum delay poss
#define irultkRuleMax       256                         // Max events cached
#define iruldepAllocMax     256                         // Max ruldeps alloced
#define ichRulNameMax       128                         // Max trace name len
#define ichRulNameAllocMax  1024                        // Max name alloc
/*************************************************************************
    Types:
    irul        Rule node ID.
    ruldep      Rule node dependency link.
    ruldepblk   Rule node dependency link allocation structure.
    sv          Split Value structure.
    rul         Rule node structure.
    ruls        Rule state structure.
 *************************************************************************/
/* I R U L */
/*----------------------------------------------------------------------------
    %%Structure: IRUL
    %%Contact: daleg
    Rule Index definition
----------------------------------------------------------------------------*/
typedef short IRUL;
#define IrulFromTk(tk)      ((IRUL) (tk))
#define TkFromIrul(irul)    (irul)
// Lexer tokens: hard-coded rule node IDs
#define irulERROR       tkERROR
#ifdef tkNil
#define irulNil         tkNil
#else /* !tkNil */
#define irulNil         0
#endif /* tkNil */
// Is rule ID valid (not irulNil and not irulERROR)
#define FValidIrul(irul) 
            ((irul) > 0)
/* R  U  L  D  E  P */
/*----------------------------------------------------------------------------
    %%Structure: RULDEP
    %%Contact: daleg
    Rule node dependency structure.
    This structure holds the dependency information that links a rule node
    to its dependents.
----------------------------------------------------------------------------*/
typedef struct _RULDEP
    {
    struct _MSORUL             *prul;                   // Node referenced
    struct _RULDEP             *pruldepNext;            // Next dependency
//  int                         cDelay;                 // Delay in eval
    } RULDEP;
MSOAPI_(RULDEP *) _MsoPruldepNew(                       // Alloc blk of deps
    int                 cruldep,
    int                 fOnFreeList
    );
// Return a new ruldep record from the free list (requires local var pruldep)
// Operates in either sequential mode (vlpruls->lpruldepNextFree) or free list
#define LpruldepNew() 
            (vlpruls->lpruldepNextFree != NULL 
                ? (vlpruls->fSeqentialFreeRuldeps 
                    ? vlpruls->lpruldepNextFree++ 
                    : (pruldep = vlpruls->lpruldepNextFree, 
                            vlpruls->lpruldepNextFree 
                                    = pruldep->pruldepNext, 
                            pruldep->pruldepNext = NULL, 
                            pruldep)) 
                : _MsoPruldepNew(iruldepAllocMax, TRUE))
// Push a ruldep record onto the free list
#define PushLpruldepOnFreeList(pruldep) 
            ((pruldep)->pruldepNext = vlpruls->lpruldepNextFree, 
             vlpruls->lpruldepNextFree = (pruldep))
/* R  U  L  D  E  P  B  L  K */
/*----------------------------------------------------------------------------
    %%Structure: RULDEPBLK
    %%Contact: daleg
    Rule node dependency allocation block structure.
    This structure allows us to batch-allocate RULDEP records.
----------------------------------------------------------------------------*/
typedef struct _RULDEPBLK
    {
    struct _RULDEPBLK      *lpruldepblkNext;            // Next block
    RULDEP                  rgruldep[1];                // Array of ruldeps
    } RULDEPBLK;
/* R  U  L  C  X  T */
/*----------------------------------------------------------------------------
    %%Structure: RULCXT
    %%Contact: daleg
    (Rul)e (C)onte(x)t-group (T)able structure.
    This structure allows the rule engine to support cheap sparse dependents
    lists for special contexts.
    The callback function allows us to perform any desired side effects
    during the propagation, as well as offering the chance to optimize
    the lookup algorithm.
----------------------------------------------------------------------------*/
typedef struct _RULCXT
    {
    struct _RULCXT         *lprulcxtNext;               // Next context
    LPFNRULCXT              lpfnrulcxt;                 // Callback fn
    int                     iruldepMax;                 // Size of array
    struct _RULCXL         *rglprulcxl[1];              // Hash table
    } RULCXT;
/* R  U  L  C  X  L */
/*----------------------------------------------------------------------------
    %%Structure: RULCXL
    %%Contact: daleg
    (Rul)e (C)onte(x)t-group (L)ist item structure.
    This is the item used in the hash table of the RULCXT above.
----------------------------------------------------------------------------*/
typedef struct _RULCXL
    {
    IRUL                    irul;                       // Rule ID
    struct _RULDEP         *pruldep;                    // Dependent list
    struct _RULCXL         *lprulcxlNext;               // Next in hash chain
    } RULCXL;
#ifdef DEBUG
/* R  U  L  N  B  L  K */
/*----------------------------------------------------------------------------
    %%Structure: RULNBLK
    %%Contact: daleg
    (Rul)e (N)ame block
    Store dynamically constructed rule names.
----------------------------------------------------------------------------*/
typedef struct _RULNBLK
    {
    struct _RULNBLK        *lprulnblkNext;              // Next block
    char                    rgch[1];                    // Block of text
    } RULNBLK;
char *LszGenNameForLprul(                               // Gen dyn rule name
    struct _MSORUL     *prul,
    int                 irulAssert
    );
char *SzSaveRulName(char *szName);                      // Save node name sz
char *LpchRulNameNew(int dichNeeded);                   // Get new name lpch
#endif /* DEBUG */
/* M  S  O  R  U  L */
/*----------------------------------------------------------------------------
    %%Structure: MSORUL
    %%Contact: daleg
    Rule node structure.
    This structure holds the state information for a rule within the
    propagation network.
    ASSUMPTIONS:
        1.  The wDelayMask field only applies to rules, but it is (currently)
            faster to not have to test for whether a node is a rule, by
            merely leaving the field empty for values.
----------------------------------------------------------------------------*/
typedef long RULV;
typedef struct _MSORUL *MSOPRUL;
#pragma pack(2)
typedef struct _MSORUL
    {
    IRUL                        irul;                   // Rule ID
    char                        rultType;               // Type: rule/event
    char                        ipfnrulscSeqCheck;      // Fn to ensure contig
    short                       rulevl;                 // Evaluation level
    short                       birulDependsOn;         // Depends on: nodes
    SVL                         svl;                    // 32-bit storage area
#ifdef DEBUG
    char const                 *lpchName;               // Name or rule text
#endif /* DEBUG */
    IRUL                        irulNextChanged;        // Next changed value
    union
        {
        short                   ipociiInstrs;           // Interp instrs
        short                   USEME_IN_EVENTS;        // Unsed slot
        };
    short                       wIntervalCount;         // Ensure contig seqs
    short                       wDelayMask;             // Delays as bit pos's
    struct _MSORUL             *prulNext;               // Next node in queue
#ifdef DEBUG
    IRUL                        irulNextTrace;          // Next traced rule
    short                       wDebugFlags;            // Random debug flags
#endif /* DEBUG */
    } MSORUL;
#pragma pack()
// Allocate new nodes
MSOAPI_(MSORUL *) MsoPrulNew(void);                     // Allocate new node
MSOAPI_(int) MsoFEnsureIrulAllocated(int irulMax);      // Pre-allocated nodes
// Discard an existing rul node
#define DiscardIrul(irul) 
            (vlpruls->irulLim--)
#define msoprulNil      ((MSORUL *) -1)                 // NIL value for MSORUL
#define msoprulInactive ((MSORUL *) -2)                 // Node is deactivated
#define wRulTrue        1000
#define wRulFalse       0
// Rule node type flags: shared with emrulini.h and rulc.h
#define rultNil             0
#define rultRule            0x00                        // Rule
#define rultEvent           0x01                        // Event/Variable
#define rultPrimaryRule     0x02                        // Rule auto-scheduled
#define rultImmediateRule   0x04                        // Rule executes immed
#define rultPersistentRule  0x20                        // Rule not cleared
#define rultAlwaysPersist   0x40                        // Rule never cleared
#define rultSpecialKwd      0x80                        // Node is generic type
// Debug check that rule is not marked as both NonTerminal and Seq
#define rultRuleMask        0x19
#ifdef NEVER
#define FRultRuleIs(rult, rultExpected) 
            (((rult) & rultRuleMask) == ((rultExpected)))
#endif /* NEVER */
#ifdef DEBUG
#define rultDynActionRule   0x04                        // Dyn DEBUG only
#define rultNonTermRule     0x08                        // Dyn DEBUG only
#define rultSeqRule         0x10                        // Dyn DEBUG only
#endif /* DEBUG */
/* R  U  L  S */
/*----------------------------------------------------------------------------
    %%Structure: RULS
    %%Contact: daleg
    Rule state structure.
    This structure holds the state information for the rule engine.
----------------------------------------------------------------------------*/
typedef int (WIN_CALLBACK *LPFNRul)(IRUL irul);         // Rule Eval function
typedef short (WIN_CALLBACK *PFNRULSC)(void);           // Interval seq chk fn
typedef int (*PFNRULVT)(IRUL irul);                     // Rule V-Table
typedef struct _RULS
    {
    // Rule base limits
    RULLIMS             rullims;                        // Rule base limits
    int                 irulMax;                        // Num nodes allocated
    int                 irulLim;                        // Num nodes used
    // Rule base state information
    RULDEP           ***rgrgpruldepDependents;          // List of Dep lists
    RULDEP            **rgpruldepDependents;            // Active Dep lists
    MSORUL            **lrglprulBlk;                    // Array of node arrays
    int                 ilprulNodesLim;                 // #arrays of arrays
#ifdef DEBUG
    MSORUL            **rgprulNodes;                    // Debug node array
#endif /* DEBUG */
    const short        *prulgAppendTo;                  // Group linkages
    const short        *prulgAppendedFrom;              // Group linkages
    short const        *rgrulevlRulevt;                 // Event_type eval lvls
    int                *rgrulevlRulevtLast;             // Highest Q of rulevts
    MSORUL            **rgprulActiveQueues;             // Active eval queues
    MSORUL            **rgprulDelayedQueues;            // Delayed eval queues
    MSORUL             *lprulQPersistent;               // Temp Q: persistent
    int                *rgirulRulevtChanged;            // Nodes changed in evt
    int                *rgrulevtEval;                   // Pending rulevt eval
    MSORULTKH          *prultkhRulevtHistory;           // Ev history for type
    long               *rgdtkiRulevt;                   // #times enter rulevt
    const int          *rgrulevtFromRulevl;             // Trans lvls to evts
    const short        *lpgrpirulDependBack;            // Back dependencies
    LPFNRul             lpfnEvalRule;                   // Evaluate rule code
    PFNRULSC const     *rgpfnrulscSeqCheck;             // Interval seq chk fns
    MSOKWTB           **rgpkwtbKeyTables;               // Keyword tables
    // Allocation information
    WORD                fDynamicInit : 1;               // Structs alloced?
    WORD                fDynAlloced : 1;                // vlpruls alloced?
    WORD                fDependBackDynAlloced : 1;      // Back deps alloced?
    WORD                fRgDependDynAlloced : 1;        // Dep lists alloced?
    WORD                fDynRulesAlloced : 1;           // Dyn rulebase alloc?
    WORD                fRgrulevlRulevtAlloced : 1;     // Last lvl tbl alloc?
    WORD                fRgprulQueuesAlloced : 1;       // Eval queues alloc?
    WORD                fRgrulevtFromRulevlAlloced : 1; // Lvl-evt tbl alloc?
    WORD                fRgprulNodesAlloced : 1;        // DEBUG nd arr alloc?
    int                 rulgCurr;                       // Current rule group
    IRUL                irulSelf;                       // irulSelf under eval
    MSORUL             *prulEvent;                      // Event causing eval
    IRUL                irulPrimaryEvent;               // Primary ev of intvl
    RULDEP             *lpruldepNextFree;               // Next free dep rec
    RULDEPBLK          *lpruldepblkDependBlocks;        // List of dep blocks
    RULCXT             *lprulcxtActive;                 // Active context list
    RULCXT            **lrglprulcxtContexts;            // List of cntx groups
    int                 rulevtCurr;                     // Current event_type
    int                *prulevtEvalLim;                 // Num Ev types to eval
    MSORUL             *lprulQueue;                     // Current queue
    int                 rulevlRultevtMin;               // 1st eval lvl in evt
    int                 rulevlRulevtLast;               // Last eval lvl in evt
    void               *pociiDynRules;                  // Dyn-loaded rulebase
#ifdef DEBUG
    char               *lpchNames;                      // Name/string buf
    char const * const *rgpchDynNames;                  // Interp: node names
    int                 irulQTrace;                     // Backtrace list
    int                 dichNameFree;                   // Num chars avail
    char               *lpchNameNextFree;               // Next free name rgch
    RULNBLK            *lprulnblkNames;                 // Dyn name list
#endif /* DEBUG */
    // Run-time flags
    WORD                fInited : 1;                    // Rule base inited?
    WORD                fNew : 1;                       // Rule base new?
    WORD                fSeqentialFreeRuldeps : 1;      // Free ruldeps are seq
    WORD                fEvaluatingDeferred : 1;        // Evaling deferred nd?
    WORD                fEvaluating: 1;                 // Eval recursion check
    // Multiple Rule base support
    struct _RULS       *lprulsNext;                     // Next struct LIFO
    // Allocation info
    WORD                fAllocedSpare1 : 1;
    WORD                fAllocedSpare2 : 1;
    WORD                fAllocedSpare3 : 1;
    WORD                fAllocedSpare4 : 1;
    WORD                fAllocedSpare5 : 1;
    WORD                fAllocedSpare6 : 1;
    WORD                fAllocedSpare7 : 1;
    WORD                fAllocedSpare8 : 1;
    WORD                fAllocedSpare9 : 1;
    WORD                fAllocedSpare10 : 1;
    WORD                fAllocedSpare11 : 1;
    int                 ilprulNodesAllocFirstLim;       // Start alloc'd nds +1
    long                lReturn;                        // Return value
    LPV                 lpvSpare3;
    LPV                 lpvSpare4;
    LPV                 lpvSpare5;
    LPV                 lpvSpare6;
    LPV                 lpvSpare7;
    LPV                 lpvSpare8;
    LPV                 lpvSpare9;
    LPV                 lpvSpare10;
    LPV                 lpvSpare11;
    // Debug logging
#ifdef DEBUG
    unsigned int        grfDebugLogFilter;              // DEBUG: how to log
#endif /* DEBUG */
#ifdef DYN_RULES
    // Dynamically-loaded rulebase support
    struct _MSOOCIS    *pocis;                          // Op-Code Interp State
    short               irulRuleInterpLim;              // #Interpreted rules
    short               irulRuleInterpMac;              // #Alloced inter ptrs
    void              **rgpociiRules;                   // Rule instructions
#endif /* DYN_RULES */
    } RULS;
extern RULS            *vlpruls;                        // Global rule state
//----------------------------------------------------
// If using debugger, an rulebase node's value is given by:
//      rulv_<irul> == vlpruls->rgprulNodes[irul]->svl.lValue
//
// Or if the rulebase is statically initialized,    and
// DEBUG_RULE_POINTERS is #defined              then
//      event FOO   can be accessed as *prulFOO     and
//      rule 126    can be accessed as *prul126
//----------------------------------------------------
// Return the number of rules in rule base
#define IrulMax()               (vlpruls->irulMax)
// Return the number of compiled rules in rule base
#define IrulCompiledMax()       (vlpruls->rullims.irulRulesMax)
// Return the number of event_types in rule base
#define RulevtMax()             RulevtMaxPruls(vlpruls)
// Return the number of event_types in rule base
#define RulevtMaxPruls(pruls) 
            ((pruls)->rullims.rulevtMax)
// Return the number of evaluation levels in rule base
#define RulevlMax()         RulevlMaxPruls(vlpruls)
// Return the number of evaluation levels in rule base
#define RulevlMaxPruls(pruls) 
            ((pruls)->rullims.rulevlMax)
#define irulMaxAlloc        128                         // Max nodes/array
#define cbfIrulShift        7                           // #bits irulMaxAlloc
#define wIrulMask           0x7F                        // Mask: irulMaxAlloc
#define ilprulMaxAlloc      256L                        // Max arrays of arrys
///#define irulMaxAlloc     2048                        // Max nodes/array
///#define cbfIrulShift     11                          // #bits irulMaxAlloc
///#define wIrulMask        0x7FF                       // Mask: irulMaxAlloc
///#define ilprulMaxAlloc   100L                        // Max arrays of arrys
///#define irulMaxAlloc     1024                        // Max nodes/array
///#define cbfIrulShift     10                          // #bits irulMaxAlloc
///#define wIrulMask        0x3FF                       // Mask: irulMaxAlloc
///#define ilprulMaxAlloc   100L                        // Max arrays of arrys
// Return the rule node structure pointer for the rule ID
#define LprulFromIrul(irul) 
            (&vlpruls->lrglprulBlk 
                [(irul) >> cbfIrulShift] [(irul) & wIrulMask])
// Return the rule ID of the rule node structure pointer
#define IrulFromLprul(prul)  
            ((prul)->irul)
// Return the Lim irul value for iruls that are contiguous with the irul
#define IrulLimContig(irul) 
            ((((irul) >> cbfIrulShift) << cbfIrulShift) + irulMaxAlloc)
// Return whether rule node is a primary rule
#define FPrimaryRule(prul)      ((prul)->rultType & rultPrimaryRule)
#ifdef NEVER
// Return whether rule node is a action rule
#define FActionRule(prul)       ((prul)->wDebugFlags & rultActionRule)
#endif /* NEVER */
#ifdef DEBUG
// Return whether rule node is a non-terminal rule (then)
#define FNonTermRule(prul)      ((prul)->wDebugFlags & rultNonTermRule)
// Return whether rule node is a sequence rule (...)
#define FSeqRule(prul)          ((prul)->wDebugFlags & rultSeqRule)
#endif /* DEBUG */
// Return whether the node ID refers to an event node
#define FIsEventIrul(irul)          FIsEventPrul(LprulFromIrul(irul))
// Return whether the node is an event node
#define FIsEventPrul(prul)          ((prul)->rultType & rultEvent)
// Return whether the node is a rule node
#define FIsRulePrul(prul)           (!FIsEventPrul(prul))
#define IMMEDIATE_RULES
#ifdef IMMEDIATE_RULES
// Return whether rule node is a sequence rule (...)
#define FImmediateRulePrul(prul)    ((prul)->rultType & rultImmediateRule)
#endif /* IMMEDIATE_RULES */
// Return whether the node is an *undefined* event
#define FSpecialKwdIrul(irul) 
            FSpecialKwdLprul(LprulFromIrul(irul))
// Return whether the node is an *undefined* event
#define SetFSpecialKwdIrul(irul) 
            SetFSpecialKwdLprul(LprulFromIrul(irul))
// Return whether the node is an *undefined* event
#define FSpecialKwdLprul(prul)      ((prul)->rultType & rultSpecialKwd)
// Return whether the node is an *undefined* event
#define SetFSpecialKwdLprul(prul)  
            ((prul)->rultType |= rultSpecialKwd)
// Return whether rule node can persist in delayed queue in soft resets
#define FPersistentLprul(prul) 
            ((prul)->rultType & rultPersistentRule)
// Mark that rule node can persist in delayed queue in soft resets
#define SetFPersistentIrul(irul) 
            SetFPersistentLprul(LprulFromIrul(irul))
// Mark that rule node can persist in delayed queue in soft resets
#define SetFPersistentLprul(prul) 
            ((prul)->rultType |= rultPersistentRule)
// Return whether rule node can persist in delayed queue in all resets
#define FAlwaysPersistLprul(prul) 
            ((prul)->rultType & rultAlwaysPersist)
// Mark that rule node can persist in delayed queue in all resets
#define SetFAlwaysPersistIrul(irul) 
            SetFAlwaysPersistLprul(LprulFromIrul(irul))
// Mark that rule node can persist in delayed queue in all resets
#define SetFAlwaysPersistLprul(prul) 
            ((prul)->rultType |= rultAlwaysPersist)
// Return whether rule node can persist in delayed queue
#define FPersistLprulGrf(prul, grf) 
            ((prul)->rultType & (grf))
// Return the value for the current rule
#define RulvSelf() 
            RulvOfIrul(irulSelf)
// Set the value for the current rule
#define SetRulvSelf(rulv) 
            SetRulvOfIrul(irulSelf, (rulv))
// Increment the value for the current rule
#define IncrRulvSelf(drulv) 
            IncrRulvOfIrul(irulSelf, (drulv))
// Return the value1 for the current rule
#define Rulv1Self() 
            Rulv1OfIrul(irulSelf)
// Set the value1 for the current rule
#define SetRulv1Self(rulv) 
            SetRulv1OfIrul(irulSelf, (rulv))
// Increment the value1 for the current rule
#define IncrRulv1Self(drulv) 
            IncrRulv1OfIrul(irulSelf, (drulv))
// Return the value2 for the current rule
#define Rulv2Self() 
            Rulv2OfIrul(irulSelf)
// Set the value2 for the current rule
#define SetRulv2Self(rulv) 
            SetRulv2OfIrul(irulSelf, (rulv))
// Increment the value2 for the current rule
#define IncrRulv2Self(drulv) 
            IncrRulv2OfIrul(irulSelf, (drulv))
// Return the value for the rule ID
#define RulvOfIrul(irul) 
            (LprulFromIrul(irul)->svl.lValue)
// Set the value for the rule ID
#define SetRulvOfIrul(irul, rulv) 
            (LprulFromIrul(irul)->svl.lValue = (rulv))
// Increment the value1 field for the rule ID
#define IncrRulvOfIrul(irul, drulv) 
            IncrRulvOfLprul(LprulFromIrul(irul), (drulv))
// Return the lValue field for a rule node
#define RulvOfLprul(prul)               ((prul)->svl.lValue)
// Set the lValue field for a rule node
#define SetRulvOfLprul(prul, w)         ((prul)->svl.lValue = (w))
// Increment the value1 field for a rule node
#define IncrRulvOfLprul(prul, drulv)    ((prul)->svl.lValue += (drulv))
// Set the value for the rule ID
#define PlValueOfIrul(irul) 
            (&LprulFromIrul(irul)->svl.lValue)
// Return the value1 field for the rule ID
#define Rulv1OfIrul(irul) 
            Rulv1OfLprul(LprulFromIrul(irul))
// Set the value1 field for the rule ID
#define SetRulv1OfIrul(irul, rulv) 
            SetRulv1OfLprul(LprulFromIrul(irul), (rulv))
// Increment the value1 field for the rule ID
#define IncrRulv1OfIrul(irul, drulv) 
            IncrRulv1OfLprul(LprulFromIrul(irul), (drulv))
// Return the value2 field for the rule ID
#define Rulv2OfIrul(irul) 
            Rulv2OfLprul(LprulFromIrul(irul))
// Set the value2 field for the rule ID
#define SetRulv2OfIrul(irul, rulv) 
            SetRulv2OfLprul(LprulFromIrul(irul), (rulv))
// Increment the value2 field for the rule ID
#define IncrRulv2OfIrul(irul, drulv) 
            IncrRulv2OfLprul(LprulFromIrul(irul), (drulv))
// Return the value1 field for a rule node
#define Rulv1OfLprul(prul)              W1OfPsv(PsvOfLprul(prul))
// Set the value1 field for a rule node
#define SetRulv1OfLprul(prul, w)        SetW1OfPsv(PsvOfLprul(prul), (w))
// Increment the value1 field for a rule node
#define IncrRulv1OfLprul(prul, dw)      IncrW1OfPsv(PsvOfLprul(prul), (dw))
// Return the value2 field for a rule node
#define Rulv2OfLprul(prul)              W2OfPsv(PsvOfLprul(prul))
// Set the value2 field for a rule node
#define SetRulv2OfLprul(prul, w)        SetW2OfPsv(PsvOfLprul(prul), (w))
// Increment the value2 field for a rule node
#define IncrRulv2OfLprul(prul, dw)      IncrW2OfPsv(PsvOfLprul(prul), (dw))
// Return the Split Value pointer of a node
#define PsvOfLprul(prul)                (&(prul)->svl.sv)
// Return the value1 field for an rule node
#define Rulv1(rulv)                     W1OfPsv((SV *) &(rulv))
// Set the value1 field for a node
#define SetRulv1(rulv, w)               SetW1OfPsv(((SV *) &(rulv)), (w))
// Return the value2 field
#define Rulv2(rulv)                     W2OfPsv((SV *) &(rulv))
// Set the value2 field for a node
#define SetRulv2(rulv, w)               SetW2OfPsv(((SV *) &(rulv)), (w))
// Return the confidence value of a node node
#define WConfidence(prul)               Rulv1OfLprul(prul)
// Set the confidence value of a node node
#define SetConfidence(prul, wValue)     SetRulv1OfLprul((prul), (wValue))
// Return the doubt value of a node node
#define WDoubt(prul)                    Rulv2OfLprul(prul)
// Set the doubt value of a node node
#define SetDoubt(prul, wValue)          SetRulv2OfLprul((prul), (wValue))
// OBSOLETE FORMS OF MACROS
#define WValueOfIrul(irul)              RulvOfIrul(irul)
#define SetWValueOfIrul(irul, rulv)     SetRulvOfIrul(irul, rulv)
#define WRulValue1(prul)                Rulv1OfLprul(prul)
#define SetWRulValue1(prul, w)          SetRulv1OfLprul((prul), (w))
#define WRulValue2(prul)                Rulv2OfLprul(prul)
#define SetWRulValue2(prul, w)          SetRulv2OfLprul((prul), (w))
// Return the rule node for the rule value
#define LprulOfWValue(lplValue) 
            ((MSORUL *) 
                (((char *) lplValue) - CchStructOffset(MSORUL, svl.lValue)))
#ifdef DEBUG
// Return the value name or rule text of the rule node structure pointer
#define LpchRulName(prul)   ((prul)->lpchName)
// Return the value name or rule text of the rule node structure pointer
#define LpchIrulName(irul)  LpchRulName(LprulFromIrul(irul))
// Return debug rule name for dynamic rule
#define PszNameDynLprul(prul) 
            (vlpruls->rgpchDynNames[(prul)->irul - IrulCompiledMax()])
#endif /* DEBUG */
// Return the node evaluation level for the node
#define RulevlOfPrul(prul) 
            (prul->rulevl)
// Return the event_type for the node
#define RulevtOfLprul(prul) 
            RulevtOfRulevl(RulevlOfPrul(prul))
// Return the event_type for the evaluation level
#define RulevtOfRulevl(rulevl) 
            (vlpruls->rgrulevtFromRulevl[rulevl])
// Return the rule queue of the rule level
#define LplprulQueueOf(rulevl)  (&vlpruls->rgprulActiveQueues[rulevl])
// Return the delayed-evaluation rule queue of the event_type
#define LplprulDelayedQueueOf(rulevt) 
            (&vlpruls->rgprulDelayedQueues[rulevt])
// Return the minimum evaluation level of the event_type
#define RulevlMinOfRulevt(rulevt) 
            (vlpruls->rgrulevlRulevt[(rulevt)])
// Return the maximum evaluation level of the event_type
#define RulevlMaxOfRulevt(rulevt) 
            (vlpruls->rgrulevlRulevt[(rulevt) + 1])
// Return the list of dependent node references of node ID
#define LpruldepFromIrul(irul) 
            (vlpruls->rgpruldepDependents[irul])
// Return the list of dependent node references of node
#define LpruldepGetDependents(prul) 
            LpruldepFromIrul(IrulFromLprul(prul))
// Set the list of dependent node references of node ID
#define SetLpruldepFromIrul(irul, pruldep) 
            (vlpruls->rgpruldepDependents[irul] = (pruldep))
// Set the list of dependent node references of node
#define LpruldepSetDependents(prul, pruldep) 
            SetLpruldepFromIrul(IrulFromLprul(prul), (pruldep))
// Return the list of dependent node references of node ID for specific group
#define LpruldepFromRulgIrul(rulg, irul) 
            (*LplpruldepForRulgIrul(rulg, irul))
// Set the list of dependent node references of node ID for specific group
#define SetLpruldepFromRulgIrul(rulg, irul, pruldep) 
            (*LplpruldepForRulgIrul(rulg, irul) = (pruldep))
// Return the address of the start of a ruldep list for the irul and group
#define LplpruldepForRulgIrul(rulg, irul) 
            (&(vlpruls->rgrgpruldepDependents[rulg][irul]))
// Return whether a dependent reference is in fact a delay specfication
#define FIsDelayFactor(lprulDepend) 
            ((unsigned long) (lprulDepend) < wDelayMax)
// Return the delay value associated with the dependency record
#define CDelayFromLpruldepend(lprulDepend) 
            ((int) ((unsigned long) lprulDepend))
// Return a dependency record to represent the delay factor
#define LpruldependFromCDelay(cDelay) 
            ((MSORUL *) (cDelay))
// Add a delay to the delay field of a delayed rule
#define AddCDelayToLprul(prul, cDelay) 
            ((prul)->wDelayMask |= (cDelay))
// Return whether a rule has any delay factor
#define FHaveCDelay(prul) 
            ((prul)->wDelayMask)
// Return whether a rule has a specific delay factor
#define FHaveCDelayOf(prul, cDelay) 
            ((prul)->wDelayMask & (cDelay))
// Decrement the node's delay counts (by shifting right)
#define DecrementCDelaysOfLprul(prul) 
            ((prul)->wDelayMask >>= 1)
// Return whether the (event) node is marked for history recording
#define FHistoryRecordLprul(prul) 
            (TRUE)                                      // First version
//          ((prul)->fRecordHistory)                    // Correct version
// Return whether node must check interval counts to detect seq discontinuities
#define FIntervalsSeqCheckedPrul(prul) 
            ((prul)->ipfnrulscSeqCheck)
// Return interval counts associated with node that has sequence checking
#define WIntervalsSeqCheckedPrul(prul) 
            ((*vlpruls->rgpfnrulscSeqCheck[(prul)->ipfnrulscSeqCheck])())
// Return whether the rule base is initialized
#define FRulesInited(lpruls)    (lpruls != NULL  &&  lpruls->fInited)
// Return the op-code instructions for an interpreted rule ID
#define PociiForIrul(irul) 
            PociiForPrul(LprulFromIrul(irul))
// Return the op-code instructions for an interpreted rule
#define PociiForPrul(prul) 
            ((MSOOCII *) vlpruls->rgpociiRules[((prul)->ipociiInstrs)])
// Return any group(s) that append(s) the current group
#define RulgAppendedFrom(rulg) 
            (vlpruls->prulgAppendedFrom[rulg])
// Return the list of groups that append from other groups
#define PrulgAppendedFrom() 
            (vlpruls->prulgAppendedFrom)
// Return the group (if any) that the current group appends to
#define RulgAppendTo(rulg) 
            (vlpruls->prulgAppendTo[rulg])
// Return the list of groups that append to other groups
#define PrulgAppendTo() 
            (vlpruls->prulgAppendTo)
#define rulgNil         (-1)                            // "No" rule group
#define rulevtNil       (-1)                            // "No" event type
#ifdef DEBUG
// Return whether node is marked for automatic backtracing */
#define FTraceLprul(prul) 
            ((prul)->irulNextTrace != 0)
#endif /* DEBUG */
// Return the list of nodes that current node depends upon
#define LpirulGetDependsOn(prul) 
            (&vlpruls->lpgrpirulDependBack[(prul)->birulDependsOn])
/*************************************************************************
    Prototypes and macros for rule.c
 *************************************************************************/
#ifndef max
#define max(a,b)    ((a) > (b) ? (a) : (b))
#endif /* !max */
#ifndef min
#define min(a,b)    ((a) < (b) ? (a) : (b))
#endif /* !max */
// Push the node onto the queue
#define PushLprul(prul, lplprulQ)  
            ((prul)->prulNext = *(lplprulQ), 
             *(lplprulQ) = (prul))
// Pop the node from the queue into the variable
#define PopLprul(lplprul, lplprulQ)  
            (*lplprul = *lplprulQ, 
             *lplprulQ = (*lplprul)->prulNext, 
             (*lplprul)->prulNext = 0)
// Push event node into Auto-Clear (Changed) list
#define PushLpRulChanged(prul) 
            if ((prul)->irulNextChanged == 0) 
                { 
                int     rulevt = RulevtOfLprul(prul); 
                
                (prul)->irulNextChanged 
                    = vlpruls->rgirulRulevtChanged[rulevt]; 
                vlpruls->rgirulRulevtChanged[rulevt] = IrulFromLprul(prul); 
                }
// Mark event as never Auto-Clearing
#define SetNoAutoClearRulv(rulv) 
            (LprulFromRulv(rulv)->irulNextChanged = irulNoAutoClear)
#define SetNoAutoClearLprul(prul) 
            ((prul)->irulNextChanged = irulNoAutoClear)
#define irulChangedNil      -1
#define irulNoAutoClear     -2
// Return the offset of a field from the start of its typedef'd structure
// NOTE: THIS IS TRICKY CODE, BUT COMPLETELY LEGAL C!!
//       To understand it, remember that 0 is a valid pointer for ALL types!
#define CchStructOffset(type, field) 
            (((char *) (&((type *) 0)->field)) - ((char *) 0))
// Call Rule Evaluation function provided by Application
#define FEvalRule(irul) 
            (*vlpruls->lpfnEvalRule)(irul)
#ifndef STATIC_LINK_EM
MSOAPI_(RULS **) MsoPvlprulsMirror(RULS **pvlprulsApp); // Exchange &vlpruls
#else /* STATIC_LINK_EM */
#define MsoPvlprulsMirror(pvlprulsApp)  pvlprulsApp
#endif /* !STATIC_LINK_EM */
MSOAPI_(int) MsoFInitRules(                             // Init rule base
    LPFNRulinit         lpfnRulInit,
    RULS               *lpruls
    );
IRUL IrulDefineEvent(int rulevt, char *szName);         // Define simple event
MSOAPI_(MSOKWD *) MsoFDefineStringKwdEvent(             // Define str kwd event
    int                 rulevt,
    char               *szName,
    XCHAR              *pxch,
    int                 cch,
    int                 ikwtb
    );
MSOAPI_(MSOKWDLH *) MsoFDefineIntegerKwdEvent(          // Define int kwd event
    int                 rulevt,
    char               *szName,
    long                lValue,
    int                 ikwtb
    );
MSOAPI_(void) MsoClearRules(void);                      // Clear nodes & state
MSOAPI_(void) MsoClearEventsForRulevts(                 // Clr rg of ev types
    int                 rulevtFirst,
    int                 drulevtCount,
    int                 fSavePersistentDelayed,
    int                 fClearChanged,
    int                 fClearIntervalCounts
    );
MSOAPI_(void) MsoRestorePersistentDelayedRules(void);   // Restore delayed Q
MSOAPI_(int) MsoFAddPruldepDependent(                   // Add dependent link
    IRUL                irul,
    MSORUL             *prulDependent,
    int                 cDelay,
    int                 rulg
    );
MSOAPI_(void) MsoFixUpPruldeps(                         // Fix up after insert
    IRUL                irul,
    int                 rulg,
    int                 rulgBase,
    RULDEP             *lpruldepOldList,
    RULDEP             *lpruldepNewList
    );
MSOAPI_(int) MsoFDelPruldepDependent(                   // Del dependent link
    IRUL                irul,
    MSORUL             *prulDependent,
    int                 rulg,
    int                 fDiscard
    );
MSOAPI_(void) MsoSetActiveRuls(RULS *pruls);            // Set curr vlpruls
MSOAPI_(void) MsoFreeRuleMem(RULS *pruls);              // Free rule memory
#ifdef OFFICE_BUILD
MSOAPI_(void) MsoMarkRuleMem(RULS *pruls);              // Mark rule mem used
#endif /* OFFICE_BUILD */
MSOAPI_(void) MsoSetEventTypeRulevt(int rulevt);        // Change event_types
MSOAPI_(void) MsoClearChangedEventsForRulevt(int rulevt);// Clr event_type vals
void RemoveLprulChanged(MSORUL *prul);                  // Un-auto-clear event
MSOAPI_(int) MsoEvaluateEvents(int rulevt);             // Event evaluation
MSOAPI_(int) MsoFEvalIrul(IRUL irul);                   // Eval single node
MSOAPI_(void) MsoDelaySignalIrul(                       // Signal node w/delay
    IRUL                irul,
    long                lValue,
    int                 cDelay
    );
MSOAPI_(void) MsoDelaySignalIrulFrom(                   // Signal node w/delay
    IRUL                irul,
    IRUL                irulFrom,
    int                 cDelay
    );
MSOAPI_(void) MsoSignalIrul(IRUL irul, long lValue);    // Cond schedule irul
#define PushIrulToEval(irul, lValue) 
            MsoSignalIrul(irul, lValue)
MSOAPI_(void) MsoScheduleIrul(IRUL irul, long lValue);  // Schedule rule to run
#ifdef DEBUG
MSOAPI_(void) MsoScheduleIrulDebug(IRUL irul, long lValue);// Log and schedule
MSOAPI_(void) MsoScheduleIrulDebugMso(IRUL irul, long lValue);//Log &sched MSO
#else
#define MsoScheduleIrulDebug    MsoScheduleIrul
#define MsoScheduleIrulDebugMso MsoScheduleIrul
#endif /* DEBUG */
MSOAPI_(void) MsoDelayScheduleIrul(                     // Schedule after delay
    IRUL                irul,
    long                lValue,
    int                 cDelay
    );
#ifdef DEBUG
MSOAPI_(void) MsoDelayScheduleIrulDebug(                // Log and schedule
    IRUL                irul,
    long                lValue,
    int                 cDelay
    );
#else
#define MsoDelayScheduleIrulDebug   MsoDelayScheduleIrul
#endif /* DEBUG */
MSOAPI_(void) MsoDelayScheduleIrulFrom(                 // Sched, pass value
    IRUL                irul,
    IRUL                irulFrom,
    int                 cDelay
    );
MSOAPI_(int) MsoFEvalIrulImmediately(                   // Eval irul now
    IRUL                irul,
    long                lValue
    );
MSOAPI_(void) MsoPushLprulDependents(MSORUL *prul);     // Push dependents
MSOAPI_(void) MsoPushDelayedEvalForRulevt(int rulevt);  // Push delayed nodes
MSOAPI_(void) MsoAutoClearIrul(IRUL irul);              // Mark node for clear
MSOAPI_(int) MsoFAliasPrulPrul(                         // Ret if 2 are aliases
    MSORUL             *prul,
    MSORUL             *prulTarget
    );
void RecordLprulHistory(MSORUL *prul);                  // Push ev into hist
#ifdef NEVER
MSOAPI_(int) MsoFIrulHistoryValueWas(                   // Look 4 event in hist
    int                 dirultkBackwards,
    long               *lpwVar
    );
#endif // NEVER
#ifdef NEED_AS_FUNCTION
void SetCurrRulg(int rulgGroup);                        // Set rule group
#endif /* NEED_AS_FUNCTION */
MSOAPI_(void) MsoSignalEventIrul(IRUL irul, long lValue);// Signal an event
MSOAPI_(void) MsoSignalEventIrulFrom(                   // Signal ev from node
    IRUL                irul,
    IRUL                irulFrom
    );
#ifdef NEVER
MSOAPI_(void) MsoSetRuleConfid(IRUL irul, int wFactor); // Set confidence val
#endif // NEVER
// Schedule a node for deferred evaluation, based upon a decision rule
//  This macro gets invoked twice.  See _MsoFDeferIrul() for details.
#define FDeferIrul(irul) 
            (vlpruls->fEvaluatingDeferred ||  _MsoFDeferIrul(irul))
#define FDeferIrulExpr(irul, lExpr) 
            (vlpruls->fEvaluatingDeferred 
                ||  (((int) lExpr)  &&  _MsoFDeferIrul(irul)))
#define FDeferIrulExprL(irul, lExpr, lValue) 
            (vlpruls->fEvaluatingDeferred 
                ||  (((int) lExpr)  &&  _MsoFDeferIrulL((irul), (lValue))))
#define IrulPickDeferred(irulDecision) 
            MsoIrulPickDeferred(irulDecision)
MSOAPI_(int) _MsoFDeferIrul(IRUL irul);                 // Add to defer list
MSOAPI_(int) _MsoFDeferIrulL(IRUL irul, long lValue);   // Add to defer w/value
MSOAPI_(IRUL) MsoIrulPickDeferred(IRUL irulDecision);   // Pick from defer list
MSOAPI_(void) MsoSetRulNotify(                          // Set up notification
    long                lExprValue,                     // Really an int
    IRUL                irulDecision,
    IRUL                irulNotify
    );
MSOAPI_(int) MsoFRulNotify(long wNotify);               // Notify on next eval
MSOAPI_(int) MsoFRulNotifyImmediately(long wNotify);    // Notify immediately
MSOAPI_(long) MsoRulvElement(IRUL irulArray, IRUL iirul);// Get value of array
MSOAPI_(void) MsoSetElementRulv(                        // Set value of array
    IRUL                irulArray,
    IRUL                iirul,
    long                lValue
    );
MSOAPI_(void) MsoSetAllElementsToRulv(                  // Set all vals of arr
    IRUL                irulArray,
    IRUL                cirul,
    long                lValue
    );
/* M S O  F  A C T I V A T E  I R U L */
/*----------------------------------------------------------------------------
    %%Function: MsoFActivateIrul
    %%Contact: daleg
    Activate a node in the rulebase
----------------------------------------------------------------------------*/
_inline int MsoFActivateIrul(IRUL irul)                 // Activate a node
{
    MSOPRUL             prul = LprulFromIrul(irul);
    if (prul->prulNext == msoprulInactive)
        {
        prul->prulNext = (MSOPRUL) NULL;
        return TRUE;
        }
    else
        return FALSE;
}
/* M S O  F  D E A C T I V A T E  I R U L */
/*----------------------------------------------------------------------------
    %%Function: MsoFDeactivateIrul
    %%Contact: daleg
    Deactivate a node in the rulebase
----------------------------------------------------------------------------*/
MSOAPI_(int) _MsoFDeactivateIrul(IRUL irul);            // Deactivate a node
_inline int MsoFDeactivateIrul(IRUL irul)
{
    MSOPRUL             prul = LprulFromIrul(irul);
    if (prul->prulNext == NULL)
        {
        prul->prulNext = msoprulInactive;
        return TRUE;
        }
    else
        return _MsoFDeactivateIrul(irul);
}
MSOAPI_(int) MsoFDeleteIrul(IRUL irul, int rulg);       // Delete a node
/*************************************************************************
    Prototypes and macros for rultest.c and rulconcl.c.
    These prototypes "Hungarianize" the rule code so that the rule
    authors do not have to know Hungarian, but it is preserved within
    the application code.
 *************************************************************************/
// Return the current interval number for the event_type
#define CIntervalsRulevt(rulevt) 
            (vlpruls->rgdtkiRulevt[rulevt])
// OBSOLETE: Return the current interval number for the event_type
#define CIntervalsRsct(rulevt)              CIntervalsRulevt(rulevt)
// Increment the current interval number for the event_type
#define IncrIntervalsRsct(rulevt, dc) 
            (vlpruls->rgdtkiRulevt[rulevt] += (dc))
#ifdef NEVER
// Set long value of a node and force propagation
#define SetValue(wVar, lValue) 
            SignalEvent(wVar, lValue)
#endif /* NEVER */
// Convert a "variable" event reference to an node address
#define LprulFromRulv(rulvVar) 
            LprulOfWValue(&(rulvVar))
// Notify a node, on its next evaluation pass
#define FNotify(rgwVar) 
            MsoFRulNotify(rgwVar)
// Notify an action rule, immediately
#define FNotifyImmediately(rgwVar) 
            MsoFRulNotifyImmediately(rgwVar)
// Indicate the next event_type to enter when current event_type is exited
#define SetNextEventType(rulevt) 
            if (vlpruls->prulevtEvalLim 
                    < vlpruls->rgrulevtEval + RulevtMax()) 
                (*vlpruls->prulevtEvalLim++ = (rulevt)); 
            else 
                AssertSz0(FALSE, "Exceeded max number of rulevts to eval");
// Force delayed evaluation of rule of given ID: GENERATED BY RULE COMPILER
#define DelayEvalIrul(irul, cDelay) 
            MsoDelayScheduleIrulFrom((irul), (irul), (cDelay))
// Return whether the dirultkBackwards'th previous value was the given event
#define ValueWas(dirultkBackwards, wVar) 
            MsoFIrulHistoryValueWas(dirultkBackwards, &(wVar))
// Find the given value in its event_type history, and return the (neg) offset
#define FindPrevValueFrom(dirultkBackwards, wVar) 
            DirultkFindPrevValueFrom(dirultkBackwards, &(wVar))
// Mark event/rule for automatic clearing on event_type exit
#define AutoClear(irul) 
            MsoAutoClearIrul(irul)
// Mark expression as exempt from dependency linkage in rule if
#define Value(expr) (expr)
// Push all dependents of node of ID onto their evaluation queues
#define Propagate(irul) 
            MsoPushLprulDependents(LprulFromIrul((int) irul))
// Evaluate the rule at normal time
#define GoToRule(irul) 
            MsoDelayScheduleIrul((irul), TRUE, 0 /* cDelay */)
// Evaluate the rule at normal time
#define GoToIrul(irul) 
            MsoDelayScheduleIrulFrom((IRUL) (irul), (irulSelf), 0 /* cDelay */)
// Evaluate the rule after delay of 1, incrementing value
#define GoToIrulNoValue(irul) 
            MsoDelayScheduleIrulFrom 
                ((IRUL) (irul), (IRUL) (irul), 1 /* cDelay */)
// Evaluate the rule at normal time
#define GoToDirul(dirul) 
            MsoDelayScheduleIrulFrom 
                ((IRUL) (irulSelf) + (dirul), (irulSelf), 0 /* cDelay */)
// Evaluate the rule after delay of 1
#define DelayGoToRule(irul) 
            DelayGoToIrulNoValue(irul)
// Signal the event with the given value
#define SignalIrul(irul, lValue) 
            MsoSignalIrul(irul, lValue)
// Signal the event with the given value
#define SignalEvent(wVar, lValue) 
            MsoSignalEventIrul(IrulFromLprul(LprulFromRulv(wVar)), (lValue))
// Signal the event with the given value
#define SignalEventIrul(irul, lValue) 
            MsoSignalEventIrul(irul, lValue)
// Signal the node with the value from the current rule
// REVIEW: THIS IS WRONG, NOT CONDITIONALLY SCHEDULING IF EVENT
#define SignalIrulSelf(irul) 
            MsoDelayScheduleIrulFrom((IRUL) (irul), (irulSelf), 0)
// Signal the event with the value from the current rule
#define SignalEventIrulSelf(irul) 
            MsoSignalEventIrulFrom((IRUL) (irul), (irulSelf))
// Evaluate the event after delay of 1
#define DelaySignalEventIrul(irul, lValue) 
            MsoDelayScheduleIrul((irul), (lValue), 1 /* cDelay */)
// Evaluate the event after specified delay
#define DelaySignalEventIrulAfter(irul, lValue, cDelay) 
            MsoDelayScheduleIrul((irul), (lValue), 1 << ((cDelay) - 1))
// Evaluate the node after delay of 1, getting value from rule
#define DelaySignalIrulSelf(irul) 
            MsoDelayScheduleIrulFrom((irul), (irulSelf), 1 /* cDelay */)
// Evaluate the event after delay of 1, getting value from rule
#define DelaySignalEventIrulSelf(irul) 
            MsoDelayScheduleIrulFrom((irul), (irulSelf), 1 /* cDelay */)
// Evaluate the event after delay of 1
// REVIEW daleg: OBSOLETE: USE DelaySignalEventIrul or "then ... (<event>)"
#define DelaySignalIrul(irul) 
            MsoDelayScheduleIrul((irul), TRUE, 1 /* cDelay */)
// Evaluate the event after delay of 1
#define DelaySignal(rulvVar) 
            DelaySignalRulv((rulvVar), TRUE)
// Evaluate the event after delay of 1
#define DelaySignalRulv(rulvVar, lValue) 
            CDelaySignalRulv((rulvVar), (lValue), 1 /* cDelay */)
// Evaluate the event after delay of 1
#define CDelaySignalRulv(rulvVar, lValue, cDelay) 
            MsoDelayScheduleIrul(LprulFromRulv(rulvVar)->irul, (lValue), 
                                 (cDelay))
// Evaluate the rule after delay of 1 passing TRUE as the value
#define DelayGoToIrul1(irul) 
            MsoDelayScheduleIrul((irul), TRUE, 1 /* cDelay */)
// Evaluate the rule after specified delay
#define DelayGoToIrulAfter(irul, cDelay) 
            MsoDelayScheduleIrul((irul), TRUE, 1 << ((cDelay) - 1))
// Evaluate the rule with value after specified delay
#define DelayGoToIrulWithRulvAfter(irul, lValue, cDelay) 
            MsoDelayScheduleIrul((irul), (lValue) - (cDelay) + 1, 
                                 1 << ((cDelay) - 1))
// Evaluate the rule after specified delay
#define DelayGoToDirulAfter(dirul, cDelay) 
            MsoDelayScheduleIrulFrom((IRUL) (irulSelf + (dirul)), (irulSelf), 
                                     1 << ((cDelay) - 1))
// Evaluate the rule after delay of 1, incrementing value
#define DelayGoToIrulNoValue(irul) 
            MsoDelayScheduleIrulFrom 
                ((IRUL) (irul), (IRUL) (irul), 1 /* cDelay */)
// Evaluate the rule after delay of 1, passing the value of the current node
#define DelayGoToIrul(irul) 
            MsoDelayScheduleIrulFrom((IRUL) (irul), (irulSelf), 1 /* cDelay */)
// Evaluate the rule (via relative offset) after delay of 1
#define DelayGoToDirul(dirul) 
            MsoDelayScheduleIrulFrom 
                ((IRUL) (irulSelf + (dirul)), (irulSelf), 1)
// Evaluate the rule (via relative offset) after delay of 1
#define DelayGoToDirulNoValue(dirul) 
            MsoDelayScheduleIrulFrom((IRUL) (irulSelf + (dirul)), 
                                     (IRUL) (irulSelf + (dirul)), 1)
// Evaluate the rule (via relative offset) after delay of 1, with value rulv
#define DelayGoToDirulWithRulv(dirul, rulv) 
            (SetRulvOfIrul(irulSelf + (dirul), (rulv)), 
             DelayGoToDirulNoValue(dirul))
// Evaluate the rule (via relative offset) after delay of 1, with value rulv2
#define DelayGoToDirulWithRulv2(dirul, rulv2) 
            (SetRulv2OfIrul(irulSelf + (dirul), (short) (rulv2)), 
             DelayGoToDirulNoValue(dirul))
// Evaluate the rule (via relative offset) after delay of 1, with value rulv2
#define DelayGoToDirulWithRulv1(dirul, rulv1) 
            (SetRulv1OfIrul(irulSelf + (dirul), (short) (rulv1)), 
             DelayGoToDirulNoValue(dirul))
// Evaluate the rule (via relative offset) after delay of 1, with values
#define DelayGoToDirulWithRulvs(dirul, rulv1, rulv2) 
            (SetRulv1OfIrul(irulSelf + (dirul), (short) (rulv1)), 
             SetRulv2OfIrul(irulSelf + (dirul), (short) (rulv2)), 
             DelayGoToDirulNoValue(dirul))
// Deactivate curr rule if the fTest value is FALSE: used in rule test clause
#define FAutoDeactivateSelf(fTest) 
            FAutoDeactivateIrul(irulSelf, (fTest))
// Deactivate the rule if the fTest value is FALSE: used in rule test clause
#define FAutoDeactivateIrul(irul, fTest) 
            ((fTest) ? FALSE : (_MsoFDeactivateIrul(irul), TRUE))
// Set the Rule Propagation Group to the given value
#define SetCurrRulg(rulgGroup) 
            (vlpruls->rgpruldepDependents 
                = vlpruls->rgrgpruldepDependents[vlpruls->rulgCurr 
                                                        = rulgGroup])
// Return the current main Rule Propagation Group
#define FCurrRulg(rulg) 
            (vlpruls->rulgCurr == (rulg))
/*************************************************************************
    Prototypes and macros for Debugging and Error Handling
 *************************************************************************/
#ifdef DEBUG
MSOAPI_(int) MsoFTraceIrul(IRUL irul, int fTraceOn);    // Trace a node
char *SzFromFixed3(long lValue, char *pchBuf);          // Fixed to sz conv
#define DebugDumpQueues(wTraceLvl, sz, lValue, wToLevel) 
            { 
            static const unsigned char      _szDump[] = sz; 
            
            _DumpQueues(wTraceLvl, _szDump, lValue, wToLevel); 
            }
#define DebugDumpQueue(wTraceLvl, rulevl) 
            _DumpQueue(wTraceLvl, rulevl, LplprulQueueOf(rulevl))
#else /* !DEBUG */
#define DebugDumpQueues(wTraceLvl, sz, lValue, wToLevel)
#define DebugDumpQueue(wTraceLvl, rulevl)
#endif /* DEBUG */
MSOEXTERN_C_END     // ****************** End extern "C" *********************
#define EMRULE_H
#if !(defined(OFFICE_BUILD)  ||  defined(XL))
#ifdef DYN_RULES
int FLoadDynEmRules(void);                              // Load dyn rulebase
#include "emruloci.h"
#endif /* DYN_RULES */
#endif /* !OFFICE_BUILD */
#endif /* !EMRULE_H */

						