Changeset 635Tweet

Timestamp:

May 11, 2011, 1:26:11 AM (11 years ago)

Author:

Sam Hocevar

Message:

lisp: refactor Lisp spaces so that they are real objects, and get rid
of the unused USER_SPACE.

Location:

abuse/trunk/src

Files:

• cache.cpp (modified) (2 diffs)
• chars.cpp (modified) (3 diffs)
• clisp.cpp (modified) (3 diffs)
• dev.cpp (modified) (2 diffs)
• game.cpp (modified) (6 diffs)
• gamma.cpp (modified) (1 diff)
• level.cpp (modified) (7 diffs)
• lisp/lisp.cpp (modified) (31 diffs)
• lisp/lisp.h (modified) (5 diffs)
• lisp/lisp_gc.cpp (modified) (2 diffs)
• lisp/lisp_gc.h (modified) (1 diff)
• loader2.cpp (modified) (1 diff)
• menu.cpp (modified) (1 diff)
• objects.cpp (modified) (16 diffs)
• particle.cpp (modified) (1 diff)
• view.cpp (modified) (1 diff)

abuse/trunk/src/cache.cpp

@@ -382 +382 @@
       if (cache_fun)
       {
-    int sp=current_space;
-    current_space=PERM_SPACE;
+    LSpace *sp = LSpace::Current;
+    LSpace::Current = &LSpace::Perm;
 
     void *call_with=NULL;
@@ -419 +419 @@
       }
     }
-    current_space=sp;
+    LSpace::Current=sp;
 
       }

abuse/trunk/src/chars.cpp

@@ -113 +113 @@
     num=ts;
     if (num<MAX_STATE) num=MAX_STATE;
-    int sp=current_space;
-    current_space=PERM_SPACE;
+    LSpace *sp = LSpace::Current;
+    LSpace::Current = &LSpace::Perm;
     ((LSymbol *)symbol)->SetNumber(num);
-    current_space=sp;
+    LSpace::Current=sp;
   }
 
@@ -268 +268 @@
 
     /* create the var and add to var list */
-    int sp=current_space;
-    current_space=PERM_SPACE;
+    LSpace *sp = LSpace::Current;
+    LSpace::Current = &LSpace::Perm;
 
     add_c_object(symbol,free_index);
@@ -276 +276 @@
     var_index[free_index]=tv;
     tv++;
-    current_space=sp;
+    LSpace::Current=sp;
   }
 }

abuse/trunk/src/clisp.cpp

@@ -724 +724 @@
       for (int x=0; x<trials; x++)
       {
-    clear_tmp();
+    LSpace::Tmp.Clear();
     CAR(args)->Eval();
       }
@@ -770 +770 @@
         exit(0);
       }
-      int sp=current_space;
-      current_space=PERM_SPACE;
+      LSpace *sp = LSpace::Current;
+      LSpace::Current = &LSpace::Perm;
       sym->SetNumber(total_objects);   // set the symbol value to the object number
-      current_space=sp;
+      LSpace::Current=sp;
       if (!total_objects)
       {
@@ -1382 +1382 @@
       }
 
-      int sp=current_space;
-      current_space=PERM_SPACE;
+      LSpace *sp = LSpace::Current;
+      LSpace::Current = &LSpace::Perm;
       int id=cache.reg(lstring_value(lcar(args)),NULL,SPEC_EXTERN_SFX,1);
       if (sym)
         sym->SetNumber(id);    // set the symbol value to sfx id
-      current_space=sp;
+      LSpace::Current=sp;
       return id;
     } break;

abuse/trunk/src/dev.cpp

@@ -53 +53 @@
 
   // maybe english.lsp was not loaded yet, let's try to do that
-  int sp=current_space;
-  current_space=PERM_SPACE;
-
+  LSpace *sp = LSpace::Current;
+  LSpace::Current = &LSpace::Perm;
 
   char prog[50];
@@ -68 +67 @@
     exit(0);
   }
-  current_space=sp;
+  LSpace::Current=sp;
 
 

abuse/trunk/src/game.cpp

@@ -699 +699 @@
   {
     screen->dirt_off();
-    clear_tmp();
+    LSpace::Tmp.Clear();
     l_post_render->EvalFunction(NULL);
-    clear_tmp();
+    LSpace::Tmp.Clear();
     screen->dirt_on();
   }
