Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f7ca35dddd
WindowsXP-SP1/shell/evtmon/inc/emrule.h

1423 lines
54 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*****************************************************************************
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 */
Reference in New Issue Copy Permalink