开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
asmrulep.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：35k
源码类别：

Symbian

开发平台：

C/C++

asmrulep.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. // #include "hlxclib/stdio.h"      /* printf */
  37. #include "hxtypes.h"    /* Basic Types */
  38. #include "hlxclib/stdlib.h"
  39. #include "hxstrutl.h"
  40. #include "hxcom.h"      /* IUnknown */
  41. #include "ihxpckts.h"
  42. #include "asmrulep.h" /* ASM Public Include File */
  43. #include "asmrulpp.h" /* ASM Private Include File */
  44. #include "chxpckts.h"
  46. #define RULE_VAL_INFINITY -1
  48. #include "hxheap.h"
  49. /*
  50. #ifdef _DEBUG
  51. #undef HX_THIS_FILE
  52. static const char HX_THIS_FILE[] = __FILE__;
  53. #endif
  54. */
  55. static const char* const zpOpName[] =
  56. {
  57.     ">",
  58.     "<",
  59.     ">=",
  60.     "<=",
  61.     "==",
  62.     "!=",
  63.     "AND",
  64.     "OR"
  65. };
  68. ASMRuleExpression::ASMRuleExpression(const char* pExpression)
  69. {
  70.     int temp;
  72.     char* pTemp = new char[temp = (strlen(pExpression) + 1)];
  73.     memcpy(pTemp, pExpression, temp); /* Flawfinder: ignore */
  75.     m_ulNumThresholds = 1; // always have one zero rule
  76.     m_pHead = Parse(pTemp, m_ulNumThresholds);
  78.     delete[] pTemp;
  79. }
  82. ASMRuleExpression::~ASMRuleExpression()
  83. {
  84.     RDelete(m_pHead);
  85. }
  88. /* Note:  This parse is destructive to pExpression */
  89. Node*
  90. ASMRuleExpression::Parse(char* pExpression, UINT32& ulNumThreshold)
  91. {
  92.     char* pTemp = pExpression;
  93.     int PLevel = 0;
  94.     BOOL bStripAgain = 1;
  95.     int OperSize;
  97.     //printf ("Parse Expression: %sn", pExpression);
  99.     // Strip outside unneccesary parens
  100.     while ((*pExpression == '(') && (bStripAgain))
  101.     {
  102. for (pTemp = pExpression, PLevel = 0; *pTemp; pTemp++)
  103. {
  104.     if (*pTemp == '(')
  105. PLevel++;
  107.     if (*pTemp == ')')
  108.     {
  109. PLevel--;
  110. if ((!(*(pTemp + 1))) && (!PLevel))
  111. {
  112.     pExpression++;
  113.     pExpression[strlen(pExpression) - 1] = 0;
  114.     bStripAgain = 1;
  115.     break;
  116. }
  117. if (!PLevel)
  118. {
  119.     bStripAgain = 0;
  120.     break;
  121. }
  122.     }
  123. }
  124.     }
  126.     for (pTemp = pExpression, PLevel = 0; *pTemp; pTemp++)
  127.     {
  128. if (*pTemp == '(')
  129.     PLevel++;
  130. if (*pTemp == ')')
  131.     PLevel--;
  133. if (!PLevel)
  134. {
  135.     OperSize = 1;
  136.     if (((*pTemp == '>') || (*pTemp == '<')) ||
  137.         ((*pTemp == '=') || (*pTemp == '!')) ||
  138.         ((*pTemp == '&') || (*pTemp == '|')))
  139.     {
  140. OperatorNode* pNode = new OperatorNode;
  142. pNode->m_Type = HX_RE_OPERATOR;
  143. switch (*pTemp)
  144. {
  145. case '>':
  146.     if ((*(pTemp + 1)) == '=')
  147.     {
  148. pNode->m_Data = HX_RE_GREATEREQUAL;
  149. OperSize = 2;
  150.     }
  151.     else
  152. pNode->m_Data = HX_RE_GREATER;
  153.     break;
  154. case '<':
  155.     if ((*(pTemp + 1)) == '=')
  156.     {
  157. pNode->m_Data = HX_RE_LESSEQUAL;
  158. OperSize = 2;
  159.     }
  160.     else
  161. pNode->m_Data = HX_RE_LESS;
  162.     break;
  163. case '=':
  164.     if ((*(pTemp + 1)) == '=')
  165.     {
  166. pNode->m_Data = HX_RE_EQUAL;
  167. OperSize = 2;
  168.     }
  169.     break;
  170. case '!':
  171.     if ((*(pTemp + 1)) == '=')
  172.     {
  173. pNode->m_Data = HX_RE_NOTEQUAL;
  174. OperSize = 2;
  175.     }
  176.     break;
  177. case '&':
  178.     if ((*(pTemp + 1)) == '&')
  179.     {
  180. pNode->m_Data = HX_RE_AND;
  181. OperSize = 2;
  182.     }
  183.     break;
  184. case '|':
  185.     if ((*(pTemp + 1)) == '|')
  186.     {
  187. pNode->m_Data = HX_RE_OR;
  188. OperSize = 2;
  189.     }
  190.     break;
  191. default:
  192.     break;
  193. };
  195. *pTemp = 0;
  196. pNode->m_pLeft  = Parse(pExpression, ulNumThreshold);
  197. pNode->m_pRight = Parse(pTemp + OperSize, ulNumThreshold);
  199. return pNode;
  200.     }
  201. }
  202.     }
  204.     for (pTemp = pExpression, PLevel = 0; *pTemp; pTemp++)
  205.     {
  206. if (*pTemp == '(')
  207.     PLevel++;
  208. if (*pTemp == ')')
  209.     PLevel--;
  211. if (!PLevel)
  212. {
  213.     if (*pTemp == '$')
  214.     {
  215. VariableNode* pNode = new VariableNode;
  217. pNode->m_Type = HX_RE_VARIABLE;
  218. pNode->m_Data = new char[strlen(pTemp)];
  219. memcpy(pNode->m_Data, pTemp + 1, strlen(pTemp)); /* Flawfinder: ignore */
  221. pNode->m_pLeft  = 0;
  222. pNode->m_pRight = 0;
  224. ulNumThreshold++; // each open variable means one more threshold.
  226. return pNode;
  227.     }
  228. }
  229.     }
  231.     for (pTemp = pExpression, PLevel = 0; *pTemp; pTemp++)
  232.     {
  233. if (*pTemp == '(')
  234.     PLevel++;
  235. if (*pTemp == ')')
  236.     PLevel--;
  238. if (!PLevel)
  239. {
  240.     if  ((*pTemp == '0') || (*pTemp == '1') || (*pTemp == '2') ||
  241.  (*pTemp == '3') || (*pTemp == '4') || (*pTemp == '5') ||
  242.  (*pTemp == '6') || (*pTemp == '7') || (*pTemp == '8') ||
  243.  (*pTemp == '9'))
  244.     {
  245. if (strchr(pTemp, '.'))
  246. {
  247.     FloatNode* pNode = new FloatNode;
  249.     pNode->m_Type = HX_RE_FLOAT;
  250.     pNode->m_Data = (float)atof(pTemp);
  252.     pNode->m_pLeft  = 0;
  253.     pNode->m_pRight = 0;
  255.     return pNode;
  256. }
  257. else
  258. {
  259.     IntegerNode* pNode = new IntegerNode;
  261.     pNode->m_Type = HX_RE_INTEGER;
  262.     pNode->m_Data = atoi(pTemp);
  264.     pNode->m_pLeft  = 0;
  265.     pNode->m_pRight = 0;
  267.     return pNode;
  268. }
  269.     }
  270. }
  271.     }
  273.     //printf ("Panic: Bad rulen");
  274.     return 0;
  275. }
  278. void
  279. ASMRuleExpression::Dump()
  280. {
  281.     //printf ("Dumping ASMRuleExpression:n");
  282.     RDump(m_pHead);
  283.     //printf ("n");
  284. }
  287. void
  288. ASMRuleExpression::RDump(Node* pNode)
  289. {
  290.     if (!pNode)
  291. return;
  293. #if 0
  294.     switch(pNode->m_Type)
  295.     {
  296.     case HX_RE_VARIABLE:
  297. printf ("   Variable: %sn", ((VariableNode *)pNode)->m_Data);
  298. break;
  299.     case HX_RE_INTEGER:
  300. printf ("   Integer: %dn", ((IntegerNode *)pNode)->m_Data);
  301. break;
  302.     case HX_RE_FLOAT:
  303. printf ("   Float: %fn", ((FloatNode *)pNode)->m_Data);
  304. break;
  305.     case HX_RE_OPERATOR:
  306. printf ("   Operator: %sn",
  307.     zpOpName[((OperatorNode *)pNode)->m_Data]);
  308. break;
  309.     }
  310. #endif
  312.     RDump(pNode->m_pLeft);
  313.     RDump(pNode->m_pRight);
  314. }
  317. void
  318. ASMRuleExpression::RDelete(Node* pNode)
  319. {
  320.     if (!pNode)
  321. return;
  323.     if (pNode->m_Type == HX_RE_VARIABLE)
  324.     {
  325. HX_VECTOR_DELETE(((VariableNode *)pNode)->m_Data);
  326.     };
  328.     RDelete(pNode->m_pLeft);
  329.     RDelete(pNode->m_pRight);
  330.     delete pNode;
  331. }
  334. /*
  335.  * This is a recursive expression evaluator that will determine whether
  336.  * or not we are subscribed to a particular rule, given the current conditions
  337.  */ 
  338. float
  339. ASMRuleExpression::REvaluate(Node* pNode, IHXValues* pVars)
  340. {
  341.     if (!pNode)
  342.         return (float)0;
  344.     switch(pNode->m_Type)
  345.     {
  346.     case HX_RE_VARIABLE:
  347. {
  348.     IHXBuffer* pValue=NULL;
  349.             float nValue = (float)0;
  351.     pVars->GetPropertyCString(((VariableNode *)pNode)->m_Data, pValue);
  353.     if (pValue)
  354.     {
  355.                 nValue = (float)atof((const char *)pValue->GetBuffer());
  356. pValue->Release();
  357.     }
  359.     return nValue;
  360. }
  362.     case HX_RE_INTEGER:
  363.         return (float)((IntegerNode *)pNode)->m_Data;
  364. break;
  365.     case HX_RE_FLOAT:
  366. return ((FloatNode *)pNode)->m_Data;
  367. break;
  368.     case HX_RE_OPERATOR:
  369. {
  370.     float Left  = REvaluate(pNode->m_pLeft,  pVars); 
  371.     float Right = REvaluate(pNode->m_pRight, pVars); 
  373.     switch (((OperatorNode *)pNode)->m_Data)
  374.     {
  375.     case HX_RE_GREATEREQUAL:
  376.                 return (float)(Left >= Right);
  377. break;
  378.     case HX_RE_GREATER:
  379.                 return (float)(Left > Right);
  380. break;
  381.             case HX_RE_LESSEQUAL:
  382. if( Right == RULE_VAL_INFINITY )
  383. {
  384.     return (float)TRUE;
  385. }
  386.                 return (float)(Left <= Right);
  387. break;
  388.     case HX_RE_LESS:
  389. if( Right == RULE_VAL_INFINITY )
  390. {
  391.     return (float)TRUE;
  392. }
  393.                 return (float)(Left < Right);
  394. break;
  395.     case HX_RE_EQUAL:
  396.                 return (float)(Left == Right);
  397. break;
  398.     case HX_RE_NOTEQUAL:
  399.                 return (float)(Left != Right);
  400. break;
  401.     case HX_RE_AND:
  402.                 return (float)(Left && Right);
  403. break;
  404.     case HX_RE_OR:
  405.                 return (float)(Left || Right);
  406. break;
  407.             default:
  408.                 HX_ASSERT(0);
  409.                 return (float)0;
  410.                 break;
  411.     }
  412. }
  413. break;
  414.     default:
  415.         HX_ASSERT(0);
  416.         return (float)0;
  417.         break;
  418.     }
  419. }
  422. BOOL
  423. ASMRuleExpression::Evaluate(IHXValues* pVars)
  424. {
  425.     BOOL res;
  426.     //printf ("Evaluate ASMRuleExpression:n");
  427.     res = (BOOL)REvaluate(m_pHead, pVars);
  428.     //printf ("%dn", res);
  429.     return res;
  430. }
  435. /*
  436.  * This is a recursive function which will evaluate a tree with one free
  437.  * variable (pPrevar).  The returned array will contain all possible values
  438.  * that are border cases.
  439.  */
  440. float
  441. ASMRuleExpression::RPreEvaluate(Node* pNode, IHXValues* pVars,
  442. const char* pPreVar, float*& pThreshold,
  443. UINT32& ulNumThreshold,
  444. BOOL& bInvolvesTheOpenVariable)
  445. {
  446.     bInvolvesTheOpenVariable = FALSE;
  447.     float retval = 0;
  449.     float* pThresholdL = NULL;
  450.     float* pThresholdR = NULL;
  452. #define RETURN(x) retval = x; goto exitpoint;
  454.     if (!pNode)
  455.         return (float)0;
  457.     switch(pNode->m_Type)
  458.     {
  459.     case HX_RE_VARIABLE:
  460. {
  461.     IHXBuffer* pValue=NULL;
  462.             float nValue = (float)0;
  464.     pVars->GetPropertyCString(((VariableNode *)pNode)->m_Data, pValue);
  466.     if (pValue)
  467.     {
  468.                 nValue = (float)atof((const char *)pValue->GetBuffer());
  469. pValue->Release();
  470.     }
  472.     if (strcasecmp(((VariableNode *)pNode)->m_Data, pPreVar) == 0)
  473.     {
  474. bInvolvesTheOpenVariable = TRUE;
  475.     }
  477.     return nValue;
  478. }
  480.     case HX_RE_INTEGER:
  481.         return (float)((IntegerNode *)pNode)->m_Data;
  482. break;
  483.     case HX_RE_FLOAT:
  484. return ((FloatNode *)pNode)->m_Data;
  485. break;
  486.     case HX_RE_OPERATOR:
  487. {
  488.     BOOL bInvolveL, bInvolveR;
  490.     UINT32 ulNumThresholdL = 0;
  491.     pThresholdL = pThreshold;
  492.     float Left  = RPreEvaluate(pNode->m_pLeft,  pVars, pPreVar,
  493.     pThresholdL, ulNumThresholdL, bInvolveL);
  495.     UINT32 ulNumThresholdR = 0;
  496.     pThresholdR = pThreshold + ulNumThresholdL;
  497.     float Right = RPreEvaluate(pNode->m_pRight, pVars, pPreVar,
  498.     pThresholdR, ulNumThresholdR, bInvolveR);
  500.     /* Handle aggregation of Threshold arrays */
  501.     switch (((OperatorNode *)pNode)->m_Data)
  502.     {
  503.     case HX_RE_GREATEREQUAL:
  504.     case HX_RE_GREATER:
  505.     case HX_RE_LESSEQUAL:
  506.     case HX_RE_LESS:
  507.     case HX_RE_EQUAL:
  508.     case HX_RE_NOTEQUAL:
  509. if (bInvolveR)
  510. {
  511.     bInvolvesTheOpenVariable = TRUE;
  512.     *pThreshold = Left;
  513.     pThreshold++;
  514.     ulNumThreshold++;
  515.     RETURN ((float)1);
  516. }
  517. if (bInvolveL)
  518. {
  519.     bInvolvesTheOpenVariable = TRUE;
  520.     *pThreshold = Right;
  521.     pThreshold++;
  522.     ulNumThreshold++;
  523.     RETURN ((float)1);
  524. }
  525. break;
  526.     case HX_RE_AND:
  527. if ((Left && bInvolveR) || (Right && bInvolveL))
  528. {
  529.     bInvolvesTheOpenVariable = TRUE;
  530.     UINT32 ulSize = ulNumThresholdL + ulNumThresholdR;
  531.     pThreshold += ulSize;
  532.     ulNumThreshold += ulSize;
  534.     RETURN ((float)1);
  535. }
  536. else
  537. {
  538.     RETURN ((float)0);
  539. }
  541.     case HX_RE_OR:
  542. if (Left || bInvolveL || Right || bInvolveR)
  543. {
  544.     bInvolvesTheOpenVariable = TRUE;
  545.     UINT32 ulSize = ulNumThresholdL + ulNumThresholdR;
  546.     pThreshold += ulSize;
  547.     ulNumThreshold += ulSize;
  549.     RETURN ((float)1);
  550. }
  551. else
  552. {
  553.     RETURN ((float)0);
  554. }
  555.     }
  557.     switch (((OperatorNode *)pNode)->m_Data)
  558.     {
  559.     case HX_RE_GREATEREQUAL:
  560.                 RETURN ((float)(Left >= Right));
  562.     case HX_RE_GREATER:
  563.                 RETURN ((float)(Left > Right));
  565.             case HX_RE_LESSEQUAL:
  566.                 RETURN ((float)(Left <= Right));
  568.     case HX_RE_LESS:
  569.                 RETURN ((float)(Left < Right));
  571.     case HX_RE_EQUAL:
  572.                 RETURN ((float)(Left == Right));
  574.     case HX_RE_NOTEQUAL:
  575.                 RETURN ((float)(Left != Right));
  577.     case HX_RE_AND:
  578.                 RETURN ((float)(Left && Right));
  580.     case HX_RE_OR:
  581.                 RETURN ((float)(Left || Right));
  583.             default:
  584.                 HX_ASSERT(0);
  585.                 RETURN ((float)0);
  586.     }
  587. }
  589.     default:
  590.         HX_ASSERT(0);
  591.         RETURN ((float)0);
  593.     }
  595. exitpoint:
  597.     return retval;
  599. #undef RETURN
  600. }
  603. void
  604. ASMRuleExpression::PreEvaluate(float*& pThreshold, UINT32& ulNumThreshold,
  605.     IHXValues* pVariables, const char* pPreVar)
  606. {
  607.     BOOL bJunk = 0;
  609.     RPreEvaluate(m_pHead, pVariables, pPreVar, 
  610.  pThreshold, ulNumThreshold, bJunk);
  611. }
  613. /*
  614.  * This is a recursive expression evaluator that will determine whether
  615.  * or not the given variable occurs anywhere in the expression.
  616.  */ 
  617. BOOL
  618. ASMRuleExpression::RFindVariable(Node* pNode, const char* pVariable)
  619. {
  620.     if (!pNode)
  621.         return FALSE;
  623.     switch(pNode->m_Type)
  624.     {
  625.     case HX_RE_VARIABLE:
  626. {
  627.     if (strcasecmp(((VariableNode *)pNode)->m_Data, pVariable) == 0)
  628.     {
  629. return TRUE;
  630.     }
  631. }
  632. break;
  633.     case HX_RE_OPERATOR:
  634. {
  635.     return (RFindVariable(pNode->m_pLeft, pVariable) ||
  636.     RFindVariable(pNode->m_pRight, pVariable));
  637. }
  639.     case HX_RE_INTEGER:
  640.     case HX_RE_FLOAT:
  641.     default:
  642.         break;
  643.     }
  645.     return FALSE;
  646. }
  648. BOOL
  649. ASMRuleExpression::FindVariable(const char* pVariable)
  650. {
  651.     return RFindVariable(m_pHead, pVariable);
  652. }
  654. class Rule
  655. {
  656. public:
  657. Rule();
  658.     void SetExpression(const char* pExpression);
  659.     void Dump();
  660. private:
  661.     ASMRuleExpression* m_pASMRuleExpression;
  662.     // Add Properties Definitions Here
  663. };
  666. ASMRule::ASMRule()
  667.     : m_pRuleExpression(0)
  668. {
  669. m_pRuleProps = new CHXHeader;
  671. HX_ASSERT(m_pRuleProps != NULL);
  673. if(m_pRuleProps)
  674. {
  675. m_pRuleProps->AddRef();
  676. }
  677. }
  680. ASMRule::~ASMRule()
  681. {
  682.     HX_RELEASE(m_pRuleProps);
  683.     HX_DELETE(m_pRuleExpression);
  684. }
  687. void
  688. ASMRule::SetExpression(const char* pExpression)
  689. {
  690.     m_pRuleExpression = new ASMRuleExpression(pExpression);
  691. }
  694. void
  695. ASMRule::Dump()
  696. {
  697.     m_pRuleExpression->Dump();
  698. }
  701. ASMRuleBook::ASMRuleBook(const char* pRuleBook)
  702. : m_pValidRulesArray(NULL)
  703. , m_pDeletedRulesArray(NULL)
  704. , m_pRuleBook(NULL)
  705. , m_LastError(HXR_OK)
  706. {
  707.     m_ulNumThresholds = 1; // always have a default
  708.     int i;
  709.     const char* pRule;
  711.     // Count Rules
  712.     i = 0;
  713.     BOOL bSingleQuote      = 0;
  714.     BOOL bDoubleQuote     = 0;
  715.     for (pRule = pRuleBook; *pRule; pRule++)
  716.     {
  717. if ((*pRule == ''') && (!bDoubleQuote))
  718.     bSingleQuote = !bSingleQuote;
  719. if ((*pRule == '"') && (!bSingleQuote))
  720.     bDoubleQuote = !bDoubleQuote;
  722. // Count the number of semi-colons (number of rules)
  723. if ((bSingleQuote == 0) && (bDoubleQuote == 0) && (*pRule == ';'))
  724.     i++;
  725.     }
  727.     m_unNumRules = i;
  728.     m_pRules = new ASMRule[i];
  729.     if(!m_pRules)
  730.     {
  731.        m_LastError = HXR_OUTOFMEMORY;
  732.         return;
  733.     }
  734.     //printf ("%d Rulesn", i);
  736.     // Iterate through each rule
  737.     m_pRuleBook = new char[ strlen( pRuleBook ) + 1 ];
  738.     if(!m_pRuleBook)
  739.     {
  740.         m_LastError = HXR_OUTOFMEMORY;
  741.         HX_DELETE(m_pRules);
  742.         return;
  743.     }
  744.     else
  745.     {
  746.         memcpy( (void*) m_pRuleBook, pRuleBook, strlen( pRuleBook ) + 1 );
  747.     }
  749.     m_LastError = Reset();
  750. }
  753. ASMRuleBook::~ASMRuleBook()
  754. {
  755.     delete [] m_pRules;
  756.     if( m_pValidRulesArray )
  757.     {
  758.        HX_VECTOR_DELETE(m_pValidRulesArray);
  759.     }
  760.     if( m_pDeletedRulesArray )
  761.     {
  762.        HX_VECTOR_DELETE(m_pDeletedRulesArray);
  763.     }
  765. HX_VECTOR_DELETE(m_pRuleBook);
  766. }
  769. BOOL
  770. ASMRuleBook::HasExpression()
  771. {
  772.     for (int i = 0; i < m_unNumRules; i++)
  773.     {
  774.         if (m_pRules[i].m_pRuleExpression)
  775.     return TRUE;
  776.     }
  778.     return FALSE;
  779. }
  782. HX_RESULT
  783. ASMRuleBook::GetProperties(UINT16 unRuleNumber, IHXValues*& pRuleProps)
  784. {
  785.     pRuleProps = m_pRules[unRuleNumber].m_pRuleProps;
  786.     if( pRuleProps )
  787.     {
  788.         pRuleProps->AddRef();
  789.     }
  791.     return HXR_OK;
  792. }
  795. /* Uses REvaluate to return the current subscription given pVariables */
  796. HX_RESULT
  797. ASMRuleBook::GetSubscription(BOOL* pSubInfo, IHXValues* pVariables)
  798. {
  799.     UINT32 i = 0;
  801.     for (i = 0; i < m_unNumRules; i++)
  802.     {
  803.         if( m_pDeletedRulesArray && m_pDeletedRulesArray[i] == TRUE )
  804. {
  805.             pSubInfo[i] = 0;
  806. }
  807. else if (m_pRules[i].m_pRuleExpression)
  808.         {
  809.             pSubInfo[i] = m_pRules[i].m_pRuleExpression->Evaluate(pVariables);
  810.         }
  811.         else
  812.         {
  813.             pSubInfo[i] = 1;
  814.         }
  815.     }
  817.     return HXR_OK;
  818. }
  820. /* 
  821.  * Uses RFindVariable to return information on which rules contain a 
  822.  * given variable in their expressions 
  823.  */
  824. HX_RESULT
  825. ASMRuleBook::FindVariable(BOOL* pFound, const char* pVariable)
  826. {
  827.     UINT32 i = 0;
  829.     for (i = 0; i < m_unNumRules; i++)
  830.     {
  831. if (m_pRules[i].m_pRuleExpression)
  832. {
  833.     pFound[i] = m_pRules[i].m_pRuleExpression->FindVariable(pVariable);
  834. }
  835. else
  836. {
  837.     pFound[i] = FALSE;
  838. }
  839.     }
  841.     return HXR_OK;
  842. }
  844. /* 
  845.  * Uses GetProperties to return information on which rules contain a 
  846.  * given property 
  847.  */
  848. HX_RESULT
  849. ASMRuleBook::FindProperty(BOOL* pFound, const char* pProperty)
  850. {
  851.     HX_RESULT hResult     = HXR_OK;
  852.     UINT32 i     = 0;
  853.     IHXValues* pProperties = NULL;
  854.     IHXBuffer* pBuffer     = NULL;
  856.     for (i = 0; i < m_unNumRules; i++)
  857.     {
  858. hResult = GetProperties((UINT16)i, pProperties);
  859. if (HXR_OK == hResult)
  860. {
  861.     hResult = pProperties->GetPropertyCString(pProperty, pBuffer);
  862.     if (HXR_OK == hResult)
  863.     {
  864. pFound[i] = TRUE;
  865. HX_RELEASE(pBuffer);
  866.     }
  867.     HX_RELEASE(pProperties);
  868. }
  869.     }
  871.     return HXR_OK;
  872. }
  874. static int FloatCompare(const void* p1, const void* p2)
  875. {
  876.     if (*(float*)p1 < *(float*)p2)
  877. return -1;
  878.     if (*(float*)p1 > *(float*)p2)
  879. return 1;
  880.     return 0;
  881. }
  883. /*
  884.  * Uses RPreEvaluate to return the array of threshold values, 
  885.  * given pVariables and pPreVar (the free variable)
  886.  * Caveat: Your variables must say "0" for pPreVar in pVariables.
  887.  */
  888. HX_RESULT
  889. ASMRuleBook::GetPreEvaluate(float* pThreshold, UINT32& ulNumThreshold,
  890.     IHXValues* pVariables, const char* pPreVar)
  891. {
  892.     UINT16 i;
  893.     float* pUnsortedFinal   = new float[m_ulNumThresholds+1];
  894.     float* pTemp = pUnsortedFinal;
  896.     UINT32 ulUFNum = 0;
  897.     ulNumThreshold = 0;
  899.     /* Get everything into a unsorted array with duplicates */ 
  900.     for (i = 0; i < m_unNumRules; i++)
  901.     {
  902.         if (m_pRules[i].m_pRuleExpression)
  903. {
  904.             m_pRules[i].m_pRuleExpression->PreEvaluate(pTemp, ulUFNum,
  905. pVariables, pPreVar);
  906. }
  907.     }
  909.     /*
  910.      * XXXSMP Totally disgusting and doesn't belong here.  So much for
  911.      * a clean, extensible function.
  912.      */
  913.     IHXValues* pValues = 0;
  914.     IHXBuffer* pBuffer = 0;
  916.     pUnsortedFinal[ulUFNum] = (float)0;
  917.     for (i = 0; i < m_unNumRules; i++)
  918.     {
  919. BOOL bOn = TRUE;
  921. if (m_pRules[i].m_pRuleExpression)
  922. {
  923.     bOn = m_pRules[i].m_pRuleExpression->Evaluate(pVariables);
  924. }
  926. if (bOn)
  927. {
  928.     GetProperties((UINT16) i, pValues);
  930.     if (HXR_OK == pValues->GetPropertyCString("AverageBandwidth",
  931. pBuffer))
  932.     {
  933. pUnsortedFinal[ulUFNum] += atoi((char*)pBuffer->GetBuffer());
  934. pBuffer->Release();
  935.     }
  937.     if (HXR_OK == pValues->GetPropertyCString("DropByN",
  938. pBuffer))
  939.     {
  940. pUnsortedFinal[ulUFNum] += 1;
  941. pBuffer->Release();
  942.     }
  943.             HX_RELEASE(pValues);
  944. }
  945.     }
  947.     ulUFNum++;
  949.     pUnsortedFinal[ulUFNum] = (float)0;
  951.     qsort(pUnsortedFinal, ulUFNum+1, sizeof(float), FloatCompare);
  953.     /* Sort and squash duplicates into the output array */
  954.     pTemp = pUnsortedFinal;
  955.     float fLast = *pUnsortedFinal;
  956.     *pThreshold = *pUnsortedFinal;
  957.     pTemp++;
  958.     pThreshold++;
  959.     ulNumThreshold++;
  960.     for (i = 0; i < ulUFNum; i++)
  961.     {
  962. if (*pTemp > fLast)
  963. {
  964.     fLast = *pTemp;
  965.     *pThreshold = fLast;
  966.     pThreshold++;
  967.     ulNumThreshold++;
  968. }
  969. pTemp++;
  970.     }
  972.     delete [] pUnsortedFinal;
  974.     return HXR_OK;
  975. }
  978. #ifdef TESTING
  979. int
  980. main()
  981. {
  982.     const char* pRuleBook =
  983. {
  984. /* Rule 0 */
  985. "     
  986.     #(24000 <= $Bandwidth) && ($Cpu > 50),     
  987.     TolerablePacketLoss=1.5,     
  988.     AverageBandwidth=4000,     
  989.     AverageBandwidthStd=0,     
  990.     Priority=7;     
  991. "
  992. /* Rule 1 */
  993. "     
  994.     #(20000 <= $Bandwidth),     
  995.     TolerablePacketLoss=1.5,     
  996.     AverageBandwidth=4000,     
  997.     AverageBandwidthStd=0,     
  998.     Priority=7;     
  999. "
  1000. /* Rule 2 */
  1001. "     
  1002.     # $Bandwidth >= 16000,     
  1003.     TolerablePacketLoss=1.5,     
  1004.     AverageBandwidth=16000,     
  1005.     AverageBandwidthStd=0,     
  1006.     Priority=7;     
  1007. "
  1008. /* Rule 3 */
  1009. "     
  1010.     #(16000 > $Bandwidth) && (($Bandwidth >= 8000)),     
  1011.     TolerablePacketLoss=2,     
  1012.     AverageBandwidth=8000,     
  1013.     AverageBandwidthStd=0,     
  1014.     Foo="This is a test",     
  1015.     Bar="This wu'z a test",     
  1016.     Priority=7;     
  1017. "
  1018. /* Rule 4 */
  1019. "     
  1020.     # ($Bandwidth > 8000),     
  1021.     AverageBandwidth=4000,     
  1022.     Priority=7;     
  1023. "
  1024. };
  1026.     ASMRuleBook     r(pRuleBook);
  1028.     for (int i = 0; i < 25000; i += 1000)
  1029.     {
  1030. IHXValues* pVal = new CHXHeader;
  1031. IHXBuffer* pBuffer = new CHXBuffer;
  1032. char s[1024]; /* Flawfinder: ignore */
  1033. //printf ("%dn", i);
  1034. sprintf (s, "%d", i); /* Flawfinder: ignore */
  1036. pBuffer->Set((unsigned char *)s, 5);
  1037. pVal->SetPropertyCString("Bandwidth", pBuffer);
  1038. pVal->AddRef();
  1040. pBuffer = new CHXBuffer;
  1041. sprintf (s, "%d", 60); /* Flawfinder: ignore */
  1042. pBuffer->Set((unsigned char *)s, 5);
  1043. pVal->SetPropertyCString("Cpu", pBuffer);
  1044. pVal->AddRef();
  1046. if (i == 0)
  1047. {
  1048.     printf ("Threshold Points:  ");
  1049.     float pThreshold[1024];
  1050.     memset (pThreshold, 0xffffffff, sizeof(float) * 1024);
  1051.     UINT32 ulNum = 0;
  1052.     r.GetPreEvaluate(pThreshold, ulNum, pVal, "Bandwidth");
  1053.     for (int j = 0; j < ulNum; j++)
  1054.     {
  1055. printf ("%.2f ", pThreshold[j]);
  1056.     }
  1057.     printf ("n");
  1058. }
  1060. BOOL pSubInfo[1024];
  1061. r.GetSubscription(pSubInfo, pVal);
  1062. printf ("    bw %5d: %d %d %d %dn", i,
  1063.     pSubInfo[0], pSubInfo[1], pSubInfo[2], pSubInfo[3], pSubInfo[4]);
  1065. pVal->Release();
  1066.     }
  1068.     return 0;
  1069. }
  1070. #endif
  1072. HX_RESULT
  1073. ASMRuleBook::InitRulesArray()
  1074. {
  1075.    if( !m_pValidRulesArray )
  1076.    {
  1077.       m_pValidRulesArray = new BOOL[ m_unNumRules ];
  1078.       if(!m_pValidRulesArray)
  1079.       {
  1080.           return HXR_OUTOFMEMORY;
  1081.       }
  1083.       for( int ii=0; ii<m_unNumRules; ii++ )
  1084.       {
  1085.          m_pValidRulesArray[ii] = TRUE;
  1086.       }
  1087.    }
  1088.    if( !m_pDeletedRulesArray )
  1089.    {
  1090.       m_pDeletedRulesArray = new BOOL[ m_unNumRules ];
  1091.       if(!m_pDeletedRulesArray)
  1092.       {
  1093.           HX_VECTOR_DELETE(m_pValidRulesArray);
  1094.           return HXR_OUTOFMEMORY;
  1095.       }
  1096.       for( int ii=0; ii<m_unNumRules; ii++ )
  1097.       {
  1098.          m_pDeletedRulesArray[ii] = FALSE;
  1099.       }
  1100.    }
  1101.    return HXR_OK;
  1102. }
  1104. HX_RESULT
  1105. ASMRuleBook::Enable( UINT16 nRule )
  1106. {
  1107.    // Allocate and initialized m_pValidRulesArray if necessary.
  1108.    if( HXR_OUTOFMEMORY == InitRulesArray() )
  1109.    {
  1110.        return HXR_OUTOFMEMORY;
  1111.    }
  1112.    else
  1113.    {
  1114.        m_pValidRulesArray[nRule] = TRUE;
  1115.    }
  1117.    return HXR_OK;
  1118. }
  1120. HX_RESULT
  1121. ASMRuleBook::Disable( UINT16 nRule )
  1122. {
  1123.    // Allocate and initialized m_pValidRulesArray if necessary.
  1124.    if( HXR_OUTOFMEMORY == InitRulesArray() )
  1125.    {
  1126.        return HXR_OUTOFMEMORY;
  1127.    }
  1128.    else
  1129.    {
  1130.        m_pValidRulesArray[nRule] = FALSE;
  1131.    }
  1133.    return HXR_OK;
  1134. }
  1136. HX_RESULT
  1137. ASMRuleBook::ReCompute()
  1138. {
  1139.    // We should call a Reset function here
  1140.    if( HXR_OUTOFMEMORY == Reset() )
  1141.    {
  1142.        return HXR_OUTOFMEMORY;
  1143.    }
  1145.    for( int ii=0; ii<m_unNumRules; ii++ )
  1146.    {
  1147.       if( m_pValidRulesArray[ ii ] == FALSE )
  1148.       {
  1149.  DeleteRule( ii );
  1150.       }
  1151.    }
  1152.    return HXR_OK;
  1153. }
  1155. // Remove a rule from the rulebook and 'collapse' the surrounding rules
  1156. // to cover the bandwidth range that up to now was covered by this rule.
  1157. HX_RESULT
  1158. ASMRuleBook::DeleteRule( int uRuleToDel )
  1159. {
  1160.    int nLeftEdge = 0;
  1161.    int nRightEdge = 0;
  1162.    ULONG32 uNumActiveRules = 0;
  1163.    int ii;
  1165.    // The rule should not be greater the max, of course.
  1166.    if( uRuleToDel > m_unNumRules )
  1167.    {
  1168.       return HXR_FAIL;
  1169.    }
  1171.    // Find the "right edge" rule.
  1172.    for( ii=0; ii<m_unNumRules; ii++ )
  1173.    {
  1174.       if( !m_pDeletedRulesArray[ii] && m_pRules[ii].m_pRuleExpression->IsRightEdge() )
  1175.       {
  1176.          nRightEdge = ii;
  1177.  break;
  1178.       }
  1179.    }
  1181.    // Find the "left edge" rule.
  1182.    for( ii=m_unNumRules-1; ii>=0; ii-- )
  1183.    {
  1184.       if( ( m_pDeletedRulesArray[ii] == FALSE ) && ( m_pRules[ ii ].m_pRuleExpression->GetLeft() || m_pRules[ ii ].m_pRuleExpression->GetRight() ) )
  1185.       {
  1186.          nLeftEdge = ii;
  1187.       }
  1188.    }
  1190.    // Determine the number of active rules.
  1191.    for( ii=0; ii<m_unNumRules; ii++ )
  1192.    {
  1193.       if( !m_pDeletedRulesArray[ii] )
  1194.       {
  1195.          uNumActiveRules++;
  1196.       }
  1197.    }
  1199.    // We handle the 3 possible cases separately: 1) Left Edge, 2) Right Edge, 
  1200.    // and 3) Non-Edge.
  1201.    if( uRuleToDel == nLeftEdge )
  1202.    {
  1203.       // Left edge case
  1204.       // Modify the next rule(s) to the right so that it's > value is 0.
  1205.       // But only if this is the only rule covering uRuleToDel's bw range.
  1206.       if( CheckCurrentRangeEmpty( uRuleToDel ) == TRUE )
  1207.       {
  1208.          for( ii=uRuleToDel+1; ii<m_unNumRules; ii++ )
  1209.          {
  1210.             if( !m_pDeletedRulesArray[ ii ] && (
  1211.                 ( m_pRules[ ii ].m_pRuleExpression->GetLeft() == m_pRules[ uRuleToDel ].m_pRuleExpression->GetRight() ) ) )
  1212.             {
  1213.                m_pRules[ ii ].m_pRuleExpression->SetLeft( 0 );
  1214.             }
  1215.          }
  1216.       }
  1217.    }
  1218.    else if( uRuleToDel >= nRightEdge )
  1219.    {
  1220.       // Right edge case
  1221.       // Set the right value (less than x) to infinity
  1222.       // But only if this is the only rule covering uRuleToDel's bw range.
  1223.       if( CheckCurrentRangeEmpty( uRuleToDel ) == TRUE )
  1224.       {
  1225.          for( ii=uRuleToDel-1; ii>=0; ii-- )
  1226.          {
  1227.             if( !m_pDeletedRulesArray[ ii ] && (
  1228.                 ( m_pRules[ ii ].m_pRuleExpression->GetRight() == m_pRules[ uRuleToDel ].m_pRuleExpression->GetRight() ) ) )
  1229.             {
  1230.                m_pRules[ ii ].m_pRuleExpression->SetRight( RULE_VAL_INFINITY );
  1231.             }
  1232.          }
  1233.       }
  1234.    }
  1235.    else if( uRuleToDel > nLeftEdge )
  1236.    {
  1237.       // Non-edge case
  1238.       // Set all "left-adjacent" rules "right-hand" value to nRight.
  1239.       // But only if this is the only rule covering uRuleToDel's bw range.
  1240.       if( CheckCurrentRangeEmpty( uRuleToDel ) == FALSE )
  1241.       {
  1242.          // Determine the value of our right-hand value.
  1243.          int nRight = (int) m_pRules[ uRuleToDel ].m_pRuleExpression->GetRight();
  1245.          for( ii=uRuleToDel-1; ii>=0; ii-- )
  1246.          {
  1247.             if( !m_pDeletedRulesArray[ ii ] && (
  1248.         ( m_pRules[ ii ].m_pRuleExpression->GetRight() == m_pRules[ uRuleToDel ].m_pRuleExpression->GetLeft() ) ) )
  1249.             {
  1250.                m_pRules[ ii ].m_pRuleExpression->SetRight( nRight );
  1251.             }
  1252.          }
  1253.       }
  1254.    }
  1256.    m_pDeletedRulesArray[uRuleToDel] = TRUE;
  1257.    return HXR_OK;
  1258. }
  1260. void
  1261. ASMRuleExpression::SetLeft( int nLeft )
  1262. {
  1263.    int nRight = ((IntegerNode*) ((VariableNode*)m_pHead->m_pRight))->m_Data;
  1264.    if( nRight == 1 )
  1265.    {
  1266.       ((IntegerNode*)(m_pHead->m_pLeft->m_pRight))->m_Data = nLeft;
  1267.    }
  1268. }
  1270. void
  1271. ASMRuleExpression::SetRight( int nRight )
  1272. {
  1273.    int nTmpRight = 0;
  1274.    if( m_pHead && m_pHead->m_pRight )
  1275.    {
  1276.       nTmpRight = ((IntegerNode*) ((VariableNode*)m_pHead->m_pRight))->m_Data;
  1277.    }
  1279.    if( nTmpRight == 1 )
  1280.    {
  1281.       ( (IntegerNode*)((VariableNode*) ((VariableNode*)m_pHead->m_pRight)->m_pRight) )->m_Data = nRight;
  1282.    }
  1283.    else if( nTmpRight != 0 )
  1284.    {
  1285.       ((VariableNode*)m_pHead->m_pRight)->m_Data = (char*)nRight;
  1286.    }
  1287. }
  1289. float
  1290. ASMRuleExpression::GetLeft()
  1291. {
  1292.    int nLeft = 0;
  1293.    int nRight = 0;
  1294.    if( m_pHead && m_pHead->m_pRight )
  1295.    {
  1296.       nRight = ((IntegerNode*) ((VariableNode*)m_pHead->m_pRight))->m_Data;
  1297.    }
  1298.    if( nRight == 1 )
  1299.    {
  1300.       nLeft = ((IntegerNode*) ((VariableNode*)m_pHead->m_pLeft->m_pRight))->m_Data;
  1301.    }
  1302.    return (float)nLeft;
  1303. }
  1305. float
  1306. ASMRuleExpression::GetRight()
  1307. {
  1308.    int nRight = 0;
  1309.    if( m_pHead && m_pHead->m_pRight )
  1310.    {
  1311.       nRight = ((IntegerNode*) ((VariableNode*)(m_pHead->m_pRight)))->m_Data;
  1312.    }
  1313.    if( nRight == 1 )
  1314.    {
  1315.       nRight = ((IntegerNode*) ((VariableNode*)m_pHead->m_pRight->m_pRight))->m_Data;
  1316.    }
  1317.    return (float)nRight;
  1318. }
  1320. int
  1321. ASMRuleExpression::GetOperatorAsInt()
  1322. {
  1323.    return (int) ((OperatorNode*) m_pHead)->m_Data;
  1324. }
  1326. // This function checks to see if the current rule's operator is GREATER or
  1327. // GREATEROREQUAL, both of which would suggest that we are the "right edge"
  1328. // rule.
  1329. BOOL
  1330. ASMRuleExpression::IsRightEdge()
  1331. {
  1332.    if( m_pHead )
  1333.    {
  1334.       switch(((OperatorNode*)m_pHead)->m_Data)
  1335.       {
  1336.   case HX_RE_GREATER:
  1337.   case HX_RE_GREATEREQUAL:
  1338.       return TRUE;
  1339.       break;
  1341.           default:
  1342.       return FALSE;
  1343.       break;
  1344.       }
  1345.    }
  1346.    else
  1347.    {
  1348.       return FALSE;
  1349.    }
  1350. }
  1352. HX_RESULT
  1353. ASMRuleBook::Reset()
  1354. {
  1355.     int i = 0;
  1356.     { //XXXSMPNOW
  1357. BOOL bSeenExpression = 0;
  1359. //printf ("******* Rule %dn", i);
  1361. const char* pRuleBook = m_pRuleBook;
  1362. while (*pRuleBook)
  1363. {
  1364.     char pTemp[2048 + 1];
  1365.     int  n  = 0;
  1366.     BOOL bSingleQuote   = 0;
  1367.     BOOL bDoubleQuote  = 0;
  1369.     for (;((*pRuleBook) && (bDoubleQuote || ((*pRuleBook != ',') && (*pRuleBook != ';')))); pRuleBook++)
  1370.     {
  1371. if ((*pRuleBook == ''') && (!bDoubleQuote))
  1372.     bSingleQuote = !bSingleQuote;
  1373. if ((*pRuleBook == '"') && (!bSingleQuote))
  1374.     bDoubleQuote = !bDoubleQuote;
  1376. // Kill whitespace outside of quotes
  1377. if (bSingleQuote || bDoubleQuote || (
  1378. (*pRuleBook != ' ') &&
  1379. (*pRuleBook != 'n') &&
  1380. (*pRuleBook != 'r') &&
  1381. (*pRuleBook != 't')))
  1382. {
  1383.     pTemp[n++] = *pRuleBook;
  1384.     if (n >= 2048)
  1385.     {
  1386. //printf ("Panic: Rule Property %d too longn", i);
  1387. HX_ASSERT(0);
  1388. break;
  1389.     }
  1390. }
  1391.     }
  1392.     pTemp[n] = 0;
  1394.     if ((*pRuleBook == ',') || (*pRuleBook == ';'))
  1395.     {
  1396. // Rule is Valid!
  1398.      if (*pTemp == '#')
  1399. {
  1400.     // This part of the rule is an expression
  1401.     if (!bSeenExpression)
  1402.     {
  1403. m_pRules[i].SetExpression(pTemp + 1);
  1404. m_pRules[i].Dump();
  1405. bSeenExpression = 1;
  1406. m_ulNumThresholds += m_pRules[i].m_pRuleExpression->GetNumThresholds();
  1407.     }
  1408.     else
  1409.     {
  1410. //printf ("Panic: Two expressions in Rule %dn", i);
  1411. HX_ASSERT(0);
  1412.     }
  1413. }
  1414. else
  1415. {
  1416.                     char *pProp;
  1417.                     char *pValue;
  1419.                     pProp  = pTemp;
  1420.                     pValue = pTemp;
  1422.                     while ((*pValue != '=') && (pValue-pTemp < ((int) strlen(pTemp))))
  1423.                     pValue++;
  1425.                     if (*pValue == '=')
  1426.                     {
  1427.                         *pValue++ = '';
  1428.                     }
  1429.                     else
  1430.                     {
  1431.                         pValue = NULL;
  1432.                     }
  1434.                     if (pValue)
  1435.                     {
  1436.                         IHXBuffer* pBuffer = new CHXBuffer;
  1437.                         if(!pBuffer)
  1438.                         {
  1439.                             return HXR_OUTOFMEMORY;
  1440.                         }
  1442.                         pBuffer->AddRef();
  1444.                         /* Strip Outside Quotes */
  1445.                         if (*pValue == '"')
  1446.                         {
  1447.                             pValue++;
  1448.                             int end = (strlen(pValue) ? strlen(pValue)-1 : 0);
  1449.                             HX_ASSERT(pValue[end] == '"');
  1450.                             pValue[end] = 0;
  1451.                         }
  1453.                         HX_RESULT theErr = 
  1454.                         pBuffer->Set((const unsigned char *)pValue,
  1455.                         strlen(pValue) + 1);
  1457.                         if( theErr == HXR_OUTOFMEMORY )
  1458.                         {
  1459.                             pBuffer->Release();
  1460.                             return theErr;
  1461.                         }
  1463.                         //printf ("Property '%s'--'%s'n", pProp, pValue);
  1465.                         if( m_pRules[i].m_pRuleProps )
  1466.                         {
  1467.                             m_pRules[i].m_pRuleProps->
  1468.                             SetPropertyCString(pProp, pBuffer);
  1469.                         }
  1471.                         pBuffer->Release();
  1472.                     }
  1473. }
  1475. if (*pRuleBook == ';')
  1476. {
  1477.     i++;
  1478.     bSeenExpression = 0;
  1479.                     if (i >= m_unNumRules)
  1480.                     {
  1481.                         break;
  1482.                     }
  1483.     //printf ("******* Rule %dn", i);
  1484. }
  1485. pRuleBook++;
  1486.     }
  1487. }
  1488.     }
  1490.     return InitRulesArray();
  1491. }
  1493. BOOL
  1494. ASMRuleBook::CheckCurrentRangeEmpty( int uRuleToDel )
  1495. {
  1496.     for( int ii=0; ii<m_unNumRules; ii++ )
  1497.     {
  1498.         // But only if this is the only rule covering uRuleToDel's bw range.
  1499.         if( uRuleToDel != ii && !m_pDeletedRulesArray[ ii ] &&
  1500.             ( m_pRules[ ii ].m_pRuleExpression->GetLeft() == m_pRules[ uRuleToDel ].m_pRuleExpression->GetLeft() ) &&
  1501.             ( m_pRules[ ii ].m_pRuleExpression->GetRight() == m_pRules[ uRuleToDel ].m_pRuleExpression->GetRight() ) &&
  1502.             ( m_pRules[ ii ].m_pRuleExpression->GetOperatorAsInt() == m_pRules[ uRuleToDel ].m_pRuleExpression->GetOperatorAsInt() ) )
  1503.         {
  1504.             return FALSE;
  1505.         }
  1506.     }
  1508.     return TRUE;
  1509. }