@@ -1985 +1985 @@
 void Game::step()
 {
-  clear_tmp();
+  LSpace::Tmp.Clear();
   if(current_level)
   {
@@ -2282 +2282 @@
         if(!strcmp(argv[i], "-lisp"))
         {
-            lisp_init();
+            Lisp::Init();
             char const *eof_char = "Ctrl-D";
             fprintf(stderr,
@@ -2328 +2328 @@
 /*      if(DEFINEDP(symbol_function(l_next_song)))  // if user function installed, call it to load up next song
       {
-    int sp = current_space;
-    current_space = PERM_SPACE;
+    int sp = LSpace::Current;
+    LSpace::Current = SPACE_PERM;
     ((LSymbol *)l_next_song)->EvalFunction(NULL);
-    current_space = sp;
+    LSpace::Current = sp;
       } */
     }
@@ -2459 +2459 @@
 
         game_net_init(argc, argv);
-        lisp_init();
+        Lisp::Init();
 
         dev_init(argc, argv);
@@ -2588 +2588 @@
         }
 
-        lisp_uninit();
+        Lisp::Uninit();
 
 #if !defined __CELLOS_LV2__

abuse/trunk/src/gamma.cpp

@@ -189 +189 @@
                 fprintf(fp, "(setq darkest_gray %ld)\n", dg);
                 fclose(fp);
-                int sp = current_space;
-                current_space = PERM_SPACE;
+                LSpace *sp = LSpace::Current;
+                LSpace::Current = &LSpace::Perm;
                 LSymbol::FindOrCreate("darkest_gray")->SetNumber(dg);
 
-                current_space = sp;
+                LSpace::Current = sp;
             }
             else

abuse/trunk/src/level.cpp

@@ -743 +743 @@
     }
 
-    clear_tmp();
+    LSpace::Tmp.Clear();
 
     if (cur)
@@ -822 +822 @@
   }
 
-  clear_tmp();
+  LSpace::Tmp.Clear();
 }
 
@@ -941 +941 @@
       uint16_t t=fp->read_uint16();
       game_object *p=new game_object(o_remap[t],1);
-      clear_tmp();
+      LSpace::Tmp.Clear();
       if (!first) first=p; else last->next=p;
       last=p; p->next=NULL;
@@ -1151 +1151 @@
         uint16_t t=fp->read_uint16();
         game_object *p=new game_object(o_remap[t],1);
-        clear_tmp();
+        LSpace::Tmp.Clear();
         if (!first) first=p; else last->next=p;
         last=p; p->next=NULL;
@@ -1510 +1510 @@
 /*  if (DEFINEDP(symbol_function(l_level_loaded)))
   {
-    int sp=current_space;
-    current_space=PERM_SPACE;
+    LSpace *sp = LSpace::Current;
+    LSpace::Current = &LSpace::Perm;
 
     void *arg_list=NULL;
@@ -1518 +1518 @@
     ((LSymbol *)l_level_loaded)->EvalFunction(arg_list);
 
-    current_space=sp;
+    LSpace::Current = sp;
   } */
 }
@@ -1841 +1841 @@
     if (f->focus)
     {
-      current_object=f->focus;
-      void *m=mark_heap(TMP_SPACE);
+      current_object = f->focus;
+      void *m = LSpace::Tmp.Mark();
       fun->EvalFunction(NULL);
-      restore_heap(m,TMP_SPACE);
+      LSpace::Tmp.Restore(m);
     }
       }

abuse/trunk/src/lisp/lisp.cpp

@@ -42 +42 @@
  * tmp space which gets thrown away after completion of eval.  system
  * functions reside in permant space. */
-
-bFILE *current_print_file=NULL;
+LSpace LSpace::Tmp, LSpace::Perm, LSpace::Gc;
+
+/* Normally set to Tmp, unless compiling or other needs. */
+LSpace *LSpace::Current;
+
+bFILE *current_print_file = NULL;
 
 LSymbol *LSymbol::root = NULL;
 size_t LSymbol::count = 0;
 
-
-uint8_t *space[4], *free_space[4];
-size_t space_size[4];
 int print_level = 0, trace_level = 0, trace_print_level = 1000;
 int total_user_functions;
-
-int current_space;  // normally set to TMP_SPACE, unless compiling or other needs
 
 int break_level=0;
