durable_rules 2.00.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da7281352c66d7ee7dfda3145829aee0ce0bd006
-  data.tar.gz: 04f8626eca2fc8a6d8da3d6da53afe932efbe2e5
+  metadata.gz: 0adaaf5bd93fde23db48196c84cc4c19a6e54eab
+  data.tar.gz: f4a48336da9a8b928da8baf5b0288796b89820e4
 SHA512:
-  metadata.gz: 1ef6301996e4db96709c006409915a66aedd409379ac08bbb94c3a24d003a8a0dbe42a6c401919b5bdfc3e9c4fe78b2957afc5dcbc57465eda74b90d00265b2d
-  data.tar.gz: fcc4e5f9785cd8566b0c74a0b6aef53d4e532e07ccd70df9eed62cce6a0a7867a7d53053ef694bc95c5bf53c2a0d5137d0fbb3d1d9ecf5d5228eb789b9389970
+  metadata.gz: e23ee1d4cbf5e2b42e5054bb862c56b502473759e3d468b66c12e08b41a8dba35a96845c30c2a57d003a9f7cd0ed61653ac830dcf579a9013bb48c65b2e361d7
+  data.tar.gz: aaf8e986ee09e907c794145f2d9cd2052cf75a1e1c4493c38e750a3d32eefbb9e701cf3234b7bc4280d736c9c2b8b2dfeb537f8b45a8069483ccb2397878ae7a

data/src/rules/events.c

@@ -1403,12 +1403,82 @@ static unsigned int handleBetaMessage(ruleset *tree,
                              messageHash);
 }
 
+static unsigned int isArrayMatch(ruleset *tree,
+                                 jsonObject *messageObject,
+                                 jsonProperty *currentProperty,
+                                 alpha *arrayAlpha,
+                                 unsigned char *propertyMatch);
 
