ncd: NCDAst: use a linked list instead of AVL tree to store map elements. There is no reason

to use an AVL tree at the parsing stage.

generated/NCDConfigParser_parse.c

@@ -1448,7 +1448,7 @@ doneM:
 
     NCDValue_InitMap(&yygotominor.yy27.v);
 
-    if (!NCDValue_MapInsert(&yygotominor.yy27.v, yymsp[-2].minor.yy27.v, yymsp[0].minor.yy27.v)) {
+    if (!NCDValue_MapPrepend(&yygotominor.yy27.v, yymsp[-2].minor.yy27.v, yymsp[0].minor.yy27.v)) {
         goto failS1;
     }
     yymsp[-2].minor.yy27.have = 0;
@@ -1476,14 +1476,7 @@ doneS:
         goto failT0;
     }
 
-    if (NCDValue_MapFindKey(&yymsp[0].minor.yy27.v, &yymsp[-4].minor.yy27.v)) {
-        BLog(BLOG_ERROR, "duplicate key in map");
-        yygotominor.yy27.have = 0;
-        parser_out->syntax_error = 1;
-        goto doneT;
-    }
-
-    if (!NCDValue_MapInsert(&yymsp[0].minor.yy27.v, yymsp[-4].minor.yy27.v, yymsp[-2].minor.yy27.v)) {
+    if (!NCDValue_MapPrepend(&yymsp[0].minor.yy27.v, yymsp[-4].minor.yy27.v, yymsp[-2].minor.yy27.v)) {
         goto failT0;
     }
     yymsp[-4].minor.yy27.have = 0;
@@ -1504,29 +1497,29 @@ doneT:
   yy_destructor(yypParser,11,&yymsp[-3].minor);
   yy_destructor(yypParser,15,&yymsp[-1].minor);
 }
-#line 1508 "NCDConfigParser_parse.c"
+#line 1501 "NCDConfigParser_parse.c"
         break;
       case 26: /* map ::= BRACKET_OPEN BRACKET_CLOSE */
-#line 619 "NCDConfigParser_parse.y"
+#line 612 "NCDConfigParser_parse.y"
 {
     yygotominor.yy27.have = 1;
     NCDValue_InitMap(&yygotominor.yy27.v);
   yy_destructor(yypParser,16,&yymsp[-1].minor);
   yy_destructor(yypParser,17,&yymsp[0].minor);
 }
-#line 1518 "NCDConfigParser_parse.c"
+#line 1511 "NCDConfigParser_parse.c"
         break;
       case 27: /* map ::= BRACKET_OPEN map_contents BRACKET_CLOSE */
-#line 624 "NCDConfigParser_parse.y"
+#line 617 "NCDConfigParser_parse.y"
 {
     yygotominor.yy27 = yymsp[-1].minor.yy27;
   yy_destructor(yypParser,16,&yymsp[-2].minor);
   yy_destructor(yypParser,17,&yymsp[0].minor);
 }
-#line 1527 "NCDConfigParser_parse.c"
+#line 1520 "NCDConfigParser_parse.c"
         break;
       case 28: /* value ::= STRING */
-#line 628 "NCDConfigParser_parse.y"
+#line 621 "NCDConfigParser_parse.y"
 {
     ASSERT(yymsp[0].minor.yy0.str)
 
@@ -1543,10 +1536,10 @@ failU0:
 doneU:
     free_token(yymsp[0].minor.yy0);
 }
-#line 1547 "NCDConfigParser_parse.c"
+#line 1540 "NCDConfigParser_parse.c"
         break;
       case 29: /* value ::= dotted_name */
