From a58a8bb7b51e62b107a7c1df78c9a157a4f74226 Mon Sep 17 00:00:00 2001
From: Abhishek Sagar <sachinites@gmail.com>
Date: Mon, 26 Oct 2020 01:00:47 -0700
Subject: [PATCH] fix in glthread library

---
 gluethread/glthread.c | 67 ++++++++++++++++++++++++-------------------
 gluethread/glthread.h |  4 ++-
 2 files changed, 41 insertions(+), 30 deletions(-)

diff --git a/gluethread/glthread.c b/gluethread/glthread.c
index 97b9f7c..8138e6d 100644
--- a/gluethread/glthread.c
+++ b/gluethread/glthread.c
@@ -98,46 +98,46 @@ remove_glthread(glthread_t *curr_glthread){
 }
 
 void
-delete_glthread_list(glthread_t *base_glthread){
+delete_glthread_list(glthread_t *glthread_head){
 
     glthread_t *glthreadptr = NULL;
                
-    ITERATE_GLTHREAD_BEGIN(base_glthread, glthreadptr){
+    ITERATE_GLTHREAD_BEGIN(glthread_head, glthreadptr){
         remove_glthread(glthreadptr);
-    } ITERATE_GLTHREAD_END(base_glthread, glthreadptr);
+    } ITERATE_GLTHREAD_END(glthread_head, glthreadptr);
 }
 
 void
-glthread_add_last(glthread_t *base_glthread, glthread_t *new_glthread){
+glthread_add_last(glthread_t *glthread_head, glthread_t *new_glthread){
 
     glthread_t *glthreadptr = NULL,
                *prevglthreadptr = NULL;
     
-    ITERATE_GLTHREAD_BEGIN(base_glthread, glthreadptr){
+    ITERATE_GLTHREAD_BEGIN(glthread_head, glthreadptr){
         prevglthreadptr = glthreadptr;
-    } ITERATE_GLTHREAD_END(base_glthread, glthreadptr);
+    } ITERATE_GLTHREAD_END(glthread_head, glthreadptr);
   
     if(prevglthreadptr) 
         glthread_add_next(prevglthreadptr, new_glthread); 
     else
-        glthread_add_next(base_glthread, new_glthread);
+        glthread_add_next(glthread_head, new_glthread);
 }
 
 unsigned int
-get_glthread_list_count(glthread_t *base_glthread){
+get_glthread_list_count(glthread_t *glthread_head){
 
     unsigned int count = 0;
     glthread_t *glthreadptr = NULL;
 
-    ITERATE_GLTHREAD_BEGIN(base_glthread, glthreadptr){
+    ITERATE_GLTHREAD_BEGIN(glthread_head, glthreadptr){
         count++;
-    } ITERATE_GLTHREAD_END(base_glthread, glthreadptr);
+    } ITERATE_GLTHREAD_END(glthread_head, glthreadptr);
     return count;
 }
 
 
 void
-glthread_priority_insert(glthread_t *base_glthread, 
+glthread_priority_insert(glthread_t *glthread_head, 
                          glthread_t *glthread,
                          int (*comp_fn)(void *, void *),
                          int offset){
@@ -148,30 +148,24 @@ glthread_priority_insert(glthread_t *base_glthread,
 
     init_glthread(glthread);
 
-    if(IS_GLTHREAD_LIST_EMPTY(base_glthread)){
-        glthread_add_next(base_glthread, glthread);
+    if(IS_GLTHREAD_LIST_EMPTY(glthread_head)){
+        glthread_add_next(glthread_head, glthread);
         return;
     }
 
     /* Only one node*/
-    if(base_glthread->right && !base_glthread->right->right){
-        if(comp_fn(GLTHREAD_GET_USER_DATA_FROM_OFFSET(base_glthread->right, offset), 
-                GLTHREAD_GET_USER_DATA_FROM_OFFSET(glthread, offset)) == -1){
-            glthread_add_next(base_glthread->right, glthread);
+    if(glthread_head->right && !glthread_head->right->right){
+        if(comp_fn(GLTHREAD_GET_USER_DATA_FROM_OFFSET(glthread, offset),
+            GLTHREAD_GET_USER_DATA_FROM_OFFSET(glthread_head->right, offset)) == -1){
+            glthread_add_next(glthread_head, glthread);
         }
         else{
-            glthread_add_next(base_glthread, glthread);
+            glthread_add_next(glthread_head->right, glthread);
         }
         return;
     }
 
-    if(comp_fn(GLTHREAD_GET_USER_DATA_FROM_OFFSET(glthread, offset), 
-            GLTHREAD_GET_USER_DATA_FROM_OFFSET(base_glthread->right, offset)) == -1){
-        glthread_add_next(base_glthread, glthread);
-        return;
-    }
-
-    ITERATE_GLTHREAD_BEGIN(base_glthread, curr){
+    ITERATE_GLTHREAD_BEGIN(glthread_head, curr){
 
         if(comp_fn(GLTHREAD_GET_USER_DATA_FROM_OFFSET(glthread, offset), 
                 GLTHREAD_GET_USER_DATA_FROM_OFFSET(curr, offset)) != -1){
@@ -179,18 +173,33 @@ glthread_priority_insert(glthread_t *base_glthread,
             continue;
         }
 
-        glthread_add_next(curr, glthread);
-        return;
+		if(!prev)
+			glthread_add_next(glthread_head, glthread);
+		else
+			glthread_add_next(prev, glthread);
 
-    }ITERATE_GLTHREAD_END(base_glthread, curr);
+		return;
+
+    }ITERATE_GLTHREAD_END(glthread_head, curr);
 
     /*Add in the end*/
     glthread_add_next(prev, glthread);
 } 
 
+glthread_t *
+dequeue_glthread_first(glthread_t *base_glthread){
+
+    glthread_t *temp;
+    if(!base_glthread->right)
+        return NULL;
+    temp = base_glthread->right;
+    remove_glthread(temp);
+    return temp;
+}
+
 #if 0
 void *
-gl_thread_search(glthread_t *base_glthread, 
+gl_thread_search(glthread_t *glthread_head, 
                  void *(*thread_to_struct_fn)(glthread_t *), 
                  void *key, 
                  int (*comparison_fn)(void *, void *)){
diff --git a/gluethread/glthread.h b/gluethread/glthread.h
index 8b87d14..01a0343 100644
--- a/gluethread/glthread.h
+++ b/gluethread/glthread.h
@@ -57,7 +57,7 @@ glthread_add_last(glthread_t *base_glthread, glthread_t *new_glthread);
 #define IS_GLTHREAD_LIST_EMPTY(glthreadptr)         \
     ((glthreadptr)->right == 0 && (glthreadptr)->left == 0)
 
-#define GLTHREAD_TO_STRUCT(fn_name, structure_name, field_name, glthreadptr)           \
+#define GLTHREAD_TO_STRUCT(fn_name, structure_name, field_name)                        \
     static inline structure_name * fn_name(glthread_t *glthreadptr){                   \
         return (structure_name *)((char *)(glthreadptr) - (char *)&(((structure_name *)0)->field_name)); \
     }
@@ -92,6 +92,8 @@ glthread_priority_insert(glthread_t *base_glthread,
                          int (*comp_fn)(void *, void *),
                          int offset);
 
+glthread_t *
+dequeue_glthread_first(glthread_t *base_glthread);
 
 #if 0
 void *