-static unsigned int handleAplhaArray(ruleset *tree,
-                                     jsonObject *messageObject,
-                                     jsonProperty *currentProperty,
-                                     alpha *arrayAlpha,
-                                     unsigned char *propertyMatch) {
+static unsigned int isNextMatch(ruleset *tree,
+                                jsonObject *jo,
+                                alpha *currentAlpha,
+                                unsigned char *propertyMatch) {
+    *propertyMatch = 0;
+    if (currentAlpha->nextListOffset) {
+        unsigned int *nextList = &tree->nextPool[currentAlpha->nextListOffset];
+        for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
+            node *listNode = &tree->nodePool[nextList[entry]];
+            jsonProperty *currentProperty;
+            unsigned int aresult = getObjectProperty(jo, listNode->value.a.expression.left.value.id.propertyNameHash, &currentProperty);
+            if (aresult == ERR_PROPERTY_NOT_FOUND) {
+                *propertyMatch = 1;
+                if (listNode->value.a.nextOffset || listNode->value.a.nextListOffset) {
+                    CHECK_RESULT(isNextMatch(tree,
+                                             jo,
+                                             &listNode->value.a,
+                                             propertyMatch));
+                }    
+
+                if (*propertyMatch) {
+                    break;
+                }
+                
+            }
+        }
+    }
+
+    if (currentAlpha->nextOffset) {
+        unsigned int *nextHashset = &tree->nextPool[currentAlpha->nextOffset];
+        for(unsigned int propertyIndex = 0; propertyIndex < jo->propertiesLength; ++propertyIndex) {
+            jsonProperty *currentProperty = &jo->properties[propertyIndex];
+            for (unsigned int entry = currentProperty->hash & HASH_MASK; nextHashset[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
+                node *hashNode = &tree->nodePool[nextHashset[entry]];  
+                if (hashNode->value.a.expression.operator == OP_IALL || hashNode->value.a.expression.operator == OP_IANY) {
+                    CHECK_RESULT(isArrayMatch(tree,
+                                              jo,
+                                              currentProperty, 
+                                              &hashNode->value.a,
+                                              propertyMatch));
+                } else {
+                    CHECK_RESULT(isAlphaMatch(tree, 
+                                              &hashNode->value.a,
+                                              jo, 
+                                              propertyMatch));
+                }
+
+                if (*propertyMatch && (hashNode->value.a.nextOffset || hashNode->value.a.nextListOffset)) {
+                    CHECK_RESULT(isNextMatch(tree,
+                                             jo,
+                                             &hashNode->value.a,
+                                             propertyMatch));
+
+                }
+
+                if (*propertyMatch) {
+                    break;
+                }   
+            }
+        }
+    }   
+    
+    return RULES_OK;
+}
+
+static unsigned int isArrayMatch(ruleset *tree,
+                                 jsonObject *messageObject,
+                                 jsonProperty *currentProperty,
+                                 alpha *arrayAlpha,
+                                 unsigned char *propertyMatch) {
     unsigned int result = RULES_OK;
     if (currentProperty->type != JSON_ARRAY) {
         return RULES_OK;
@@ -1421,10 +1491,6 @@ static unsigned int handleAplhaArray(ruleset *tree,
     result = readNextArrayValue(first, &first, &last, &type);
     while (result == PARSE_OK) {
         *propertyMatch = 0;
-        unsigned short top = 1;
-        alpha *stack[MAX_STACK_SIZE];
-        stack[0] = arrayAlpha;
-        alpha *currentAlpha;
         if (type == JSON_OBJECT) {
             char *next;
             jo.propertiesLength = 0;
@@ -1450,75 +1516,61 @@ static unsigned int handleAplhaArray(ruleset *tree,
                                            last - first + 1));
         }
 
-        while (top) {
-            --top;
-            currentAlpha = stack[top];
-            // add all disjunctive nodes to stack
-            if (currentAlpha->nextListOffset) {
-                unsigned int *nextList = &tree->nextPool[currentAlpha->nextListOffset];
-                for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
-                    node *listNode = &tree->nodePool[nextList[entry]];
-                    char exists = 0;
-                    for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
-                        if (listNode->value.a.expression.left.value.id.propertyNameHash == jo.properties[propertyIndex].hash) {
-                            // filter out not exists (OP_NEX)
-                            exists = 1;
-                            break;
-                        }
-                    }
-
-                    if (!exists) {
-                        if (top == MAX_STACK_SIZE) {
-                            return ERR_MAX_STACK_SIZE;
-                        }
-                        
-                        stack[top] = &listNode->value.a; 
-                        ++top;
+        if (arrayAlpha->nextListOffset) {
+            unsigned int *nextList = &tree->nextPool[arrayAlpha->nextListOffset];
+            for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
+                node *listNode = &tree->nodePool[nextList[entry]];
+                jsonProperty *currentProperty;
+                unsigned int aresult = getObjectProperty(&jo, listNode->value.a.expression.left.value.id.propertyNameHash, &currentProperty);
+                if (aresult == ERR_PROPERTY_NOT_FOUND) {
+                    *propertyMatch = 1;
+                    if (listNode->value.a.nextOffset || listNode->value.a.nextListOffset) {
+                        CHECK_RESULT(isNextMatch(tree,
+                                                 &jo,
+                                                 &listNode->value.a,
+                                                 propertyMatch));
+                    }    
+
+                    if (*propertyMatch) {
+                        break;
                     }
+                    
                 }
             }
+        }
 
-            // calculate conjunctive nodes
-            if (currentAlpha->nextOffset) {
-                unsigned int *nextHashset = &tree->nextPool[currentAlpha->nextOffset];
-                for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
-                    jsonProperty *currentProperty = &jo.properties[propertyIndex];
-                    for (unsigned int entry = currentProperty->hash & HASH_MASK; nextHashset[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
-                        node *hashNode = &tree->nodePool[nextHashset[entry]];
-                        if (currentProperty->hash == hashNode->value.a.expression.left.value.id.propertyNameHash) {
-                            unsigned char match = 0;
-                            if (hashNode->value.a.expression.operator == OP_IALL || hashNode->value.a.expression.operator == OP_IANY) {
-                                // handleAplhaArray finds a valid path, thus use propertyMatch
-                                CHECK_RESULT(handleAplhaArray(tree, 
-                                                              &jo,
-                                                              currentProperty, 
-                                                              &hashNode->value.a,
-                                                              propertyMatch));
-                            } else {
-                                CHECK_RESULT(isAlphaMatch(tree,
-                                                          &hashNode->value.a,
-                                                          &jo,
-                                                          &match));
+        if (arrayAlpha->arrayListOffset) {
+            unsigned int *nextHashset = &tree->nextPool[arrayAlpha->arrayListOffset];
+            for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
+                jsonProperty *currentProperty = &jo.properties[propertyIndex];
+                for (unsigned int entry = currentProperty->hash & HASH_MASK; nextHashset[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
+                    node *hashNode = &tree->nodePool[nextHashset[entry]];  
+                    if (hashNode->value.a.expression.operator == OP_IALL || hashNode->value.a.expression.operator == OP_IANY) {
+                        CHECK_RESULT(isArrayMatch(tree,
+                                                  &jo,
+                                                  currentProperty, 
+                                                  &hashNode->value.a,
+                                                  propertyMatch));
+                    } else {
+                        CHECK_RESULT(isAlphaMatch(tree, 
+                                                  &hashNode->value.a,
+                                                  &jo, 
+                                                  propertyMatch));
+                    }
 
-                                if (match) {
-                                    if (top == MAX_STACK_SIZE) {
-                                        return ERR_MAX_STACK_SIZE;
-                                    }
+                    if (*propertyMatch && hashNode->value.a.nextOffset) {
+                        CHECK_RESULT(isNextMatch(tree,
+                                                 &jo,
+                                                 &hashNode->value.a,
+                                                 propertyMatch));
 
-                                    stack[top] = &hashNode->value.a; 
-                                    ++top;
-                                }
-                            }
-                        }
-                    }               
+                    }
+
+                    if (*propertyMatch && (hashNode->value.a.nextOffset || hashNode->value.a.nextListOffset)) {
+                        break;
+                    }   
                 }
             }
-
-            // no next offset and no nextListOffest means we found a valid path
-            if (!currentAlpha->nextOffset && !currentAlpha->nextListOffset) {
-                *propertyMatch = 1;
-                break;
-            } 
         }
         
         // OP_IANY, one element led a a valid path
@@ -1586,11 +1638,11 @@ static unsigned int handleAlpha(ruleset *tree,
                         } else {
                             unsigned char match = 0;
                             if (hashNode->value.a.expression.operator == OP_IALL || hashNode->value.a.expression.operator == OP_IANY) {
-                                CHECK_RESULT(handleAplhaArray(tree,
-                                                              jo,
-                                                              currentProperty, 
-                                                              &hashNode->value.a,
-                                                              &match));
+                                CHECK_RESULT(isArrayMatch(tree,
+                                                          jo,
+                                                          currentProperty, 
+                                                          &hashNode->value.a,
+                                                          &match));
                             } else {
                                 CHECK_RESULT(isAlphaMatch(tree, 
                                                           &hashNode->value.a,

data/src/rules/rete.c

@@ -156,6 +156,7 @@ static unsigned int storeAlpha(ruleset *tree,
         return result;
     }
 
+    (*newNode)->value.a.arrayListOffset = 0;
     (*newNode)->value.a.nextListOffset = 0;
     (*newNode)->value.a.betaListOffset = 0;
     (*newNode)->value.a.nextOffset = 0;
@@ -189,6 +190,13 @@ static unsigned int allocateNext(ruleset *tree,
     return RULES_OK;
 }
 
+static unsigned int ensureNextArrayHashset(ruleset *tree, node *newNode) {
+    if (!newNode->value.a.arrayListOffset) {
+        return allocateNext(tree, NEXT_BUCKET_LENGTH, &newNode->value.a.arrayListOffset);
+    }
+
+    return RULES_OK;
+}
 
 static unsigned int ensureNextHashset(ruleset *tree, node *newNode) {
     if (!newNode->value.a.nextOffset) {
@@ -753,9 +761,14 @@ static unsigned int validateRuleset(char *rules) {
     return (result == PARSE_END ? PARSE_OK: result);
 }
 
-static unsigned int linkAlpha(ruleset *tree, 
+static unsigned int linkAlpha(ruleset *tree,
+                              char linkToArray, 
                               unsigned int parentOffset, 
                               unsigned int nextOffset) {
+    if (!nextOffset) {
+        return RULES_OK;
+    }
+
     unsigned int entry;
     node *parentAlpha = &tree->nodePool[parentOffset];
     node *nextNode = &tree->nodePool[nextOffset];
@@ -785,10 +798,19 @@ static unsigned int linkAlpha(ruleset *tree,
 
         parentNextList[entry] = nextOffset;
     } else {
-        CHECK_RESULT(ensureNextHashset(tree, 
-                                       parentAlpha));
-        
-        unsigned int *parentNext = &tree->nextPool[parentAlpha->value.a.nextOffset];
+        unsigned int *parentNext = NULL;
+        if ((parentAlpha->value.a.expression.operator == OP_IALL || parentAlpha->value.a.expression.operator == OP_IANY) && linkToArray) {
+            CHECK_RESULT(ensureNextArrayHashset(tree, 
+                                                parentAlpha));
+
+            parentNext = &tree->nextPool[parentAlpha->value.a.arrayListOffset];
+        } else {
+            CHECK_RESULT(ensureNextHashset(tree, 
+                                           parentAlpha));
+
+            parentNext = &tree->nextPool[parentAlpha->value.a.nextOffset];
+        }
+
         unsigned int hash = nextNode->value.a.expression.left.value.id.propertyNameHash;
         for (entry = hash & HASH_MASK; parentNext[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
             if ((entry + 1) % NEXT_BUCKET_LENGTH == (hash & HASH_MASK)) {
@@ -923,6 +945,7 @@ static unsigned int findAlpha(ruleset *tree,
                               unsigned int parentOffset, 
                               unsigned char operator, 
                               char *rule,
+                              char linkToArray,
                               unsigned int betaOffset, 
                               unsigned int *resultOffset) {
     char *first;
@@ -1000,6 +1023,7 @@ static unsigned int findAlpha(ruleset *tree,
     
     newAlpha->nameOffset = stringOffset;
     newAlpha->type = NODE_ALPHA;
+    newAlpha->value.a.stringOffset = stringOffset;
     newAlpha->value.a.expression.left.type = JSON_MESSAGE_IDENTIFIER;
     newAlpha->value.a.expression.left.value.id.propertyNameHash = hash;
     newAlpha->value.a.expression.left.value.id.propertyNameOffset = newAlpha->nameOffset;
@@ -1014,27 +1038,23 @@ static unsigned int findAlpha(ruleset *tree,
         type = JSON_IREGEX;
     }
 
-    //if (operator == OP_IANY || operator == OP_IALL) {
-    //    newAlpha->value.a.expression.right.type = JSON_NIL;
-    //} else {
-        CHECK_RESULT(copyValue(tree, 
-                               &newAlpha->value.a.expression.right, 
-                               first, 
-                               last,
-                               expressionOffset, 
-                               &id, 
-                               type));
-
-        if (type == JSON_IDENTIFIER || type == JSON_EXPRESSION) {
-            expression *expr;
-            GET_EXPRESSION(tree, 
-                           betaOffset, 
-                           expr);
-            copyExpression(&newAlpha->value.a.expression, expr);
-        } 
-    //}
-
-    return linkAlpha(tree, parentOffset, *resultOffset);
+    CHECK_RESULT(copyValue(tree, 
+                           &newAlpha->value.a.expression.right, 
+                           first, 
+                           last,
+                           expressionOffset, 
+                           &id, 
+                           type));
+
+    if (type == JSON_IDENTIFIER || type == JSON_EXPRESSION) {
+        expression *expr;
+        GET_EXPRESSION(tree, 
+                       betaOffset, 
+                       expr);
+        copyExpression(&newAlpha->value.a.expression, expr);
+    } 
+
+    return linkAlpha(tree, linkToArray, parentOffset, *resultOffset);
 }
 
 static unsigned int getSetting(unsigned int settingHash, char *rule, unsigned short *value) {
@@ -1077,6 +1097,7 @@ static unsigned int createForwardAlpha(ruleset *tree,
     
     newAlpha->nameOffset = 0;
     newAlpha->type = NODE_ALPHA;
+    newAlpha->value.a.arrayListOffset = 0;
     newAlpha->value.a.expression.left.type = JSON_MESSAGE_IDENTIFIER;
     newAlpha->value.a.expression.left.value.id.propertyNameOffset = 0;
     newAlpha->value.a.expression.left.value.id.propertyNameHash = HASH_FORWARD;
@@ -1089,6 +1110,7 @@ static unsigned int createForwardAlpha(ruleset *tree,
 
 static unsigned int createAlpha(ruleset *tree, 
                                 char *rule, 
+                                char linkToArray,
                                 unsigned int betaOffset,
                                 unsigned int nextOffset,
                                 unsigned int *newOffset) {
@@ -1159,10 +1181,12 @@ static unsigned int createAlpha(ruleset *tree,
             while (result == PARSE_OK) {
                 CHECK_RESULT(createAlpha(tree, 
                                          first, 
+                                         linkToArray,
                                          betaOffset, 
                                          0, 
                                          &resultOffset));
                 
+                linkToArray = 0;
                 previousOffset = resultOffset;
                 result = readNextArrayValue(last, 
                                             &first, 
@@ -1176,6 +1200,7 @@ static unsigned int createAlpha(ruleset *tree,
                               OP_END);
             if (nextOffset != 0) {
                 return linkAlpha(tree, 
+                                 0,
                                  previousOffset, 
                                  nextOffset);
             }
@@ -1196,11 +1221,13 @@ static unsigned int createAlpha(ruleset *tree,
                 unsigned int single_offset = parentOffset;
                 CHECK_RESULT(createAlpha(tree, 
                                          first, 
+                                         linkToArray,
                                          betaOffset, 
                                          0, 
                                          &single_offset));
 
                 CHECK_RESULT(linkAlpha(tree,
+                                       0,
                                        single_offset, 
                                        *newOffset));
                 
@@ -1216,6 +1243,7 @@ static unsigned int createAlpha(ruleset *tree,
                               OP_END);
             if (nextOffset != 0) {
                 return linkAlpha(tree, 
+                                 0,
                                  *newOffset, 
                                  nextOffset);
             }
@@ -1237,7 +1265,8 @@ static unsigned int createAlpha(ruleset *tree,
         CHECK_RESULT(findAlpha(tree, 
                                parentOffset, 
                                operator, 
-                               first, 
+                               first,
+                               linkToArray, 
                                betaOffset, 
                                newOffset));
         
@@ -1254,38 +1283,19 @@ static unsigned int createAlpha(ruleset *tree,
         
         CHECK_RESULT(createAlpha(tree, 
                                  first, 
+                                 1,
                                  betaOffset, 
-                                 nextOffset, 
+                                 0, 
                                  &inner_offset));
         
         node *newAlpha = &tree->nodePool[inner_offset];
         if (newAlpha->value.a.expression.right.type != JSON_IDENTIFIER && newAlpha->value.a.expression.right.type != JSON_EXPRESSION) {
-            return linkAlpha(tree, 
+            return linkAlpha(tree,
+                            0, 
                             *newOffset, 
                             nextOffset);
         } else {
-            // Functions that can execute in client or backend should follow this pattern
-            node *oldAlpha = &tree->nodePool[*newOffset];
-            expression *newExpression = NULL;
-            unsigned int expressionOffset = 0;
-            CHECK_RESULT(storeExpression(tree, 
-                                         &newExpression, 
-                                         &expressionOffset));
-            
-            oldAlpha->value.a.expression.right.type = JSON_EXPRESSION;
-            oldAlpha->value.a.expression.right.value.expressionOffset = expressionOffset;
-            copyExpression(&newAlpha->value.a.expression, newExpression);
-
-            expression *betaExpression;
-            GET_EXPRESSION(tree, 
-                           betaOffset, 
-                           betaExpression);
-
-            copyExpression(newExpression, betaExpression);
-
-            return linkAlpha(tree, 
-                             *newOffset, 
-                             nextOffset);
+            return ERR_UNEXPECTED_TYPE;
         }
     }
 
@@ -1294,6 +1304,7 @@ static unsigned int createAlpha(ruleset *tree,
                          parentOffset, 
                          operator, 
                          first, 
+                         linkToArray,
                          betaOffset, 
                          newOffset);
     } else {
@@ -1301,10 +1312,12 @@ static unsigned int createAlpha(ruleset *tree,
                                parentOffset, 
                                operator, 
                                first, 
+                               linkToArray,
                                betaOffset, 
                                newOffset));
         
-        return linkAlpha(tree, 
+        return linkAlpha(tree,
+                         0, 
                          *newOffset, 
                          nextOffset);
     }
@@ -1408,6 +1421,7 @@ static unsigned int createBeta(ruleset *tree,
                                              &type));
             CHECK_RESULT(createAlpha(tree, 
                                      first, 
+                                     0,
                                      betaOffset, 
                                      betaOffset, 
                                      &resultOffset));
@@ -1626,11 +1640,15 @@ static void printBetaNode(ruleset *tree, node *betaNode, int level, unsigned int
     }
 }
 
-static void printAlphaNode(ruleset *tree, node *alphaNode, int level, unsigned int offset) {
+static void printAlphaNode(ruleset *tree, node *alphaNode, int level, char *prefix, unsigned int offset) {
     for (int i = 0; i < level; ++ i) {
         printf("    ");
     }
 
+    if (prefix) {
+        printf("%s", prefix);
+    }
+
     printf("-> alpha: name %s, offset %u\n", &tree->stringPool[alphaNode->nameOffset], offset);
     
     for (int i = 0; i < level; ++ i) {
@@ -1640,11 +1658,20 @@ static void printAlphaNode(ruleset *tree, node *alphaNode, int level, unsigned i
     printSimpleExpression(tree, &alphaNode->value.a.expression, 1, NULL);
 
     printf("\n");
+    if (alphaNode->value.a.arrayListOffset) {
+        unsigned int *nextHashset = &tree->nextPool[alphaNode->value.a.arrayListOffset];
+        for (unsigned int entry = 0; entry < NEXT_BUCKET_LENGTH; ++entry) { 
+            if (nextHashset[entry]) {
+                printAlphaNode(tree, &tree->nodePool[nextHashset[entry]], level + 1, "Next Array ", nextHashset[entry]);  
+            }
+        }  
+    }
+
     if (alphaNode->value.a.nextOffset) {
         unsigned int *nextHashset = &tree->nextPool[alphaNode->value.a.nextOffset];
         for (unsigned int entry = 0; entry < NEXT_BUCKET_LENGTH; ++entry) { 
             if (nextHashset[entry]) {
-                printAlphaNode(tree, &tree->nodePool[nextHashset[entry]], level + 1, nextHashset[entry]);  
+                printAlphaNode(tree, &tree->nodePool[nextHashset[entry]], level + 1, "Next ", nextHashset[entry]);  
             }
         }  
     }
@@ -1652,7 +1679,7 @@ static void printAlphaNode(ruleset *tree, node *alphaNode, int level, unsigned i
     if (alphaNode->value.a.nextListOffset) {
         unsigned int *nextList = &tree->nextPool[alphaNode->value.a.nextListOffset];
         for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
-            printAlphaNode(tree, &tree->nodePool[nextList[entry]], level + 1, nextList[entry]);
+            printAlphaNode(tree, &tree->nodePool[nextList[entry]], level + 1, "Next List ", nextList[entry]);
         }
     }
 
@@ -1782,6 +1809,7 @@ static unsigned int createTree(ruleset *tree, char *rules) {
     printAlphaNode(tree, 
                    &tree->nodePool[NODE_M_OFFSET], 
                    0, 
+                   NULL,
                    NODE_M_OFFSET);
 #endif
 
@@ -1845,7 +1873,7 @@ unsigned int createRuleset(unsigned int *handle, char *name, char *rules) {
     newNode->nameOffset = stringOffset;
     newNode->type = NODE_ALPHA;
     newNode->value.a.expression.operator = OP_TYPE;
-
+    
     // will use random numbers for state stored event mids
     srand(time(NULL));
     CREATE_HANDLE(tree, handle);

data/src/rules/rete.h

@@ -1,6 +1,6 @@
 #include "state.h"
 
-//#define _PRINT 1
+// #define _PRINT 1
 
 #define OP_NOP 0
 #define OP_LT 0x01
@@ -83,8 +83,10 @@ typedef struct expressionSequence {
 
 typedef struct alpha {
     expression expression;
+    unsigned int stringOffset;
     unsigned int betaListOffset;
     unsigned int nextListOffset;
+    unsigned int arrayListOffset;
     unsigned int nextOffset;
 } alpha;
 

data/src/rules/state.c

@@ -796,6 +796,9 @@ unsigned int ensureStateNode(void *tree,
             sidHash, 
             nodeOffset);
 
+        if (rulesetTree->statePool.count > MAX_STATE_INDEX_LENGTH) {
+            return ERR_OUT_OF_MEMORY;
+        }
         rulesetTree->reverseStateIndex[rulesetTree->statePool.count - 1] = nodeOffset;
         stateNode *node = STATE_NODE(tree, nodeOffset); 
         node->offset = nodeOffset;
@@ -1118,7 +1121,7 @@ unsigned int getNextResult(void *tree,
 static void insertSortProperties(jsonObject *jo, jsonProperty **properties) {
     for (unsigned short i = 1; i < jo->propertiesLength; ++i) {
         unsigned short ii = i; 
-        while (properties[ii]->hash < properties[ii - 1]->hash) {
+        while (ii >= 1 && (properties[ii]->hash < properties[ii - 1]->hash)) {
             jsonProperty *temp = properties[ii];
             properties[ii] = properties[ii - 1];
             properties[ii - 1] = temp;
@@ -1200,7 +1203,7 @@ unsigned int calculateId(jsonObject *jo) {
 
     unsigned int candidate = HASH_ID % MAX_OBJECT_PROPERTIES;
     while (jo->propertyIndex[candidate] != 0) {
-        candidate = candidate + 1 % MAX_OBJECT_PROPERTIES;
+        candidate = (candidate + 1) % MAX_OBJECT_PROPERTIES;
     }
 
     // Index intentionally offset by 1 to enable getObject 
@@ -1234,7 +1237,7 @@ static unsigned int fixupIds(jsonObject *jo, char generateId) {
 
         unsigned int candidate = HASH_SID % MAX_OBJECT_PROPERTIES;
         while (jo->propertyIndex[candidate] != 0) {
-            candidate = candidate + 1 % MAX_OBJECT_PROPERTIES;
+            candidate = (candidate + 1) % MAX_OBJECT_PROPERTIES;
         }
 
         // Index intentionally offset by 1 to enable getObject 
@@ -1294,7 +1297,7 @@ unsigned int setObjectProperty(jsonObject *jo,
 
     unsigned int candidate = hash % MAX_OBJECT_PROPERTIES;
     while (jo->propertyIndex[candidate] != 0) {
-        candidate = candidate + 1 % MAX_OBJECT_PROPERTIES;
+        candidate = (candidate + 1) % MAX_OBJECT_PROPERTIES;
     }
 
     // Index intentionally offset by 1 to enable getObject 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 2.00.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-08 00:00:00.000000000 Z
+date: 2019-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake