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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
asmrulep.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：35k
源码类别：

Symbian

开发平台：

Visual C++

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