@@ -160 +159 @@
 void need_perm_space(char const *why)
 {
-  if (current_space!=PERM_SPACE && current_space!=GC_SPACE)
+  if (LSpace::Current != &LSpace::Perm && LSpace::Current != &LSpace::Gc)
   {
     lbreak("%s : action requires permanant space\n", why);
@@ -167 +166 @@
 }
 
-void *mark_heap(int heap)
-{
-  return free_space[heap];
-}
-
-void restore_heap(void *val, int heap)
-{
-  free_space[heap] = (uint8_t *)val;
-}
-
-static size_t get_free_size(int which_space)
-{
-    size_t used = free_space[which_space] - space[which_space];
-    return space_size[which_space] > used ? space_size[which_space] - used : 0;
-}
-
-static void *lmalloc(size_t size, int which_space)
+void *LSpace::Mark()
+{
+    return m_free;
+}
+
+void LSpace::Restore(void *val)
+{
+    m_free = (uint8_t *)val;
+}
+
+size_t LSpace::GetFree()
+{
+    size_t used = m_free - m_data;
+    return m_size > used ? m_size - used : 0;
+}
+
+void *LSpace::Alloc(size_t size)
 {
     // Align allocation
@@ -189 +188 @@
 
     // Collect garbage if necessary
-    if (size > get_free_size(which_space))
-    {
-        if (which_space == PERM_SPACE || which_space == TMP_SPACE)
-            LispGC::CollectSpace(which_space, 0);
-
-        if (size > get_free_size(which_space))
-            LispGC::CollectSpace(which_space, 1);
-
-        if (size > get_free_size(which_space))
-        {
-            lbreak("lisp: cannot find %d bytes in space #%d\n",
-                   size, which_space);
+    if (size > GetFree())
+    {
+        if (this == &LSpace::Perm || this == &LSpace::Tmp)
+            LispGC::CollectSpace(this, 0);
+
+        if (size > GetFree())
+            LispGC::CollectSpace(this, 1);
+
+        if (size > GetFree())
+        {
+            lbreak("lisp: cannot find %d bytes in %s\n", size, m_name);
             exit(0);
         }
     }
 
-    void *ret = (void *)free_space[which_space];
-    free_space[which_space] += size;
+    void *ret = m_free;
+    m_free += size;
     return ret;
 }
@@ -229 +227 @@
         size = sizeof(LRedirect);
 
-    LArray *p = (LArray *)lmalloc(size, current_space);
+    LArray *p = (LArray *)LSpace::Current->Alloc(size);
     p->type = L_1D_ARRAY;
     p->len = len;
@@ -282 +280 @@
     size_t size = Max(sizeof(LFixedPoint), sizeof(LRedirect));
 
-    LFixedPoint *p = (LFixedPoint *)lmalloc(size, current_space);
+    LFixedPoint *p = (LFixedPoint *)LSpace::Current->Alloc(size);
     p->type = L_FIXED_POINT;
     p->x = x;
@@ -292 +290 @@
     size_t size = Max(sizeof(LObjectVar), sizeof(LRedirect));
 
-    LObjectVar *p = (LObjectVar *)lmalloc(size, current_space);
+    LObjectVar *p = (LObjectVar *)LSpace::Current->Alloc(size);
     p->type = L_OBJECT_VAR;
     p->index = index;
@@ -304 +302 @@
     size_t size = Max(sizeof(LPointer), sizeof(LRedirect));
 
-    LPointer *p = (LPointer *)lmalloc(size, current_space);
+    LPointer *p = (LPointer *)LSpace::Current->Alloc(size);
     p->type = L_POINTER;
     p->addr = addr;
@@ -314 +312 @@
     size_t size = Max(sizeof(LChar), sizeof(LRedirect));
 
-    LChar *c = (LChar *)lmalloc(size, current_space);
+    LChar *c = (LChar *)LSpace::Current->Alloc(size);
     c->type = L_CHARACTER;
     c->ch = ch;
@@ -339 +337 @@
     size_t size = Max(sizeof(LString) + length - 1, sizeof(LRedirect));
 
-    LString *s = (LString *)lmalloc(size, current_space);
+    LString *s = (LString *)LSpace::Current->Alloc(size);
     s->type = L_STRING;
     s->str[0] = '\0';
@@ -351 +349 @@
     size_t size = Max(sizeof(LUserFunction), sizeof(LRedirect));
 
-    LUserFunction *lu = (LUserFunction *)lmalloc(size, current_space);
+    LUserFunction *lu = (LUserFunction *)LSpace::Current->Alloc(size);
     lu->type = L_USER_FUNCTION;
     lu->arg_list = arg_list;
@@ -363 +361 @@
 
     // System functions should reside in permanant space
-    int space = (current_space == GC_SPACE) ? GC_SPACE : PERM_SPACE;
-    LSysFunction *ls = (LSysFunction *)lmalloc(size, space);
+    LSysFunction *ls = LSpace::Current == &LSpace::Gc
+                     ? (LSysFunction *)LSpace::Gc.Alloc(size)
+                     : (LSysFunction *)LSpace::Perm.Alloc(size);
     ls->type = L_SYS_FUNCTION;
     ls->min_args = min_args;
@@ -397 +396 @@
     size_t size = Max(sizeof(LSymbol), sizeof(LRedirect));
 
-    LSymbol *s = (LSymbol *)lmalloc(size, current_space);
+    LSymbol *s = (LSymbol *)LSpace::Current->Alloc(size);
     PtrRef ref(s);
 
@@ -414 +413 @@
     size_t size = Max(sizeof(LNumber), sizeof(LRedirect));
 
-    LNumber *n = (LNumber *)lmalloc(size, current_space);
+    LNumber *n = (LNumber *)LSpace::Current->Alloc(size);
     n->type = L_NUMBER;
     n->num = num;
@@ -424 +423 @@
     size_t size = Max(sizeof(LList), sizeof(LRedirect));
 
-    LList *c = (LList *)lmalloc(size, current_space);
+    LList *c = (LList *)LSpace::Current->Alloc(size);
     c->type = L_CONS_CELL;
     c->car = NULL;
@@ -772 +771 @@
   else
   {
-    int sp=current_space;
-    if (current_space!=GC_SPACE)
-      current_space=PERM_SPACE;       // make sure all symbols get defined in permanant space
+    LSpace *sp = LSpace::Current;
+    if (LSpace::Current != &LSpace::Gc)
+      LSpace::Current = &LSpace::Perm;       // make sure all symbols get defined in permanant space
     LList *cs;
     cs=LList::Create();
@@ -781 +780 @@
     cs->cdr=symbol_list;
     symbol_list=cs;
-    current_space=sp;
+    LSpace::Current = sp;
   }
   return s;
@@ -815 +814 @@
 
     // Make sure all symbols get defined in permanant space
-    int sp = current_space;
-    if (current_space != GC_SPACE)
-       current_space = PERM_SPACE;
+    LSpace *sp = LSpace::Current;
+    if (LSpace::Current != &LSpace::Gc)
+        LSpace::Current = &LSpace::Perm;
 
     p = (LSymbol *)malloc(sizeof(LSymbol));
@@ -833 +832 @@
     count++;
 
-    current_space = sp;
+    LSpace::Current = sp;
     return p;
 }
@@ -2401 +2400 @@
                     stat_man->update((cs - s) * 100 / l);
 #endif
-                void *m = mark_heap(TMP_SPACE);
+                void *m = LSpace::Tmp.Mark();
                 compiled_form = LObject::Compile(cs);
                 compiled_form->Eval();
                 compiled_form = NULL;
-                restore_heap(m, TMP_SPACE);
+                LSpace::Tmp.Restore(m);
             }
 #ifndef NO_LIBS
@@ -2471 +2470 @@
     case SYS_FUNC_ENUM:
     {
-        int sp = current_space;
-        current_space = PERM_SPACE;
+        LSpace *sp = LSpace::Current;
+        LSpace::Current = &LSpace::Perm;
         int32_t x = 0;
         while (arg_list)
@@ -2511 +2510 @@
             x++;
         }
-        current_space = sp;
+        LSpace::Current = sp;
         break;
     }
