Changeset 561Tweet

Timestamp:

Apr 30, 2011, 12:24:57 AM (12 years ago)

Author:

Sam Hocevar

Message:

lisp: fix a memory leak in the grow stack objets and refactor the class.

Location:

abuse/trunk/src

Files:

• game.cpp (modified) (1 diff)
• lisp/lisp.cpp (modified) (16 diffs)
• lisp/lisp_gc.cpp (modified) (3 diffs)
• lisp/lisp_gc.h (modified) (2 diffs)
• lisp/stack.h (modified) (1 diff)

abuse/trunk/src/game.cpp

@@ -2636 +2636 @@
         timer_uninit();
 
-    l_user_stack.clean_up();
-    // FIXME: this is now private in PtrRef::stack
-    //l_ptr_stack.clean_up();
-
     sound_uninit();
 

abuse/trunk/src/lisp/lisp.cpp

@@ -86 +86 @@
 {
     dprintf("Main program\n");
-    if (max_lev==-1) max_lev=PtrRef::stack.son;
-    else if (max_lev>=PtrRef::stack.son) max_lev=PtrRef::stack.son-1;
-
-    for (int i=0; i<max_lev; i++)
+    if (max_lev == -1)
+        max_lev = PtrRef::stack.m_size;
+    else if (max_lev >= (int)PtrRef::stack.m_size)
+        max_lev = PtrRef::stack.m_size - 1;
+
+    for (int i = 0; i < max_lev; i++)
     {
         dprintf("%d> ", i);
@@ -1565 +1567 @@
   void **arg_on=(void **)malloc(sizeof(void *)*num_args);
   LList *list_on=(LList *)CDR(arg_list);
-  long old_ptr_son=PtrRef::stack.son;
+  long old_ptr_son=PtrRef::stack.m_size;
 
   for (i=0; i<num_args; i++)
@@ -1619 +1621 @@
   }
   while (!stop);
-  PtrRef::stack.son=old_ptr_son;
+  PtrRef::stack.m_size=old_ptr_son;
 
   free(arg_on);
@@ -1640 +1642 @@
     {
       void **str_eval=(void **)malloc(elements*sizeof(void *));
-      int i, old_ptr_stack_start=PtrRef::stack.son;
+      int i, old_ptr_stack_start=PtrRef::stack.m_size;
 
       // evalaute all the strings and count their lengths
@@ -1702 +1704 @@
       }
       free(str_eval);
-      PtrRef::stack.son=old_ptr_stack_start;   // restore pointer GC stack
+      PtrRef::stack.m_size=old_ptr_stack_start;   // restore pointer GC stack
       *s=0;
       ret=st;
@@ -2081 +2083 @@
         LObject *block_list = CDR(arg_list);
         PtrRef r1(block_list), r2(var_list);
-        long stack_start = l_user_stack.son;
+        long stack_start = l_user_stack.m_size;
 
         while (var_list)
@@ -2117 +2119 @@
             var_list = CDR(var_list);
         }
-        l_user_stack.son = stack_start; // restore the stack
+        l_user_stack.m_size = stack_start; // restore the stack
         break;
     }
@@ -2768 +2770 @@
         LObject *init_var = CAR(arg_list);
         PtrRef r1(init_var);
-        int ustack_start = l_user_stack.son; // restore stack at end
+        int ustack_start = l_user_stack.m_size; // restore stack at end
         LSymbol *sym = NULL;
         PtrRef r2(sym);
@@ -2784 +2786 @@
         }
 
-        void **do_evaled = l_user_stack.sdata + l_user_stack.son;
+        void **do_evaled = l_user_stack.sdata + l_user_stack.m_size;
         // push all of the init forms, so we can set the symbol
         for (init_var = CAR(arg_list); init_var; init_var = CDR(init_var))
@@ -2819 +2821 @@
         }
 
-        l_user_stack.son = ustack_start;
+        l_user_stack.m_size = ustack_start;
         break;
     }
@@ -3010 +3012 @@
 
     // mark the start start, so we can restore when done
-    long stack_start = l_user_stack.son;
+    long stack_start = l_user_stack.m_size;
 
     // first push all of the old symbol values
@@ -3025 +3027 @@
     // open block so that local vars aren't saved on the stack
     {
-        int new_start = l_user_stack.son;
+        int new_start = l_user_stack.m_size;
         int i = new_start;
         // now push all the values we wish to gather
@@ -3044 +3046 @@
             ((LSymbol *)CAR(f_arg))->SetValue((LObject *)l_user_stack.sdata[i++]);
 
-        l_user_stack.son = new_start;
+        l_user_stack.m_size = new_start;
     }
 
