Implement again the traversal used in cljib.c for the strintifying process

Author: constarg

src/cjlib.c

@@ -812,7 +812,7 @@ static char *simple_key_value_paired_stringtify
  */
 static inline int switch_from_incomplete_obj_str_data
 (struct incomplete_property_str *restrict dst, enum cjlib_json_datatypes type, 
- cjlib_json_object *entry, bool init)
+ cjlib_json_object *entry)
 {
     struct cjlib_json_data *examine_entry_data = CJLIB_DICT_NODE_DATA(entry);
     *dst = (struct incomplete_property_str) {
@@ -826,12 +826,8 @@ static inline int switch_from_incomplete_obj_str_data
 
     cjlib_queue_init(dst->i_pending_data_q);
 
-    if (init) {
-        if (CJLIB_OBJECT == type) dst->i_data.object = entry;
-    } else {
-        if (CJLIB_OBJECT == type) dst->i_data.object = examine_entry_data->c_value.c_obj;
-        else dst->i_data.array = examine_entry_data->c_value.c_arr;
-    }
+    if (CJLIB_OBJECT == type) dst->i_data.object = entry;
+    else dst->i_data.array = examine_entry_data->c_value.c_arr;
 
     return 0;
 }
@@ -899,9 +895,9 @@ const char *cjlib_json_object_stringtify(const cjlib_json_object *src)
     incomplete_property_str_init(&curr_incomp);
     cjlib_stack_init(&incomplete_st);
 
-    if (-1 == switch_from_incomplete_obj_str_data(&curr_incomp, CJLIB_OBJECT, (cjlib_json_object *) src, true)) return NULL;
+    if (-1 == switch_from_incomplete_obj_str_data(&curr_incomp, CJLIB_OBJECT, (cjlib_json_object *) src)) return NULL;
 
-    if (-1 == cjlib_dict_postorder(curr_incomp.i_pending_data_q, curr_incomp.i_data.object)) return NULL;
+    if (-1 == cjlib_dict_preorder(curr_incomp.i_pending_data_q, curr_incomp.i_data.object)) return NULL;
 
     // Put a dummy entry in the stack to start the process.
     if (-1 == cjlib_stack_push((void *) &curr_incomp, sizeof(struct incomplete_property_str), 
@@ -944,25 +940,10 @@ const char *cjlib_json_object_stringtify(const cjlib_json_object *src)
                     cjlib_stack_push(&curr_incomp, sizeof(struct incomplete_property_str), 
                                      &incomplete_st);
 
-                    /**
-                     * (gdb) print(*examine_entry_data)
-                       $23 = {c_value = {c_str = 0x40a640 "\200\231@", c_num = 2.0932889485015272e-317, c_boolean = 64, c_obj = 0x40a640, 
-                       c_null = 0x40a640, c_arr = 0x40a640}, c_datatype = CJLIB_OBJECT}
-                        
-                       (gdb) print(*examine_entry_data.c_value.c_obj)
-                       $24 = {avl_data = 0x409980, avl_key = 0x4098c0 "request", avl_left = 0x409dd0, avl_right = 0x409c90}
-                       (gdb) n
-                       cjlib_stack_push(&curr_incomp, sizeof(struct incomplete_property_str), 
-                       (gdb) n
-                       <----- HERE IS THE BUG ----- > TODO - When switching from array, DO NOT pass the examine entry.
-                       if (-1 == switch_from_incomplete_obj_str_data(&curr_incomp, CJLIB_OBJECT, examine_entry, false)) return NULL;
-                       (gdb) 
-                         if (-1 == cjlib_dict_postorder(curr_incomp.i_pending_data_q, curr_incomp.i_data.object)) return NULL;
-                   */
-
-                    if (-1 == switch_from_incomplete_obj_str_data(&curr_incomp, CJLIB_OBJECT, examine_entry, false)) return NULL;
+		            if (CJLIB_ARRAY == curr_incomp.i_type) examine_entry = examine_entry_data->c_value.c_obj;
+                    if (-1 == switch_from_incomplete_obj_str_data(&curr_incomp, CJLIB_OBJECT, examine_entry)) return NULL;
 
-                    if (-1 == cjlib_dict_postorder(curr_incomp.i_pending_data_q, curr_incomp.i_data.object)) return NULL;
+                    if (-1 == cjlib_dict_preorder(curr_incomp.i_pending_data_q, curr_incomp.i_data.object)) return NULL;
                     break;
                 case CJLIB_ARRAY:
                     cjlib_stack_push(&curr_incomp, sizeof(struct incomplete_property_str), &incomplete_st);
@@ -999,6 +980,7 @@ const char *cjlib_json_object_stringtify(const cjlib_json_object *src)
     } 
 
     free(curr_incomp.i_key);
+
     // Return the now completed JSON.
     return curr_incomp.i_state;
 }

src/cjlib_dictionary.c

@@ -32,6 +32,7 @@
 #include "cjlib_dictionary.h"
 #include "cjlib.h"
 #include "cjlib_queue.h"
+#include "cjlib_stack.h"
 
 // Those constants are used in the search/insert/delete functions.
 #define S_RETRIEVE_KEY_NODE        (0x0)
@@ -99,37 +100,44 @@ enum rotation_after_left_deletion_type
 /**
  * Set every node of a AVL tree into a QEUEUE
  */
-int cjlib_dict_postorder(struct cjlib_queue *restrict dst, const struct avl_bs_tree_node *src)
+int cjlib_dict_preorder(struct cjlib_queue *restrict dst, const struct avl_bs_tree_node *src)
 {
-    struct cjlib_queue post_order_node_q; // The queue used for the post order traversal.
-    struct cjlib_queue post_order_data_q; 
-    cjlib_queue_init(&post_order_node_q);
-    cjlib_queue_init(&post_order_data_q);
+    struct cjlib_stack pre_order_traversal_st; // The stack used for the preorder traversal.
+    struct cjlib_queue pre_order_data_q; 
+    cjlib_stack_init(&pre_order_traversal_st);
+    cjlib_queue_init(&pre_order_data_q);
 
     struct avl_bs_tree_node *root = (struct avl_bs_tree_node *) src; // Set the root of the whole tree in the local variable.
 
+    // 1. PROCESS ROOT -> 2. VISIT LEFT SUBTREE -> 3. VISIT RIGHT SUBTREE -> GO TO (1.)
     do {
         if (NULL != root) {
-            if (-1 == cjlib_queue_enqeue((void *) &root, sizeof(struct cjlib_json_data *), &post_order_data_q)) return -1;
-        }
-        
-        if (NULL != root && NULL != root->avl_left) {
-            if (-1 == cjlib_queue_enqeue((void *) &root, sizeof(struct avl_bs_tree_node *), &post_order_node_q)) return -1;
-        }
-
-        if (NULL != root->avl_right) {
-            if (-1 == cjlib_queue_enqeue((void *) &root->avl_right, sizeof(struct avl_bs_tree_node *), &post_order_node_q)) return -1;
+            // Process the current Root before left or right sub tree.
+            // 1. Process.
+            if (-1 == cjlib_queue_enqeue(&root, sizeof(struct avl_bs_tree_node *), &pre_order_data_q)) return -1;
         }
 
-        if (NULL != root->avl_left) {
-            root = src->avl_left;
+        // Check the next node to process is available.
+        if (NULL == root) {
+            // Check if this is the last node.
+            if (cjlib_stack_is_empty(&pre_order_traversal_st)) break;
+
+            // Reached a leaf (either left or right), go to the parent node.
+            // 3. VISIT RIGHT SUBTREE.
+            if (-1 == cjlib_stack_pop(&root, sizeof(struct avl_bs_tree_node *), &pre_order_traversal_st)) return -1;
+            
+            // After reaching a left leaf, then go to the right subtree of the leaf's parent.
+            root = root->avl_right;
         } else {
-            cjlib_queue_deqeue(&root, sizeof(struct avl_bs_tree_node *), &post_order_node_q);
-            break;
+            // 2. VISIT LEFT SUBTREE.
+            if (-1 == cjlib_stack_push(&root, sizeof(struct avl_bs_tree_node *), &pre_order_traversal_st)) return -1;
+            // Proceed to the next left tree, untill reaching a leaf (next left is null).
+            root = root->avl_left;
         }
-    } while(!cjlib_queue_is_empty(&post_order_node_q));
+        
+    } while(!cjlib_stack_is_empty(&pre_order_traversal_st));
 
-    (void) memcpy(dst, &post_order_data_q, sizeof(struct cjlib_queue));
+    (void) memcpy(dst, &pre_order_data_q, sizeof(struct cjlib_stack));
 
     return 0;
 }

src/include/cjlib_dictionary.h

@@ -72,14 +72,14 @@ static inline cjlib_dict_t *cjlib_make_dict(void)
 }
 
 /**
- * Travel through the whole tree using the POST-ORDER method. This function builds a 
+ * Travel through the whole tree using the PRE-ORDER method. This function builds a 
  * queue that consists of all the available nodes in the dictionary of interest. 
  *
  * @param dst A pointer pointing to the memory where the built queue is stored.
  * @param src A pointer to the dictionary (or object) of interest.
  * @return -1 in case an error occur, otherwise -1.
 */
-extern int cjlib_dict_postorder(struct cjlib_queue *restrict dst, const cjlib_dict_t *src);
+extern int cjlib_dict_preorder(struct cjlib_queue *restrict dst, const cjlib_dict_t *src);
 
 /**
  * Searches for an element in a dictionary based on its associated key.