@@ -2807 +2806 @@
     }
     case SYS_FUNC_GC:
-        LispGC::CollectSpace(current_space, 0);
+        LispGC::CollectSpace(LSpace::Current, 0);
         break;
     case SYS_FUNC_SCHAR:
@@ -2946 +2945 @@
 void tmp_space()
 {
-    current_space = TMP_SPACE;
+    LSpace::Current = &LSpace::Tmp;
 }
 
 void perm_space()
 {
-    current_space = PERM_SPACE;
-}
-
-void use_user_space(void *addr, long size)
-{
-    current_space = USER_SPACE;
-    free_space[USER_SPACE] = space[USER_SPACE] = (uint8_t *)addr;
-    space_size[USER_SPACE] = size;
+    LSpace::Current = &LSpace::Perm;
 }
 
@@ -3071 +3063 @@
         {
             dprintf("%d (%d, %d, %d) TRACE : ", trace_level,
-                    get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
+                    LSpace::Perm.GetFree(), LSpace::Tmp.GetFree(),
                     PtrRef::stack.m_size);
             Print();
@@ -3120 +3112 @@
         if (trace_level <= trace_print_level)
             dprintf("%d (%d, %d, %d) TRACE ==> ", trace_level,
-                    get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
+                    LSpace::Perm.GetFree(), LSpace::Tmp.GetFree(),
                     PtrRef::stack.m_size);
         ret->Print();
@@ -3127 +3119 @@
 
 /*  l_user_stack.push(ret);
-  LispGC::CollectSpace(PERM_SPACE);
+  LispGC::CollectSpace(&LSpace::Perm);
   ret=l_user_stack.pop(1);  */
 
@@ -3135 +3127 @@
 void l_comp_init();
 
-void lisp_init()
+void Lisp::Init()
 {
     LSymbol::root = NULL;
     total_user_functions = 0;
 
-    free_space[0] = space[0] = (uint8_t *)malloc(0x1000);
-    space_size[0] = 0x1000;
-
-    free_space[1] = space[1] = (uint8_t *)malloc(0x1000);
-    space_size[1] = 0x1000;
-
-    current_space = PERM_SPACE;
+    LSpace::Tmp.m_free = LSpace::Tmp.m_data = (uint8_t *)malloc(0x1000);
+    LSpace::Tmp.m_size = 0x1000;
+    LSpace::Tmp.m_name = "temporary space";
+
+    LSpace::Perm.m_free = LSpace::Perm.m_data = (uint8_t *)malloc(0x1000);
+    LSpace::Perm.m_size = 0x1000;
+    LSpace::Perm.m_name = "permanent space";
+
+    LSpace::Gc.m_name = "garbage space";
+
+    LSpace::Current = &LSpace::Perm;
 
     l_comp_init();
@@ -3153 +3149 @@
                          sys_funcs[i].min_args, sys_funcs[i].max_args, i);
     clisp_init();
-    current_space = TMP_SPACE;
+    LSpace::Current = &LSpace::Tmp;
     dprintf("Lisp: %d symbols defined, %d system functions, "
             "%d pre-compiled functions\n", LSymbol::count,
@@ -3159 +3155 @@
 }
 
-void lisp_uninit()
-{
-    free(space[0]);
-    free(space[1]);
+void Lisp::Uninit()
+{
+    free(LSpace::Tmp.m_data);
+    free(LSpace::Perm.m_data);
     DeleteAllSymbols(LSymbol::root);
     LSymbol::root = NULL;
@@ -3168 +3164 @@
 }
 
-void clear_tmp()
-{
-    free_space[TMP_SPACE] = space[TMP_SPACE];
+void LSpace::Clear()
+{
+    m_free = m_data;
 }
 

abuse/trunk/src/lisp/lisp.h

@@ -21 +21 @@
 #define Cell void
 #define MAX_LISP_TOKEN_LEN 200
-enum { PERM_SPACE,
-       TMP_SPACE,
-       USER_SPACE,
-       GC_SPACE };
 
 #define FIXED_TRIG_SIZE 360               // 360 degrees stored in table
@@ -33 +29 @@
 #define DEFINEDP(x) (x!=l_undefined)
 class bFILE;
-extern int current_space;
 extern bFILE *current_print_file;
 
@@ -45 +40 @@
 typedef uint32_t ltype;    // make sure structures aren't packed differently on various compiler
                        // and sure that word, etc are word aligned
+
+class Lisp
+{
+public:
+    static void Init();
+    static void Uninit();
+};
+
+struct LSpace
+{
+    size_t GetFree();
+    void *Alloc(size_t size);
+
+    void *Mark();
+    void Restore(void *val);
+    void Clear();
+
+    static LSpace Tmp, Perm, Gc;
+    static LSpace *Current;
+
+    uint8_t *m_data;
+    uint8_t *m_free;
+    char const *m_name;
+    size_t m_size;
+};
 
 struct LObject
@@ -206 +226 @@
 void perm_space();
 void tmp_space();
-void use_user_space(void *addr, long size);
 void *lpointer_value(void *lpointer);
 int32_t lnumber_value(void *lnumber);
@@ -239 +258 @@
 
 int end_of_program(char *s);
-void clear_tmp();
 void lisp_init();
 void lisp_uninit();
 
-extern uint8_t *space[4], *free_space[4];
-extern size_t space_size[4];
 void *nth(int num, void *list);
 int32_t lisp_atan2(int32_t dy, int32_t dx);

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -205 +205 @@
 }
 
-void LispGC::CollectSpace(int which_space, int grow)
-{
-    int old_space = current_space;
-    cstart = space[which_space];
-    cend = free_space[which_space];
-
-    space_size[GC_SPACE] = space_size[which_space];
+void LispGC::CollectSpace(LSpace *which_space, int grow)
+{
+    LSpace *old_space = LSpace::Current;
+    cstart = which_space->m_data;
+    cend = which_space->m_free;
+
+    LSpace::Gc.m_size = which_space->m_size;
     if (grow)
     {
-        space_size[GC_SPACE] += space_size[which_space] >> 1;
-        space_size[GC_SPACE] -= (space_size[GC_SPACE] & 7);
-    }
-    uint8_t *new_space = (uint8_t *)malloc(space_size[GC_SPACE]);
-    current_space = GC_SPACE;
-    free_space[GC_SPACE] = space[GC_SPACE] = new_space;
-
-    collected_start = new_space;
-    collected_end = new_space + space_size[GC_SPACE];
+        LSpace::Gc.m_size += which_space->m_size >> 1;
+        LSpace::Gc.m_size -= (LSpace::Gc.m_size & 7);
+    }
+    uint8_t *new_data = (uint8_t *)malloc(LSpace::Gc.m_size);
+    LSpace::Current = &LSpace::Gc;
+    LSpace::Gc.m_free = LSpace::Gc.m_data = new_data;
+
+    collected_start = new_data;
+    collected_end = new_data + LSpace::Gc.m_size;
 
     CollectSymbols(LSymbol::root);
@@ -228 +228 @@
 
     // for debuging clear it out
-    memset(space[which_space], 0, space_size[which_space]);
-    free(space[which_space]);
-
-    space[which_space] = new_space;
-    space_size[which_space] = space_size[GC_SPACE];
-    free_space[which_space] = new_space
-                            + (free_space[GC_SPACE] - space[GC_SPACE]);
-    current_space = old_space;
-}
-
+    memset(which_space->m_data, 0, which_space->m_size);
+    free(which_space->m_data);
+
+    which_space->m_data = new_data;
+    which_space->m_size = LSpace::Gc.m_size;
+    which_space->m_free = new_data + (LSpace::Gc.m_free - LSpace::Gc.m_data);
+    LSpace::Current = old_space;
+}
+

abuse/trunk/src/lisp/lisp_gc.h

@@ -20 +20 @@
 public:
     // Collect temporary or permanent spaces
-    static void CollectSpace(int which_space, int grow);
+    static void CollectSpace(LSpace *which_space, int grow);
 
 private:

abuse/trunk/src/loader2.cpp

@@ -361 +361 @@
   }
   compiled_init();
