Changeset 561


Ignore:
Timestamp:
Apr 30, 2011, 12:24:57 AM (6 years ago)
Author:
sam
Message:

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

Location:
abuse/trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/game.cpp

    r560 r561  
    26362636        timer_uninit();
    26372637
    2638     l_user_stack.clean_up();
    2639     // FIXME: this is now private in PtrRef::stack
    2640     //l_ptr_stack.clean_up();
    2641 
    26422638    sound_uninit();
    26432639
  • abuse/trunk/src/lisp/lisp.cpp

    r560 r561  
    8686{
    8787    dprintf("Main program\n");
    88     if (max_lev==-1) max_lev=PtrRef::stack.son;
    89     else if (max_lev>=PtrRef::stack.son) max_lev=PtrRef::stack.son-1;
    90 
    91     for (int i=0; i<max_lev; i++)
     88    if (max_lev == -1)
     89        max_lev = PtrRef::stack.m_size;
     90    else if (max_lev >= (int)PtrRef::stack.m_size)
     91        max_lev = PtrRef::stack.m_size - 1;
     92
     93    for (int i = 0; i < max_lev; i++)
    9294    {
    9395        dprintf("%d> ", i);
     
    15651567  void **arg_on=(void **)malloc(sizeof(void *)*num_args);
    15661568  LList *list_on=(LList *)CDR(arg_list);
    1567   long old_ptr_son=PtrRef::stack.son;
     1569  long old_ptr_son=PtrRef::stack.m_size;
    15681570
    15691571  for (i=0; i<num_args; i++)
     
    16191621  }
    16201622  while (!stop);
    1621   PtrRef::stack.son=old_ptr_son;
     1623  PtrRef::stack.m_size=old_ptr_son;
    16221624
    16231625  free(arg_on);
     
    16401642    {
    16411643      void **str_eval=(void **)malloc(elements*sizeof(void *));
    1642       int i, old_ptr_stack_start=PtrRef::stack.son;
     1644      int i, old_ptr_stack_start=PtrRef::stack.m_size;
    16431645
    16441646      // evalaute all the strings and count their lengths
     
    17021704      }
    17031705      free(str_eval);
    1704       PtrRef::stack.son=old_ptr_stack_start;   // restore pointer GC stack
     1706      PtrRef::stack.m_size=old_ptr_stack_start;   // restore pointer GC stack
    17051707      *s=0;
    17061708      ret=st;
     
    20812083        LObject *block_list = CDR(arg_list);
    20822084        PtrRef r1(block_list), r2(var_list);
    2083         long stack_start = l_user_stack.son;
     2085        long stack_start = l_user_stack.m_size;
    20842086
    20852087        while (var_list)
     
    21172119            var_list = CDR(var_list);
    21182120        }
    2119         l_user_stack.son = stack_start; // restore the stack
     2121        l_user_stack.m_size = stack_start; // restore the stack
    21202122        break;
    21212123    }
     
    27682770        LObject *init_var = CAR(arg_list);
    27692771        PtrRef r1(init_var);
    2770         int ustack_start = l_user_stack.son; // restore stack at end
     2772        int ustack_start = l_user_stack.m_size; // restore stack at end
    27712773        LSymbol *sym = NULL;
    27722774        PtrRef r2(sym);
     
    27842786        }
    27852787
    2786         void **do_evaled = l_user_stack.sdata + l_user_stack.son;
     2788        void **do_evaled = l_user_stack.sdata + l_user_stack.m_size;
    27872789        // push all of the init forms, so we can set the symbol
    27882790        for (init_var = CAR(arg_list); init_var; init_var = CDR(init_var))
     
    28192821        }
    28202822
    2821         l_user_stack.son = ustack_start;
     2823        l_user_stack.m_size = ustack_start;
    28222824        break;
    28232825    }
     
    30103012
    30113013    // mark the start start, so we can restore when done
    3012     long stack_start = l_user_stack.son;
     3014    long stack_start = l_user_stack.m_size;
    30133015
    30143016    // first push all of the old symbol values
     
    30253027    // open block so that local vars aren't saved on the stack
    30263028    {
    3027         int new_start = l_user_stack.son;
     3029        int new_start = l_user_stack.m_size;
    30283030        int i = new_start;
    30293031        // now push all the values we wish to gather
     
    30443046            ((LSymbol *)CAR(f_arg))->SetValue((LObject *)l_user_stack.sdata[i++]);
    30453047
    3046         l_user_stack.son = new_start;
     3048        l_user_stack.m_size = new_start;
    30473049    }
    30483050
     
    30653067        ((LSymbol *)CAR(f_arg))->SetValue((LObject *)l_user_stack.sdata[cur_stack++]);
    30663068
    3067     l_user_stack.son = stack_start;
     3069    l_user_stack.m_size = stack_start;
    30683070
    30693071#ifdef L_PROFILE
     
    30883090            dprintf("%d (%d, %d, %d) TRACE : ", trace_level,
    30893091                    get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
    3090                     PtrRef::stack.son);
     3092                    PtrRef::stack.m_size);
    30913093            Print();
    30923094            dprintf("\n");
     
    31373139            dprintf("%d (%d, %d, %d) TRACE ==> ", trace_level,
    31383140                    get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
    3139                     PtrRef::stack.son);
     3141                    PtrRef::stack.m_size);
    31403142        ret->Print();
    31413143        dprintf("\n");
  • abuse/trunk/src/lisp/lisp_gc.cpp

    r558 r561  
    3131
    3232// Stack where user programs can push data and have it GCed
    33 grow_stack<void> l_user_stack(150);
     33GrowStack<void> l_user_stack(150);
    3434
    3535// Stack of user pointers
    36 grow_stack<void *> PtrRef::stack(1500);
     36GrowStack<void *> PtrRef::stack(1500);
    3737
    3838static size_t reg_ptr_total = 0;
     
    187187void LispGC::CollectStacks()
    188188{
    189     size_t t = l_user_stack.son;
    190 
    191189    void **d = l_user_stack.sdata;
    192     for (size_t i = 0; i < t; i++, d++)
     190    for (size_t i = 0; i < l_user_stack.m_size; i++, d++)
    193191        *d = CollectObject((LObject *)*d);
    194192
    195     t = PtrRef::stack.son;
    196193    void ***d2 = PtrRef::stack.sdata;
    197     for (size_t i = 0; i < t; i++, d2++)
     194    for (size_t i = 0; i < PtrRef::stack.m_size; i++, d2++)
    198195    {
    199196        void **ptr = *d2;
     
    201198    }
    202199
    203     d2 = reg_ptr_list;
    204     for (size_t i = 0; i < reg_ptr_total; i++, d2++)
    205     {
    206         void **ptr = *d2;
     200    void ***d3 = reg_ptr_list;
     201    for (size_t i = 0; i < reg_ptr_total; i++, d3++)
     202    {
     203        void **ptr = *d3;
    207204        *ptr = CollectObject((LObject *)*ptr);
    208205    }
  • abuse/trunk/src/lisp/lisp_gc.h

    r558 r561  
    1414
    1515// Stack user progs can push data and have it GCed
    16 extern grow_stack<void> l_user_stack;
     16extern GrowStack<void> l_user_stack;
    1717
    1818class LispGC
     
    5252
    5353    // Stack of user pointers, user pointers get remapped on GC
    54     static grow_stack<void *> stack;
     54    static GrowStack<void *> stack;
    5555};
    5656
  • abuse/trunk/src/lisp/stack.h

    r555 r561  
    1616
    1717// A fixed-size stack class
    18 template<class T> class grow_stack
     18template<class T> class GrowStack
    1919{
    2020public:
    21     T **sdata;
    22     long son;
     21    GrowStack(int max_size)
     22    {
     23        m_max_size = max_size;
     24        m_size = 0;
     25        sdata = (T **)malloc(sizeof(T *) * m_max_size);
     26    }
    2327
    24 private:
    25     long smax;
    26 
    27 public:
    28     grow_stack(int max_size)
     28    ~GrowStack()
    2929    {
    30         smax = max_size;
    31         son = 0;
    32         sdata = (T **)malloc(sizeof(T *) * smax);
     30        if (m_size != 0)
     31            fprintf(stderr, "warning: cleaning up nonempty stack\n");
     32        free(sdata);
    3333    }
    3434
    3535    void push(T *data)
    3636    {
    37         if(son >= smax)
     37        if (m_size >= m_max_size)
    3838        {
    39             lbreak("error: stack overflow (%ld >= %ld)\n", son, smax);
     39            lbreak("error: stack overflow (%d >= %d)\n",
     40                   (int)m_size, (int)m_max_size);
    4041            exit(1);
    4142        }
    42         sdata[son] = data;
    43         son++;
     43        sdata[m_size] = data;
     44        m_size++;
    4445    }
    4546
    46     T *pop(long total)
     47    T *pop(size_t total)
    4748    {
    48         if (total > son)
     49        if (total > m_size)
    4950        {
    5051            lbreak("error: stack underflow\n");
    5152            exit(1);
    5253        }
    53         son -= total;
    54         return sdata[son];
     54        m_size -= total;
     55        return sdata[m_size];
    5556    }
    5657
    57     void clean_up()
    58     {
    59         if(son != 0)
    60             fprintf(stderr, "warning: cleaning up stack and not empty\n");
    61         free(sdata);
    62         sdata = NULL;
    63         son = 0;
    64     }
     58public:
     59    T **sdata;
     60    size_t m_size;
     61
     62private:
     63    size_t m_max_size;
    6564};
    6665
    6766#endif
     67
Note: See TracChangeset for help on using the changeset viewer.