-#line 645 "NCDConfigParser_parse.y"
+#line 638 "NCDConfigParser_parse.y"
 {
     if (!yymsp[0].minor.yy9) {
         goto failV0;
@@ -1565,30 +1558,30 @@ failV0:
 doneV:
     free(yymsp[0].minor.yy9);
 }
-#line 1569 "NCDConfigParser_parse.c"
+#line 1562 "NCDConfigParser_parse.c"
         break;
       case 32: /* name_maybe ::= */
-#line 672 "NCDConfigParser_parse.y"
+#line 665 "NCDConfigParser_parse.y"
 {
     yygotominor.yy9 = NULL;
 }
-#line 1576 "NCDConfigParser_parse.c"
+#line 1569 "NCDConfigParser_parse.c"
         break;
       case 34: /* process_or_template ::= PROCESS */
-#line 682 "NCDConfigParser_parse.y"
+#line 675 "NCDConfigParser_parse.y"
 {
     yygotominor.yy8 = 0;
   yy_destructor(yypParser,19,&yymsp[0].minor);
 }
-#line 1584 "NCDConfigParser_parse.c"
+#line 1577 "NCDConfigParser_parse.c"
         break;
       case 35: /* process_or_template ::= TEMPLATE */
-#line 686 "NCDConfigParser_parse.y"
+#line 679 "NCDConfigParser_parse.y"
 {
     yygotominor.yy8 = 1;
   yy_destructor(yypParser,20,&yymsp[0].minor);
 }
-#line 1592 "NCDConfigParser_parse.c"
+#line 1585 "NCDConfigParser_parse.c"
         break;
       default:
         break;
@@ -1653,7 +1646,7 @@ static void yy_syntax_error(
 #line 125 "NCDConfigParser_parse.y"
 
     parser_out->syntax_error = 1;
-#line 1657 "NCDConfigParser_parse.c"
+#line 1650 "NCDConfigParser_parse.c"
   ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
 }
 

generated/NCDConfigParser_parse.y

@@ -565,7 +565,7 @@ map_contents(R) ::= value(A) COLON value(B). {
 
     NCDValue_InitMap(&R.v);
 
-    if (!NCDValue_MapInsert(&R.v, A.v, B.v)) {
+    if (!NCDValue_MapPrepend(&R.v, A.v, B.v)) {
         goto failS1;
     }
     A.have = 0;
@@ -589,14 +589,7 @@ map_contents(R) ::= value(A) COLON value(B) COMMA map_contents(N). {
         goto failT0;
     }
 
-    if (NCDValue_MapFindKey(&N.v, &A.v)) {
-        BLog(BLOG_ERROR, "duplicate key in map");
-        R.have = 0;
-        parser_out->syntax_error = 1;
-        goto doneT;
-    }
-
-    if (!NCDValue_MapInsert(&N.v, A.v, B.v)) {
+    if (!NCDValue_MapPrepend(&N.v, A.v, B.v)) {
         goto failT0;
     }
     A.have = 0;

ncd/NCDAst.c

@@ -41,14 +41,11 @@ struct NCDValue__list_element {
 };
 
 struct NCDValue__map_element {
-    NCDValue__MapTreeNode tree_node;
+    LinkedList1Node list_node;
     NCDValue key;
     NCDValue val;
 };
 
-#include "NCDAst_maptree.h"
-#include <structure/SAvl_impl.h>
-
 static void value_assert (NCDValue *o)
 {
     switch (o->type) {
@@ -81,9 +78,11 @@ void NCDValue_Free (NCDValue *o)
         } break;
         
         case NCDVALUE_MAP: {
-            struct NCDValue__map_element *e;
-            while (e = NCDValue__MapTree_GetFirst(&o->map_tree, 0)) {
-                NCDValue__MapTree_Remove(&o->map_tree, 0, e);
+            LinkedList1Node *n;
+            while (n = LinkedList1_GetFirst(&o->map_list)) {
+                struct NCDValue__map_element *e = UPPER_OBJECT(n, struct NCDValue__map_element, list_node);
+                
+                LinkedList1_Remove(&o->map_list, &e->list_node);
                 NCDValue_Free(&e->key);
                 NCDValue_Free(&e->val);
                 free(e);
@@ -146,17 +145,24 @@ size_t NCDValue_StringLength (NCDValue *o)
 
 void NCDValue_InitList (NCDValue *o)
 {
+    o->type = NCDVALUE_LIST;
     LinkedList1_Init(&o->list);
     o->list_count = 0;
+}
+
+size_t NCDValue_ListCount (NCDValue *o)
+{
+    value_assert(o);
+    ASSERT(o->type == NCDVALUE_LIST)
     
-    o->type = NCDVALUE_LIST;
+    return o->list_count;
 }
 
 int NCDValue_ListAppend (NCDValue *o, NCDValue v)
 {
     value_assert(o);
-    value_assert(&v);
     ASSERT(o->type == NCDVALUE_LIST)
+    value_assert(&v);
     
     if (o->list_count == SIZE_MAX) {
         return 0;
@@ -167,9 +173,10 @@ int NCDValue_ListAppend (NCDValue *o, NCDValue v)
         return 0;
     }
     
+    e->v = v;
     LinkedList1_Append(&o->list, &e->list_node);
+    
     o->list_count++;
-    e->v = v;
     
     return 1;
 }
@@ -177,8 +184,8 @@ int NCDValue_ListAppend (NCDValue *o, NCDValue v)
 int NCDValue_ListPrepend (NCDValue *o, NCDValue v)
 {
     value_assert(o);
-    value_assert(&v);
     ASSERT(o->type == NCDVALUE_LIST)
+    value_assert(&v);
     
     if (o->list_count == SIZE_MAX) {
         return 0;
@@ -189,21 +196,14 @@ int NCDValue_ListPrepend (NCDValue *o, NCDValue v)
         return 0;
     }
     
+    e->v = v;
     LinkedList1_Prepend(&o->list, &e->list_node);
+    
     o->list_count++;
-    e->v = v;
     
     return 1;
 }
 
-size_t NCDValue_ListCount (NCDValue *o)
-{
-    value_assert(o);
-    ASSERT(o->type == NCDVALUE_LIST)
-    
-    return o->list_count;
-}
-
 NCDValue * NCDValue_ListFirst (NCDValue *o)
 {
     value_assert(o);
@@ -240,7 +240,7 @@ NCDValue * NCDValue_ListNext (NCDValue *o, NCDValue *ev)
 void NCDValue_InitMap (NCDValue *o)
 {
     o->type = NCDVALUE_MAP;
-    NCDValue__MapTree_Init(&o->map_tree);
+    LinkedList1_Init(&o->map_list);
     o->map_count = 0;
 }
 
@@ -252,97 +252,83 @@ size_t NCDValue_MapCount (NCDValue *o)
     return o->map_count;
 }
 
-NCDValue * NCDValue_MapFirstKey (NCDValue *o)
+NCDValue * NCDValue_MapPrepend (NCDValue *o, NCDValue key, NCDValue val)
 {
     value_assert(o);
     ASSERT(o->type == NCDVALUE_MAP)
+    value_assert(&key);
+    value_assert(&val);
     
-    struct NCDValue__map_element *e = NCDValue__MapTree_GetFirst(&o->map_tree, 0);
+    if (o->map_count == SIZE_MAX) {
+        return NULL;
+    }
+    
+    struct NCDValue__map_element *e = malloc(sizeof(*e));
     if (!e) {
         return NULL;
     }
     
-    value_assert(&e->key);
-    value_assert(&e->val);
+    e->key = key;
+    e->val = val;
+    LinkedList1_Prepend(&o->map_list, &e->list_node);
+    
+    o->map_count++;
     
     return &e->key;
 }
 
-NCDValue * NCDValue_MapNextKey (NCDValue *o, NCDValue *ekey)
+NCDValue * NCDValue_MapFirstKey (NCDValue *o)
 {
     value_assert(o);
     ASSERT(o->type == NCDVALUE_MAP)
     
-    struct NCDValue__map_element *e0 = UPPER_OBJECT(ekey, struct NCDValue__map_element, key);
-    value_assert(&e0->key);
-    value_assert(&e0->val);
+    LinkedList1Node *ln = LinkedList1_GetFirst(&o->map_list);
     
-    struct NCDValue__map_element *e = NCDValue__MapTree_GetNext(&o->map_tree, 0, e0);
-    if (!e) {
+    if (!ln) {
         return NULL;
     }
     
+    struct NCDValue__map_element *e = UPPER_OBJECT(ln, struct NCDValue__map_element, list_node);
+    
     value_assert(&e->key);
     value_assert(&e->val);
     
     return &e->key;
 }
 
-NCDValue * NCDValue_MapKeyValue (NCDValue *o, NCDValue *ekey)
+NCDValue * NCDValue_MapNextKey (NCDValue *o, NCDValue *ekey)
 {
     value_assert(o);
     ASSERT(o->type == NCDVALUE_MAP)
     
-    struct NCDValue__map_element *e = UPPER_OBJECT(ekey, struct NCDValue__map_element, key);
-    value_assert(&e->key);
-    value_assert(&e->val);
+    struct NCDValue__map_element *e0 = UPPER_OBJECT(ekey, struct NCDValue__map_element, key);
+    value_assert(&e0->key);
+    value_assert(&e0->val);
     
-    return &e->val;
-}
-
-NCDValue * NCDValue_MapFindKey (NCDValue *o, NCDValue *key)
-{
-    value_assert(o);
-    ASSERT(o->type == NCDVALUE_MAP)
-    value_assert(key);
+    LinkedList1Node *ln = LinkedList1Node_Next(&e0->list_node);
     
-    struct NCDValue__map_element *e = NCDValue__MapTree_LookupExact(&o->map_tree, 0, key);
-    if (!e) {
+    if (!ln) {
         return NULL;
     }
     
+    struct NCDValue__map_element *e = UPPER_OBJECT(ln, struct NCDValue__map_element, list_node);
+    
     value_assert(&e->key);
     value_assert(&e->val);
-    ASSERT(!NCDValue_Compare(&e->key, key))
     
     return &e->key;
 }
 
-NCDValue * NCDValue_MapInsert (NCDValue *o, NCDValue key, NCDValue val)
+NCDValue * NCDValue_MapKeyValue (NCDValue *o, NCDValue *ekey)
 {
     value_assert(o);
     ASSERT(o->type == NCDVALUE_MAP)
-    value_assert(&key);
-    value_assert(&val);
-    ASSERT(!NCDValue_MapFindKey(o, &key))
-    
-    if (o->map_count == SIZE_MAX) {
-        return NULL;
-    }
-    
-    struct NCDValue__map_element *e = malloc(sizeof(*e));
-    if (!e) {
-        return NULL;
-    }
-    
-    e->key = key;
-    e->val = val;
-    int res = NCDValue__MapTree_Insert(&o->map_tree, 0, e, NULL);
-    ASSERT_EXECUTE(res)
     
-    o->map_count++;
+    struct NCDValue__map_element *e = UPPER_OBJECT(ekey, struct NCDValue__map_element, key);
+    value_assert(&e->key);
+    value_assert(&e->val);
     
-    return &e->key;
+    return &e->val;
 }
 
 int NCDValue_InitVar (NCDValue *o, const char *var_name)

ncd/NCDAst.h

@@ -35,7 +35,6 @@
 
 #include <misc/debug.h>
 #include <structure/LinkedList1.h>
-#include <structure/SAvl.h>
 
 typedef struct NCDValue_s NCDValue;
 typedef struct NCDProgram_s NCDProgram;
@@ -45,12 +44,6 @@ typedef struct NCDStatement_s NCDStatement;
 typedef struct NCDIfBlock_s NCDIfBlock;
 typedef struct NCDIf_s NCDIf;
 
-struct NCDValue__map_element;
-typedef NCDValue *NCDValue__maptree_key;
-
-#include "NCDAst_maptree.h"
-#include <structure/SAvl_decl.h>
-
 struct NCDValue_s {
     int type;
     union {
@@ -63,7 +56,7 @@ struct NCDValue_s {
             size_t list_count;
         };
         struct {
-            NCDValue__MapTree map_tree;
+            LinkedList1 map_list;
             size_t map_count;
         };
         struct {
@@ -164,8 +157,7 @@ size_t NCDValue_MapCount (NCDValue *o);
 NCDValue * NCDValue_MapFirstKey (NCDValue *o);
 NCDValue * NCDValue_MapNextKey (NCDValue *o, NCDValue *ekey);
 NCDValue * NCDValue_MapKeyValue (NCDValue *o, NCDValue *ekey);
-NCDValue * NCDValue_MapFindKey (NCDValue *o, NCDValue *key);
-NCDValue * NCDValue_MapInsert (NCDValue *o, NCDValue key, NCDValue val) WARN_UNUSED;
+NCDValue * NCDValue_MapPrepend (NCDValue *o, NCDValue key, NCDValue val) WARN_UNUSED;
 int NCDValue_InitVar (NCDValue *o, const char *var_name) WARN_UNUSED;
 const char * NCDValue_VarName (NCDValue *o);
 int NCDValue_Compare (NCDValue *o, NCDValue *v);

ncd/NCDAst_maptree.h

@@ -1,9 +0,0 @@
-#define SAVL_PARAM_NAME NCDValue__MapTree
-#define SAVL_PARAM_FEATURE_COUNTS 0
-#define SAVL_PARAM_FEATURE_NOKEYS 0
-#define SAVL_PARAM_TYPE_ENTRY struct NCDValue__map_element
-#define SAVL_PARAM_TYPE_KEY NCDValue__maptree_key
-#define SAVL_PARAM_TYPE_ARG int
-#define SAVL_PARAM_FUN_COMPARE_ENTRIES(arg, entry1, entry2) NCDValue_Compare(&(entry1)->key, &(entry2)->key)
-#define SAVL_PARAM_FUN_COMPARE_KEY_ENTRY(arg, key1, entry2) NCDValue_Compare((key1), &(entry2)->key)
-#define SAVL_PARAM_MEMBER_NODE tree_node

ncd/NCDConfigParser_parse.y

@@ -565,7 +565,7 @@ map_contents(R) ::= value(A) COLON value(B). {
 
     NCDValue_InitMap(&R.v);
 
-    if (!NCDValue_MapInsert(&R.v, A.v, B.v)) {
+    if (!NCDValue_MapPrepend(&R.v, A.v, B.v)) {
         goto failS1;
     }
     A.have = 0;
@@ -589,14 +589,7 @@ map_contents(R) ::= value(A) COLON value(B) COMMA map_contents(N). {
         goto failT0;
     }
 
-    if (NCDValue_MapFindKey(&N.v, &A.v)) {
-        BLog(BLOG_ERROR, "duplicate key in map");
-        R.have = 0;
-        parser_out->syntax_error = 1;
-        goto doneT;
-    }
-
-    if (!NCDValue_MapInsert(&N.v, A.v, B.v)) {
+    if (!NCDValue_MapPrepend(&N.v, A.v, B.v)) {
         goto failT0;
     }
     A.have = 0;

ncd/NCDInterpProcess.c

@@ -117,8 +117,10 @@ static int convert_value_recurser (NCDPlaceholderDb *pdb, NCDValue *value, NCDVa
                     goto fail;
                 }
                 
-                int res = NCDVal_MapInsert(*out, vkey, vval);
-                ASSERT_EXECUTE(res) // we assume different variables get different placeholder ids
+                if (!NCDVal_MapInsert(*out, vkey, vval)) {
+                    BLog(BLOG_ERROR, "duplicate key in map");
+                    goto fail;
+                }
             }
         } break;