-  clear_tmp();
+  LSpace::Tmp.Clear();
 
   dprintf("Engine : Registering base graphics\n");

abuse/trunk/src/menu.cpp

@@ -389 +389 @@
   if (!DEFINEDP(ss->GetValue()))
   {
-    int sp=current_space;
-    current_space=PERM_SPACE;
+    LSpace *sp = LSpace::Current;
+    LSpace::Current = &LSpace::Perm;
 //    char *prog="((\"art/help.spe\" . \"sell2\")(\"art/help.spe\" . \"sell4\")(\"art/help.spe\" . \"sell3\")(\"art/fore/endgame.spe\" . \"credit\"))";
 //    char *prog="((\"art/fore/endgame.spe\" . \"credit\") (\"art/help.spe\" . \"sell6\"))";
     char const *prog = "((\"art/fore/endgame.spe\" . \"credit\"))";
     ss->SetValue(LObject::Compile(prog));
-    current_space=sp;
+    LSpace::Current = sp;
   }
 

abuse/trunk/src/objects.cpp

@@ -261 +261 @@
     current_object=this;
 
-    void *m=mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
     ((LSymbol *)ns)->EvalFunction(NULL);
-    restore_heap(m,TMP_SPACE);
+    LSpace::Tmp.Restore(m);
 
     current_object=o;