@@ -3065 +3067 @@
         ((LSymbol *)CAR(f_arg))->SetValue((LObject *)l_user_stack.sdata[cur_stack++]);
 
-    l_user_stack.son = stack_start;
+    l_user_stack.m_size = stack_start;
 
 #ifdef L_PROFILE
@@ -3088 +3090 @@
             dprintf("%d (%d, %d, %d) TRACE : ", trace_level,
                     get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
-                    PtrRef::stack.son);
+                    PtrRef::stack.m_size);
             Print();
             dprintf("\n");
@@ -3137 +3139 @@
             dprintf("%d (%d, %d, %d) TRACE ==> ", trace_level,
                     get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
-                    PtrRef::stack.son);
+                    PtrRef::stack.m_size);
         ret->Print();
         dprintf("\n");

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -31 +31 @@
 
 // Stack where user programs can push data and have it GCed
-grow_stack<void> l_user_stack(150);
+GrowStack<void> l_user_stack(150);
 
 // Stack of user pointers
-grow_stack<void *> PtrRef::stack(1500);
+GrowStack<void *> PtrRef::stack(1500);
 
 static size_t reg_ptr_total = 0;
@@ -187 +187 @@
 void LispGC::CollectStacks()
 {
-    size_t t = l_user_stack.son;
-
     void **d = l_user_stack.sdata;
-    for (size_t i = 0; i < t; i++, d++)
+    for (size_t i = 0; i < l_user_stack.m_size; i++, d++)
         *d = CollectObject((LObject *)*d);
 
-    t = PtrRef::stack.son;
     void ***d2 = PtrRef::stack.sdata;
-    for (size_t i = 0; i < t; i++, d2++)
+    for (size_t i = 0; i < PtrRef::stack.m_size; i++, d2++)
     {
         void **ptr = *d2;
@@ -201 +198 @@
     }
 
-    d2 = reg_ptr_list;
-    for (size_t i = 0; i < reg_ptr_total; i++, d2++)
-    {
-        void **ptr = *d2;
+    void ***d3 = reg_ptr_list;
+    for (size_t i = 0; i < reg_ptr_total; i++, d3++)
+    {
+        void **ptr = *d3;
         *ptr = CollectObject((LObject *)*ptr);
     }

abuse/trunk/src/lisp/lisp_gc.h

@@ -14 +14 @@
 
 // Stack user progs can push data and have it GCed
-extern grow_stack<void> l_user_stack;
+extern GrowStack<void> l_user_stack;
 
 class LispGC
@@ -52 +52 @@
 
     // Stack of user pointers, user pointers get remapped on GC
-    static grow_stack<void *> stack;
+    static GrowStack<void *> stack;
 };
 

abuse/trunk/src/lisp/stack.h

@@ -16 +16 @@
 
 // A fixed-size stack class
-template<class T> class grow_stack
+template<class T> class GrowStack
 {
 public:
-    T **sdata;
-    long son;
+    GrowStack(int max_size)
+    {
+        m_max_size = max_size;
+        m_size = 0;
+        sdata = (T **)malloc(sizeof(T *) * m_max_size);
+    }
 
-private:
-    long smax;
-
-public:
-    grow_stack(int max_size)
+    ~GrowStack()
     {
-        smax = max_size;
-        son = 0;
-        sdata = (T **)malloc(sizeof(T *) * smax);
+        if (m_size != 0)
+            fprintf(stderr, "warning: cleaning up nonempty stack\n");
+        free(sdata);
     }
 
     void push(T *data)
     {
-        if(son >= smax)
+        if (m_size >= m_max_size)
         {
-            lbreak("error: stack overflow (%ld >= %ld)\n", son, smax);
+            lbreak("error: stack overflow (%d >= %d)\n",
+                   (int)m_size, (int)m_max_size);
             exit(1);
         }
-        sdata[son] = data;
-        son++;
+        sdata[m_size] = data;
+        m_size++;
     }
 
-    T *pop(long total)
+    T *pop(size_t total)
     {
-        if (total > son)
+        if (total > m_size)
         {
             lbreak("error: stack underflow\n");
             exit(1);
         }
-        son -= total;
-        return sdata[son];
+        m_size -= total;
+        return sdata[m_size];
     }
 
-    void clean_up()
-    {
-        if(son != 0)
-            fprintf(stderr, "warning: cleaning up stack and not empty\n");
-        free(sdata);
-        sdata = NULL;
-        son = 0;
-    }
+public:
+    T **sdata;
+    size_t m_size;
+
+private:
+    size_t m_max_size;
 };
 
 #endif
+