@@ -275 +275 @@
     {
         current_object = this;
-        void *m = mark_heap( TMP_SPACE );
+        void *m = LSpace::Tmp.Mark();
         ((LSymbol *)ns)->EvalFunction(NULL);
-        restore_heap( m, TMP_SPACE );
+        LSpace::Tmp.Restore(m);
     }
     else
@@ -410 +410 @@
 
     current_object=this;
-    void *m=mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
 
     time_marker *prof1=NULL;
@@ -424 +424 @@
     }
 
-    restore_heap(m,TMP_SPACE);
+    LSpace::Tmp.Restore(m);
 
     if (keep_ai_info())
@@ -484 +484 @@
     current_object = this;
 
-    void *m = mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
 
     am = LList::Create();
@@ -528 +528 @@
     }
 
-    restore_heap(m, TMP_SPACE);
+    LSpace::Tmp.Restore(m);
 
     current_object = o;
@@ -624 +624 @@
     current_object=this;
 
-    void *m=mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
     time_marker *prof1=NULL;
     if (profiling())
@@ -637 +637 @@
     }
 
-
-
-    restore_heap(m,TMP_SPACE);
+    LSpace::Tmp.Restore(m);
 
   } else drawer();
@@ -651 +649 @@
     current_object=this;
 
-    void *m=mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
     time_marker *prof1=NULL;
     if (profiling())
@@ -664 +662 @@
     }
 
-    restore_heap(m,TMP_SPACE);
-
+    LSpace::Tmp.Restore(m);
   }
 }
@@ -1157 +1154 @@
     current_object=g;
 
-    void *m=mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
 
     time_marker *prof1=NULL;
@@ -1171 +1168 @@
     }
 
-
-
-    restore_heap(m,TMP_SPACE);
-
-    current_object=o;
+    LSpace::Tmp.Restore(m);
+    current_object = o;
   }
   return g;
@@ -1222 +1216 @@
     lcy->cdr = lb;
 
-    void *m = mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
 
     time_marker *prof1 = NULL;
@@ -1236 +1230 @@
     }
 
-    restore_heap(m,TMP_SPACE);
+    LSpace::Tmp.Restore(m);
 
     if (item_type(r)!=L_NUMBER)
@@ -1626 +1620 @@
     current_object=this;
 
-    void *m=mark_heap(TMP_SPACE);
+    void *m = LSpace::Tmp.Mark();
 
     time_marker *prof1=NULL;
@@ -1640 +1634 @@
     }
 
-
-    restore_heap(m,TMP_SPACE);
-
-    current_object=o;
-  }
-}
+    LSpace::Tmp.Restore(m);
+    current_object = o;
+  }
+}

abuse/trunk/src/particle.cpp

@@ -72 +72 @@
     exit(0);
   }
-  int sp=current_space;
-  current_space=PERM_SPACE;
+  LSpace *sp = LSpace::Current;
+  LSpace::Current = &LSpace::Perm;
   sym->SetNumber(total_pseqs); // set the symbol value to the object number
-  current_space=sp;
+  LSpace::Current = sp;
   pseqs=(part_sequence **)realloc(pseqs,sizeof(part_sequence *)*(total_pseqs+1));
 

abuse/trunk/src/view.cpp

@@ -473 +473 @@
       current_object=focus;
 
-      void *m=mark_heap(TMP_SPACE);
+      void *m = LSpace::Tmp.Mark();
       void *list=NULL;
       push_onto_list(LString::Create(chat_buf),list);
       ((LSymbol *)l_chat_input)->EvalFunction(list);
-      restore_heap(m,TMP_SPACE);
+      LSpace::Tmp.Restore(m);
 
       current_object=o;