Changeset 493Tweet

Timestamp:

Apr 17, 2011, 3:58:41 PM (12 years ago)

Author:

Sam Hocevar

Message:

lisp: refactor stuff for better type checking.

Location:

abuse/trunk/src

Files:

• ant.cpp (modified) (1 diff)
• cache.cpp (modified) (1 diff)
• chars.cpp (modified) (6 diffs)
• clisp.cpp (modified) (29 diffs)
• cop.cpp (modified) (1 diff)
• game.cpp (modified) (1 diff)
• lcache.cpp (modified) (1 diff)
• lisp/lisp.cpp (modified) (68 diffs)
• lisp/lisp.h (modified) (13 diffs)
• lisp/lisp_gc.cpp (modified) (10 diffs)
• menu.cpp (modified) (1 diff)
• objects.cpp (modified) (3 diffs)
• particle.cpp (modified) (2 diffs)

abuse/trunk/src/ant.cpp

@@ -112 +112 @@
     void *call_list=NULL;
     PtrRef r1(call_list);
-    push_onto_list(new_lisp_pointer(b),call_list);
+    push_onto_list(LPointer::Create(b),call_list);
     push_onto_list(LNumber::Create(angle),call_list);
     push_onto_list(LNumber::Create(firey),call_list);
     push_onto_list(LNumber::Create(firex),call_list);
     push_onto_list(LNumber::Create(o->aitype()),call_list);
-    push_onto_list(new_lisp_pointer(o),call_list);
+    push_onto_list(LPointer::Create(o),call_list);
     eval_user_fun((LSymbol *)l_fire_object,call_list);
     o->set_state((character_state)S_weapon_fire);

abuse/trunk/src/cache.cpp

@@ -879 +879 @@
     {
       delete cache_file;
-      lprint(block);
+      ((LObject *)block)->Print();
       fprintf(stderr,"Unable to open lisp cache file name %s\n",lfname);
       exit(0);

abuse/trunk/src/chars.cpp

@@ -85 +85 @@
   if (item_type(symbol)!=L_SYMBOL)
   {
-    lprint(symbol);
+    ((LObject *)symbol)->Print();
     lbreak("is not a symbol (in def_char)");
     exit(0);
@@ -97 +97 @@
     if (item_type(val)!=L_NUMBER)
     {
-      lprint(symbol);
+      ((LObject *)symbol)->Print();
       dprintf("expecting symbol value to be a number, instead got : ");
-      lprint(val);
+      ((LObject *)val)->Print();
       lbreak("");
       exit(0);
@@ -116 +116 @@
   if (num<ts && seq[num])
   {
-    lprint(symbol);
+    ((LObject *)symbol)->Print();
     lbreak("symbol has been assigned value %d, but value already in use by state %s\n"
        "use a different symbol for this state\n",
@@ -205 +205 @@
   if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
   {
-    lprint(symbol);
+    ((LObject *)symbol)->Print();
     lbreak("symbol already has a value, cannot instantiate an object varible");
     exit(0);
   } else if (DEFINEDP(s->value))
   {
-    int index=((LObjectVar *)s->value)->number;
+    int index=((LObjectVar *)s->value)->index;
     if (index<tiv)
     {
@@ -405 +405 @@
     if (!isa_var_name(real))
     {
-      lprint(field);
+      ((LObject *)field)->Print();
       lbreak("fields : no such var name \"%s\"\n",name);
       exit(0);
@@ -432 +432 @@
     else
     {
-      lprint(lcar(field));
+      ((LObject *)lcar(field))->Print();
       lbreak("Unknown field for character definition");
       exit(0);

abuse/trunk/src/clisp.cpp

@@ -602 +602 @@
       game_object *hit=current_object->bmove(whit,o);
       if (hit)
-        return new_lisp_pointer(hit);
+        return LPointer::Create(hit);
       else if (whit) return NULL;
       else return true_symbol;
     } break;
 
-    case 3 : return new_lisp_pointer(current_object); break;
+    case 3 : return LPointer::Create(current_object); break;
     case 4 :
     { if (player_list->next)
-        return new_lisp_pointer(current_level->attacker(current_object));
-      else return new_lisp_pointer(player_list->focus); } break;
-    case 5 : return new_lisp_pointer(current_level->find_closest(current_object->x,
+        return LPointer::Create(current_level->attacker(current_object));
+      else return LPointer::Create(player_list->focus); } break;
+    case 5 : return LPointer::Create(current_level->find_closest(current_object->x,
                                  current_object->y,
                                lnumber_value(eval(CAR(args))),
                                        current_object)); break;
-    case 6 : return new_lisp_pointer(current_level->find_xclosest(current_object->x,
+    case 6 : return LPointer::Create(current_level->find_xclosest(current_object->x,
                                   current_object->y,
                                   lnumber_value(eval(CAR(args))),
@@ -625 +625 @@
       long n1=lnumber_value(eval(CAR(args)));
       long n2=lnumber_value(eval(CAR(CDR(args))));
-      return new_lisp_pointer(current_level->find_xrange(current_object->x,
+      return LPointer::Create(current_level->find_xrange(current_object->x,
                              current_object->y,
                              n1,
@@ -643 +643 @@
       if (current_level)
         current_level->add_object(o);
-      return new_lisp_pointer(o);
+      return LPointer::Create(o);
     } break;
     case 22 :
@@ -657 +657 @@
       if (current_level)
         current_level->add_object_after(o,current_object);
-      return new_lisp_pointer(o);
-    } break;
-
-    case 9 : return new_lisp_pointer(the_game->first_view->focus); break;
+      return LPointer::Create(o);
+    } break;
+
+    case 9 : return LPointer::Create(the_game->first_view->focus); break;
     case 10 :
     {
       view *v=((game_object *)lpointer_value(eval(CAR(args))))->controller()->next;
       if (v)
-        return new_lisp_pointer(v->focus);
+        return LPointer::Create(v->focus);
       else return NULL;
     } break;
     case 11 :
     {
-      return new_lisp_pointer
+      return LPointer::Create
       ((void *)current_object->get_object(lnumber_value(eval(CAR(args)))));
     } break;
     case 12 :
     {
-      return new_lisp_pointer
+      return LPointer::Create
       ((void *)current_object->get_light(lnumber_value(eval(CAR(args)))));
     } break;
@@ -699 +699 @@
       int xs=lnumber_value(eval(CAR(args))); args=lcdr(args);
       int ys=lnumber_value(eval(CAR(args)));
-      return new_lisp_pointer(add_light_source(t,x,y,r1,r2,xs,ys));
+      return LPointer::Create(add_light_source(t,x,y,r1,r2,xs,ys));
     } break;
     case 15 :
@@ -722 +722 @@
       }
       time_marker end;
-      return new_lisp_fixed_point((long)(end.diff_time(&start)*(1<<16)));
+      return LFixedPoint::Create((long)(end.diff_time(&start)*(1<<16)));
     } break;
     case 18 :
@@ -739 +739 @@
                           current_object->y,
                           x1,y1,x2,y2,list,current_object);
-      if (find) return new_lisp_pointer(find);
+      if (find) return LPointer::Create(find);
       else return NULL;
     } break;
@@ -753 +753 @@
                             current_object->y,
                             a1,a2,list,current_object);
-      if (find) return new_lisp_pointer(find);
+      if (find) return LPointer::Create(find);
       else return NULL;
     } break;
@@ -928 +928 @@
       return ret;
     } break;
-    case 51 :   return new_lisp_pointer(wm->font()); break;
+    case 51 :   return LPointer::Create(wm->font()); break;
     case 52 :
     {
@@ -995 +995 @@
         long x;
         sscanf(lstring_value(eval(CAR(args))),"%lx",&x);
-        return new_lisp_pointer((void *)(intptr_t)x);
+        return LPointer::Create((void *)(intptr_t)x);
     } break;
     case 64 :
@@ -1392 +1392 @@
       if (!a)
       {
-        lprint(args);
+        ((LObject *)args)->Print();
         lbreak("expecting y after x in play_sound\n");
         exit(1);
@@ -1478 +1478 @@
       if (a<0 || a>=TOTAL_ABILITIES)
       {
-    lprint(args);
+    ((LObject *)args)->Print();
     lbreak("bad ability number for get_ability, should be 0..%d, not %d\n",
         TOTAL_ABILITIES,a);
@@ -1573 +1573 @@
       if (r<0 || b<0 || g<0 || r>255 || g>255 || b>255)
       {
-    lprint(args);
+    ((LObject *)args)->Print();
     lbreak("color out of range (0..255) in color lookup\n");
     exit(0);
@@ -1582 +1582 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->x_suggestion;
     } break;
@@ -1588 +1588 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->y_suggestion;
     } break;
@@ -1594 +1594 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->b1_suggestion;
     } break;
@@ -1600 +1600 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->b2_suggestion;
     } break;
@@ -1606 +1606 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->b3_suggestion;
     } break;
@@ -1615 +1615 @@
       bg_ymul=lnumber_value(CAR(args)); args=CDR(args);
       bg_ydiv=lnumber_value(CAR(args));
-      if (bg_xdiv==0) { bg_xdiv=1; lprint(args); dprintf("bg_set_scroll : cannot set xdiv to 0\n"); }
-      if (bg_ydiv==0) { bg_ydiv=1; lprint(args); dprintf("bg_set_scroll : cannot set ydiv to 0\n"); }
+      if (bg_xdiv==0) { bg_xdiv=1; ((LObject *)args)->Print(); dprintf("bg_set_scroll : cannot set xdiv to 0\n"); }
+      if (bg_ydiv==0) { bg_ydiv=1; ((LObject *)args)->Print(); dprintf("bg_set_scroll : cannot set ydiv to 0\n"); }
     } break;
     case 179 :
@@ -1983 +1983 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->pointer_x;
     } break;
@@ -1989 +1989 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->pointer_y;
     } break;
@@ -2064 +2064 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->kills;
     } break;
@@ -2070 +2070 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->tkills;
     } break;
@@ -2076 +2076 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->secrets;
     } break;
@@ -2082 +2082 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else return v->tsecrets;
     } break;
@@ -2088 +2088 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else v->kills=lnumber_value(CAR(args));
     } break;
@@ -2094 +2094 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else v->tkills=lnumber_value(CAR(args));
     } break;
@@ -2100 +2100 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else v->secrets=lnumber_value(CAR(args));
     } break;
@@ -2106 +2106 @@
     {
       view *v=current_object->controller();
-      if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
+      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
       else v->tsecrets=lnumber_value(CAR(args));
     } break;

abuse/trunk/src/cop.cpp

@@ -227 +227 @@
   void *list=NULL;
   PtrRef r1(list);
-  push_onto_list(new_lisp_pointer(target),list);
+  push_onto_list(LPointer::Create(target),list);
   push_onto_list(LNumber::Create(angle),list);
   push_onto_list(LNumber::Create(y2),list);
   push_onto_list(LNumber::Create(x2),list);
   push_onto_list(LNumber::Create(type),list);
-  push_onto_list(new_lisp_pointer(o->get_object(0)),list);
+  push_onto_list(LPointer::Create(o->get_object(0)),list);
   eval_function((LSymbol *)l_fire_object,list);
   o->lvars[top_just_fired]=1;

abuse/trunk/src/game.cpp

@@ -2313 +2313 @@
                     l_user_stack.push(prog);
                     while(*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
-                    lprint(eval(prog));
+                    ((LObject *)eval(prog))->Print();
                     l_user_stack.pop(1);
                 }

abuse/trunk/src/lcache.cpp

@@ -105 +105 @@
     { return LNumber::Create(fp->read_uint32()); } break;
     case L_CHARACTER :
-    { return new_lisp_character(fp->read_uint16()); } break;
+    { return LChar::Create(fp->read_uint16()); } break;
     case L_STRING :
     { long l=fp->read_uint32();

abuse/trunk/src/lisp/lisp.cpp

@@ -41 +41 @@
 
 bFILE *current_print_file=NULL;
-LSymbol *lsym_root=NULL;
-long ltotal_syms=0;
-
+
+LSymbol *LSymbol::root = NULL;
+size_t LSymbol::count = 0;
 
 
@@ -58 +58 @@
     if(!block || item_type(block) != L_CONS_CELL)
     {
-        lprint(block);
+        ((LObject *)block)->Print();
         return;
     }
@@ -69 +69 @@
             dprintf("[...]");
         else
-            lprint(a);
+            ((LObject *)a)->Print();
     }
     if (block)
     {
         dprintf(" . ");
-        lprint(block);
+        ((LObject *)block)->Print();
     }
     dprintf(")");
@@ -88 +88 @@
     {
         dprintf("%d> ", i);
-        lprint(*PtrRef::stack.sdata[i]);
+        ((LObject *)*PtrRef::stack.sdata[i])->Print();
     }
 }
@@ -142 +142 @@
                 PtrRef r1(prog);
                 while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
-                lprint(eval(prog));
+                ((LObject *)eval(prog))->Print();
       } while (*s);
     }
@@ -220 +220 @@
 }
 
-LArray *LArray::Create(int size, void *rest)
-{
-  PtrRef r11(rest);
-  size_t s = sizeof(LArray)
-           + ((size < 1 ? 1 : size) - 1) * sizeof(LObject *);
-  LArray *p = (LArray *)lmalloc(s, current_space);
-  p->type = L_1D_ARRAY;
-  p->size = size;
-  LObject **data = p->GetData();
-  memset(data, 0, size * sizeof(LObject *));
-  PtrRef r1(p);
-
-  if (rest)
-  {
-    void *x=eval(CAR(rest));
-    if (x==colon_initial_contents)
-    {
-      x=eval(CAR(CDR(rest)));
-      data = p->GetData();
-      for (int i=0;i<size;i++, x=CDR(x))
-      {
-        if (!x)
-        {
-          lprint(rest);
-          lbreak("(make-array) incorrect list length\n");
-          exit(0);
-        }
-        data[i] = (LObject *)CAR(x);
-      }
-      if (x)
-      {
-        lprint(rest);
-        lbreak("(make-array) incorrect list length\n");
-        exit(0);
-      }
-    }
-    else if (x==colon_initial_element)
-    {
-      x=eval(CAR(CDR(rest)));
-      data = p->GetData();
-      for (int i=0;i<size;i++)
-        data[i] = (LObject *)x;
-    }
-    else
-    {
-      lprint(x);
-      lbreak("Bad option argument to make-array\n");
-      exit(0);
-    }
-  }
-
-  return p;
-}
-
-LFixedPoint *new_lisp_fixed_point(int32_t x)
-{
-  LFixedPoint *p=(LFixedPoint *)lmalloc(sizeof(LFixedPoint), current_space);
-  p->type=L_FIXED_POINT;
-  p->x=x;
-  return p;
-}
-
-
-LObjectVar *new_lisp_object_var(int16_t number)
-{
-  LObjectVar *p=(LObjectVar *)lmalloc(sizeof(LObjectVar), current_space);
-  p->type=L_OBJECT_VAR;
-  p->number=number;
-  return p;
-}
-
-
-struct LPointer *new_lisp_pointer(void *addr)
-{
-  if (addr==NULL) return NULL;
-  LPointer *p=(LPointer *)lmalloc(sizeof(LPointer), current_space);
-  p->type=L_POINTER;
-  p->addr=addr;
-  return p;
-}
-
-struct LChar *new_lisp_character(uint16_t ch)
-{
-  LChar *c=(LChar *)lmalloc(sizeof(LChar), current_space);
-  c->type=L_CHARACTER;
-  c->ch=ch;
-  return c;
-}
-
-struct LString *LString::Create(char const *string)
-{
-    size_t size = sizeof(LString) + strlen(string);
+LArray *LArray::Create(size_t len, void *rest)
+{
+    PtrRef r11(rest);
+    size_t size = sizeof(LArray) + (len - 1) * sizeof(LObject *);
     if (size < sizeof(LRedirect))
         size = sizeof(LRedirect);
 
-    LString *s = (LString *)lmalloc(size, current_space);
-    s->type = L_STRING;
+    LArray *p = (LArray *)lmalloc(size, current_space);
+    p->type = L_1D_ARRAY;
+    p->len = len;
+    LObject **data = p->GetData();
+    memset(data, 0, len * sizeof(LObject *));
+    PtrRef r1(p);
+
+    if (rest)
+    {
+        void *x = eval(CAR(rest));
+        if (x == colon_initial_contents)
+        {
+            x = eval(CAR(CDR(rest)));
+            data = p->GetData();
+            for (size_t i = 0; i < len; i++, x = CDR(x))
+            {
+                if (!x)
+                {
+                    ((LObject *)rest)->Print();
+                    lbreak("(make-array) incorrect list length\n");
+                    exit(0);
+                }
+                data[i] = (LObject *)CAR(x);
+            }
+            if (x)
+            {
+                ((LObject *)rest)->Print();
+                lbreak("(make-array) incorrect list length\n");
+                exit(0);
+            }
+        }
+        else if (x == colon_initial_element)
+        {
+            x = eval(CAR(CDR(rest)));
+            data = p->GetData();
+            for (size_t i = 0; i < len; i++)
+                data[i] = (LObject *)x;
+        }
+        else
+        {
+            ((LObject *)x)->Print();
+            lbreak("Bad option argument to make-array\n");
+            exit(0);
+        }
+    }
+
+    return p;
+}
+
+LFixedPoint *LFixedPoint::Create(int32_t x)
+{
+    size_t size = sizeof(LFixedPoint);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LFixedPoint *p = (LFixedPoint *)lmalloc(size, current_space);
+    p->type = L_FIXED_POINT;
+    p->x = x;
+    return p;
+}
+
+LObjectVar *LObjectVar::Create(int index)
+{
+    size_t size = sizeof(LObjectVar);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LObjectVar *p = (LObjectVar *)lmalloc(size, current_space);
+    p->type = L_OBJECT_VAR;
+    p->index = index;
+    return p;
+}
+
+LPointer *LPointer::Create(void *addr)
+{
+    if (addr == NULL)
+        return NULL;
+    size_t size = sizeof(LPointer);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LPointer *p = (LPointer *)lmalloc(size, current_space);
+    p->type = L_POINTER;
+    p->addr = addr;
+    return p;
+}
+
+LChar *LChar::Create(uint16_t ch)
+{
+    size_t size = sizeof(LChar);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LChar *c = (LChar *)lmalloc(size, current_space);
+    c->type = L_CHARACTER;
+    c->ch = ch;
+    return c;
+}
+
+struct LString *LString::Create(char const *string)
+{
+    LString *s = Create(strlen(string) + 1);
     strcpy(s->str, string);
     return s;
@@ -323 +335 @@
 struct LString *LString::Create(char const *string, int length)
 {
-    size_t size = sizeof(LString) + length;
-    if (size < sizeof(LRedirect))
-        size = sizeof(LRedirect);
-
-    LString *s = (LString *)lmalloc(size, current_space);
-    s->type = L_STRING;
+    LString *s = Create(length + 1);
     memcpy(s->str, string, length);
     s->str[length] = 0;
@@ -349 +356 @@
 LUserFunction *new_lisp_user_function(void *arg_list, void *block_list)
 {
-  PtrRef r1(arg_list), r2(block_list);
-  LUserFunction *lu=(LUserFunction *)lmalloc(sizeof(LUserFunction), current_space);
-  lu->type=L_USER_FUNCTION;
-  lu->arg_list=arg_list;
-  lu->block_list=block_list;
-  return lu;
+    PtrRef r1(arg_list), r2(block_list);
+
+    size_t size = sizeof(LUserFunction);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LUserFunction *lu = (LUserFunction *)lmalloc(size, current_space);
+    lu->type = L_USER_FUNCTION;
+    lu->arg_list = arg_list;
+    lu->block_list = block_list;
+    return lu;
 }
 #else
 LUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
 {
-  int sp=current_space;
-  if (current_space!=GC_SPACE)
-    current_space=PERM_SPACE;       // make sure all functions get defined in permanant space
-
-  LUserFunction *lu=(LUserFunction *)lmalloc(sizeof(LUserFunction), current_space);
-  lu->type=L_USER_FUNCTION;
-  lu->alist=arg_list;
-  lu->blist=block_list;
-
-  current_space=sp;
-
-  return lu;
-}
-#endif
-
+    // Make sure all functions get defined in permanent space
+    int sp = current_space;
+    if (current_space != GC_SPACE)
+        current_space = PERM_SPACE;
+
+    size_t size = sizeof(LUserFunction);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LUserFunction *lu = (LUserFunction *)lmalloc(size, current_space);
+    lu->type = L_USER_FUNCTION;
+    lu->alist = arg_list;
+    lu->blist = block_list;
+
+    current_space = sp;
+
+    return lu;
+}
+#endif
 
 LSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number)
 {
-  // sys functions should reside in permanant space
-  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
-                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
-  ls->type=L_SYS_FUNCTION;
-  ls->min_args=min_args;
-  ls->max_args=max_args;
-  ls->fun_number=fun_number;
-  return ls;
+    size_t size = sizeof(LSysFunction);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    // System functions should reside in permanant space
+    int space = (current_space == GC_SPACE) ? GC_SPACE : PERM_SPACE;
+    LSysFunction *ls = (LSysFunction *)lmalloc(size, space);
+    ls->type = L_SYS_FUNCTION;
+    ls->min_args = min_args;
+    ls->max_args = max_args;
+    ls->fun_number = fun_number;
+    return ls;
 }
 
 LSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number)
 {
-  // sys functions should reside in permanant space
-  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
-                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
-  ls->type=L_C_FUNCTION;
-  ls->min_args=min_args;
-  ls->max_args=max_args;
-  ls->fun_number=fun_number;
-  return ls;
+    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
+    ls->type = L_C_FUNCTION;
+    return ls;
 }
 
 LSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number)
 {
-  // sys functions should reside in permanant space
-  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
-                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
-  ls->type=L_C_BOOL;
-  ls->min_args=min_args;
-  ls->max_args=max_args;
-  ls->fun_number=fun_number;
-  return ls;
+    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
+    ls->type = L_C_BOOL;
+    return ls;
 }
 
 LSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number)
 {
-  // sys functions should reside in permanant space
-  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
-                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
-  ls->type=L_L_FUNCTION;
-  ls->min_args=min_args;
-  ls->max_args=max_args;
-  ls->fun_number=fun_number;
-  return ls;
-}
-
-LNumber *new_lisp_node(long num)
-{
-  LNumber *n=(LNumber *)lmalloc(sizeof(LNumber), current_space);
-  n->type=L_NUMBER;
-  n->num=num;
-  return n;
+    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
+    ls->type = L_L_FUNCTION;
+    return ls;
 }
 
 LSymbol *new_lisp_symbol(char *name)
 {
-  LSymbol *s=(LSymbol *)lmalloc(sizeof(LSymbol), current_space);
-  s->type=L_SYMBOL;
-  s->name=LString::Create(name);
-  s->value=l_undefined;
-  s->function=l_undefined;
+    size_t size = sizeof(LSymbol);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LSymbol *s = (LSymbol *)lmalloc(size, current_space);
+    s->type = L_SYMBOL;
+    s->name = LString::Create(name);
+    s->value = l_undefined;
+    s->function = l_undefined;
 #ifdef L_PROFILE
-  s->time_taken=0;
-#endif
-  return s;
+    s->time_taken = 0;
+#endif
+    return s;
 }
 
 LNumber *LNumber::Create(long num)
 {
-    LNumber *s = (LNumber *)lmalloc(sizeof(LNumber), current_space);
-    s->type = L_NUMBER;
-    s->num = num;
-    return s;
+    size_t size = sizeof(LNumber);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LNumber *n = (LNumber *)lmalloc(size, current_space);
+    n->type = L_NUMBER;
+    n->num = num;
+    return n;
 }
 
 LList *LList::Create()
 {
-    LList *c = (LList *)lmalloc(sizeof(LList), current_space);
+    size_t size = sizeof(LList);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LList *c = (LList *)lmalloc(size, current_space);
     c->type = L_CONS_CELL;
     c->car = NULL;
@@ -503 +512 @@
   else if (item_type(lpointer)!=L_POINTER)
   {
-    lprint(lpointer);
+    ((LObject *)lpointer)->Print();
     lbreak(" is not a pointer\n");
     exit(0);
@@ -525 +534 @@
     default :
     {
-      lprint(lnumber);
+      ((LObject *)lnumber)->Print();
       lbreak(" is not a number\n");
       exit(0);
@@ -538 +547 @@
     if (item_type(this) != L_STRING)
     {
-        lprint(this);
+        Print();
         lbreak(" is not a string\n");
         exit(0);
@@ -575 +584 @@
   if (item_type(c)!=L_CHARACTER)
   {
-    lprint(c);
+    ((LObject *)c)->Print();
     lbreak("is not a character\n");
     exit(0);
@@ -593 +602 @@
     default :
     {
-      lprint(c);
+      ((LObject *)c)->Print();
       lbreak(" is not a number\n");
       exit(0);
@@ -626 +635 @@
 }
 
-LObject *LArray::Get(long x)
+LObject *LArray::Get(int x)
 {
 #ifdef TYPE_CHECKING
     if (type != L_1D_ARRAY)
     {
-        lprint(this);
+        Print();
         lbreak("is not an array\n");
         exit(0);
     }
 #endif
-    if (x >= size || x < 0)
+    if (x >= (int)len || x < 0)
     {
         lbreak("array reference out of bounds (%d)\n", x);
         exit(0);
     }
-    return GetData()[x];
+    return data[x];
 }
 
@@ -820 +829 @@
 LSymbol *LSymbol::Find(char const *name)
 {
-    LSymbol *p = lsym_root;
+    LSymbol *p = root;
     while (p)
     {
@@ -833 +842 @@
 LSymbol *LSymbol::FindOrCreate(char const *name)
 {
-    LSymbol *p = lsym_root;
-    LSymbol **parent = &lsym_root;
+    LSymbol *p = root;
+    LSymbol **parent = &root;
     while (p)
     {
@@ -861 +870 @@
     p->left = p->right = NULL;
     *parent = p;
-    ltotal_syms++;
+    count++;
 
     current_space = sp;
@@ -900 +909 @@
     if (this && item_type(this) != (ltype)L_CONS_CELL)
     {
-        lprint(this);
+        Print();
         lbreak(" is not a sequence\n");
         exit(0);
@@ -922 +931 @@
   if (l1!=l2)
   {
-    lprint(list1);
-    lprint(list2);
+    ((LObject *)list1)->Print();
+    ((LObject *)list2)->Print();
     lbreak("... are not the same length (pairlis)\n");
     exit(0);
@@ -975 +984 @@
 }
 
-LSymbol *add_c_object(void *symbol, int16_t number)
+LSymbol *add_c_object(void *symbol, int index)
 {
   need_perm_space("add_c_object");
@@ -984 +993 @@
     exit(0);
   }
-  else s->value=new_lisp_object_var(number);
+  else s->value=LObjectVar::Create(index);
   return NULL;
 }
@@ -1239 +1248 @@
       read_ltoken(s, n);                   // read character name
       if (!strcmp(n, "newline"))
-        ret=new_lisp_character('\n');
+        ret = LChar::Create('\n');
       else if (!strcmp(n, "space"))
-        ret=new_lisp_character(' ');
+        ret = LChar::Create(' ');
       else
-        ret=new_lisp_character(n[0]);
+        ret = LChar::Create(n[0]);
     }
     else if (n[1]==0)                           // short hand for function
@@ -1295 +1304 @@
 }
 
-void lprint(void *i)
-{
-  print_level++;
-  if (!i)
-    lprint_string("nil");
-  else
-  {
-    switch ((short)item_type(i))
-    {
-      case L_CONS_CELL :
-      {
-                LList *cs=(LList *)i;
-        lprint_string("(");
-        for (;cs;cs=(LList *)lcdr(cs))    
+void LObject::Print()
+{
+    char buf[32];
+
+    print_level++;
+
+    switch (item_type(this))
+    {
+    case L_CONS_CELL:
+        if (!this)
+        {
+            lprint_string("nil");
+        }
+        else
+        {
+            LList *cs = (LList *)this;
+            lprint_string("(");
+            for (; cs; cs = (LList *)lcdr(cs))
+            {
+                if (item_type(cs) == (ltype)L_CONS_CELL)
                 {
-                  if (item_type(cs)==(ltype)L_CONS_CELL)
-                  {
-                        lprint(cs->car);
+                    cs->car->Print();
                     if (cs->cdr)
-                      lprint_string(" ");
-                  }
-                  else
-                  {
+                        lprint_string(" ");
+                }
+                else
+                {
                     lprint_string(". ");
-                    lprint(cs);
-                    cs=NULL;
-                  }
+                    cs->Print();
+                    cs = NULL;
                 }
-        lprint_string(")");
-      }
-      break;
-      case L_NUMBER :
-      {
-                char num[10];
-                sprintf(num, "%ld", ((LNumber *)i)->num);
-        lprint_string(num);
-      }
-      break;
-      case L_SYMBOL :
-        lprint_string(((LSymbol *)i)->name->GetString());
-      break;
-      case L_USER_FUNCTION :
-      case L_SYS_FUNCTION :
+            }
+            lprint_string(")");
+        }
+        break;
+    case L_NUMBER:
+        sprintf(buf, "%ld", ((LNumber *)this)->num);
+        lprint_string(buf);
+        break;
+    case L_SYMBOL:
+        lprint_string(((LSymbol *)this)->name->GetString());
+        break;
+    case L_USER_FUNCTION:
+    case L_SYS_FUNCTION:
         lprint_string("err... function?");
-      break;
-      case L_C_FUNCTION :
+        break;
+    case L_C_FUNCTION:
         lprint_string("C function, returns number\n");
-      break;
-      case L_C_BOOL :
+        break;
+    case L_C_BOOL:
         lprint_string("C boolean function\n");
-      break;
-      case L_L_FUNCTION :
+        break;
+    case L_L_FUNCTION:
         lprint_string("External lisp function\n");
-            break;
-      case L_STRING :
-      {
-                if (current_print_file)
-                     lprint_string(lstring_value(i));
-                else
-             dprintf("\"%s\"", lstring_value(i));
-      }
-      break;
-
-      case L_POINTER :
-      {
-                char ptr[10];
-                    sprintf(ptr, "%p", lpointer_value(i));
-                lprint_string(ptr);
-      }
-      break;
-      case L_FIXED_POINT :
-      {
-                char num[20];
-                sprintf(num, "%g", (lfixed_point_value(i)>>16)+
-                          ((lfixed_point_value(i)&0xffff))/(double)0x10000);
-                lprint_string(num);
-      } break;
-      case L_CHARACTER :
-      {
-                if (current_print_file)
-                {
-                  uint8_t ch=((LChar *)i)->ch;
-                  current_print_file->write(&ch, 1);
-                } else
-                {
-                  uint16_t ch=((LChar *)i)->ch;
-                  dprintf("#\\");
-                  switch (ch)
-                  {
-                    case '\n' :
-                    { dprintf("newline"); break; }
-                    case ' ' :
-                    { dprintf("space"); break; }
-                    default :
-                      dprintf("%c", ch);
-                  }
-                }
-      } break;
-      case L_OBJECT_VAR :
-      {
-                l_obj_print(((LObjectVar *)i)->number);
-      } break;
-      case L_1D_ARRAY :
-      {
-          LArray *a = (LArray *)i;
-          LObject **data = a->GetData();
-          dprintf("#(");
-          for (int j = 0; j < a->size; j++)
-          {
-              lprint(data[j]);
-              if (j != a->size - 1)
-                  dprintf(" ");
-          }
-          dprintf(")");
-      } break;
-      case L_COLLECTED_OBJECT :
-      {
-                lprint_string("GC_refrence->");
-                lprint(((LRedirect *)i)->new_reference);
-      } break;
-      default :
+        break;
+    case L_STRING:
+        if (current_print_file)
+            lprint_string(lstring_value(this));
+        else
+            dprintf("\"%s\"", lstring_value(this));
+        break;
+    case L_POINTER:
+        sprintf(buf, "%p", lpointer_value(this));
+        lprint_string(buf);
+        break;
+    case L_FIXED_POINT:
+        sprintf(buf, "%g", (lfixed_point_value(this) >> 16) +
+                ((lfixed_point_value(this) & 0xffff)) / (double)0x10000);
+        lprint_string(buf);
+        break;
+    case L_CHARACTER:
+        if (current_print_file)
+        {
+            uint8_t ch = ((LChar *)this)->ch;
+            current_print_file->write(&ch, 1);
+        }
+        else
+        {
+            uint16_t ch = ((LChar *)this)->ch;
+            dprintf("#\\");
+            switch (ch)
+            {
+            case '\n':
+                dprintf("newline"); break;
+            case ' ':
+                dprintf("space"); break;
+            default:
+                dprintf("%c", ch); break;
+            }
+        }
+        break;
+    case L_OBJECT_VAR:
+        l_obj_print(((LObjectVar *)this)->index);
+        break;
+    case L_1D_ARRAY:
+        {
+            LArray *a = (LArray *)this;
+            LObject **data = a->GetData();
+            dprintf("#(");
+            for (size_t j = 0; j < a->len; j++)
+            {
+                data[j]->Print();
+                if (j != a->len - 1)
+                    dprintf(" ");
+            }
+            dprintf(")");
+        }
+        break;
+    case L_COLLECTED_OBJECT:
+        lprint_string("GC_refrence->");
+        ((LRedirect *)this)->ref->Print();
+        break;
+    default:
         dprintf("Shouldn't happen\n");
     }
-  }
-  print_level--;
-  if (!print_level && !current_print_file)
-    dprintf("\n");
+
+    print_level--;
+    if (!print_level && !current_print_file)
+        dprintf("\n");
 }
 
@@ -1432 +1433 @@
   if (item_type(sym)!=L_SYMBOL)
   {
-    lprint(sym);
+    sym->Print();
     lbreak("EVAL : is not a function name (not symbol either)");
     exit(0);
@@ -1461 +1462 @@
     default :
     {
-      lprint(sym);
+      sym->Print();
       lbreak(" is not a function name");
       exit(0);    
@@ -1474 +1475 @@
     if (args<req_min)
     {
-      lprint(arg_list);
-      lprint(sym->name);
+      ((LObject *)arg_list)->Print();
+      sym->name->Print();
       lbreak("\nToo few parameters to function\n");
       exit(0);
     } else if (req_max!=-1 && args>req_max)
     {
-      lprint(arg_list);
-      lprint(sym->name);
+      ((LObject *)arg_list)->Print();
+      sym->name->Print();
       lbreak("\nToo many parameters to function\n");
       exit(0);
@@ -1560 +1561 @@
 {
   bFILE *fp=open_file("preport.out", "wb");
-  pro_print(fp, lsym_root);
+  pro_print(fp, LSymbol::root);
   delete fp;
 }
@@ -1577 +1578 @@
     default :
     {
-      lprint(sym);
+      ((LObject *)sym)->Print();
       lbreak(" is not a function\n");
       exit(0);
@@ -1681 +1682 @@
           else
           {
-        lprint(str_eval[i]);
+        ((LObject *)str_eval[i])->Print();
         lbreak(" is not a character\n");        
         exit(0);
@@ -1690 +1691 @@
       case L_STRING : len+=strlen(lstring_value(str_eval[i])); break;
       default :
-        lprint(prog_list);
+        ((LObject *)prog_list)->Print();
         lbreak("type not supported\n");
         exit(0);
@@ -1731 +1732 @@
   else
   {
-    lprint(prog_list);
+    ((LObject *)prog_list)->Print();
     lbreak("concat operation not supported, try 'string\n");
     exit(0);
@@ -1799 +1800 @@
       {
         ret=eval(CAR(arg_list));  arg_list=CDR(arg_list);
-    lprint(ret);
+        ((LObject *)ret)->Print();
       }
       return ret;
@@ -1815 +1816 @@
         case L_CONS_CELL : ret = LNumber::Create(((LList *)v)->GetLength()); break;
         default :
-        { lprint(v);
+        {
+          ((LObject *)v)->Print();
           lbreak("length : type not supported\n");
         }
@@ -1887 +1889 @@
     } while (arg_list);
 
-    ret=new_lisp_fixed_point(sum);
+    ret = LFixedPoint::Create(sum);
       } else
       { sum=1;
@@ -1909 +1911 @@
     if (item_type(i)!=L_NUMBER)
     {
-      lprint(i);
+      ((LObject *)i)->Print();
       lbreak("/ only defined for numbers, cannot divide ");
       exit(0);
@@ -1968 +1970 @@
             case L_OBJECT_VAR :
             {
-              l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->number, set_to);
+              l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->index, set_to);
             } break;
             default :
@@ -1983 +1985 @@
             car=eval(CAR(CDR(i)));
             if (!car || item_type(car)!=L_CONS_CELL)
-            { lprint(car); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
+            { ((LObject *)car)->Print(); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
             ((LList *)car)->car = (LObject *)set_to;
           } else if (car==cdr_symbol)
@@ -1989 +1991 @@
             car=eval(CAR(CDR(i)));
             if (!car || item_type(car)!=L_CONS_CELL)
-            { lprint(car); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
+            { ((LObject *)car)->Print(); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
             ((LList *)car)->cdr = (LObject *)set_to;
           } else if (car==aref_symbol)
@@ -1999 +2001 @@
             if (item_type(a) != L_1D_ARRAY)
             {
-                lprint(a);
+                a->Print();
                 lbreak("is not an array (aref)\n");
                 exit(0);
             }
 #endif
-            long num=lnumber_value(eval(CAR(CDR(CDR(i)))));
+            int num = lnumber_value(eval(CAR(CDR(CDR(i)))));
 #ifdef TYPE_CHECKING
-            if (num >= a->size || num < 0)
+            if (num >= (int)a->len || num < 0)
             {
               lbreak("aref : value of bounds (%d)\n", num);
@@ -2025 +2027 @@
         default :
         {
-          lprint(i);
+          ((LObject *)i)->Print();
           lbreak("setq/setf only defined for symbols and arrays now..\n");
           exit(0);
@@ -2079 +2081 @@
     if (item_type(var_name)!=L_SYMBOL)
     {
-      lprint(var_name);
+      ((LObject *)var_name)->Print();
       lbreak("should be a symbol (let)\n");
       exit(0);
@@ -2116 +2118 @@
       if (item_type(symbol)!=L_SYMBOL)
       {
-    lprint(symbol);
+        symbol->Print();
     lbreak(" is not a symbol! (DEFUN)\n");
     exit(0);
@@ -2123 +2125 @@
       if (item_type(arg_list)!=L_CONS_CELL)
       {
-    lprint(arg_list);
+    ((LObject *)arg_list)->Print();
     lbreak("is not a lambda list (DEFUN)\n");
     exit(0);
@@ -2188 +2190 @@
         default :
         {
-          lprint(i);
+          ((LObject *)i)->Print();
           lbreak(" is not character type\n");
           exit(0);
@@ -2200 +2202 @@
       if (item_type(i)!=L_NUMBER)
       {
-    lprint(i);
+    ((LObject *)i)->Print();
     lbreak(" is not number type\n");
     exit(0);
       }
-      ret=new_lisp_character(((LNumber *)i)->num);
+      ret = LChar::Create(((LNumber *)i)->num);
     } break;
     case SYS_FUNC_COND:
@@ -2294 +2296 @@
       if (item_type(symb)!=L_SYMBOL)
       {
-    lprint(symb);
+    ((LObject *)symb)->Print();
     lbreak(" is not a symbol (symbol-name)\n");
     exit(0);
@@ -2429 +2431 @@
     case SYS_FUNC_COMMA:
     {
-      lprint(arg_list);
+      ((LObject *)arg_list)->Print();
       lbreak("comma is illegal outside of backquote\n");
       exit(0);
@@ -2444 +2446 @@
         resize_perm(lnumber_value(eval(CAR(arg_list)))); break;
     case SYS_FUNC_COS:
-        ret=new_lisp_fixed_point(lisp_cos(lnumber_value(eval(CAR(arg_list))))); break;
+        ret = LFixedPoint::Create(lisp_cos(lnumber_value(eval(CAR(arg_list))))); break;
     case SYS_FUNC_SIN:
-        ret=new_lisp_fixed_point(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
+        ret = LFixedPoint::Create(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
     case SYS_FUNC_ATAN2:
     {
@@ -2472 +2474 @@
 #ifdef TYPE_CHECKING
         if (item_type(s)!=L_SYMBOL)
-        { lprint(arg_list);
+        {
+          ((LObject *)arg_list)->Print();
           lbreak("expecting (sybmol value) for enum\n");
           exit(0);
@@ -2482 +2485 @@
       default :
       {
-        lprint(arg_list);
+        ((LObject *)arg_list)->Print();
         lbreak("expecting symbol or (symbol value) in enum\n");
         exit(0);
@@ -2678 +2681 @@
       { lbreak("elt : out of range of string\n"); ret=NULL; }
       else
-        ret=new_lisp_character(st[x]);
+        ret = LChar::Create(st[x]);
     } break;
     case SYS_FUNC_LISTP:
@@ -2756 +2759 @@
       else if (x<0)
       { lbreak("SCHAR: index should not be negative\n"); exit(0); }
-      return new_lisp_character(s[x]);
+      return LChar::Create(s[x]);
     } break;
     case SYS_FUNC_SYMBOLP:
@@ -2781 +2784 @@
 
       if (item_type(l1)!=L_CONS_CELL)
-      { lprint(l1); lbreak("first arg should be a list\n"); }
+      { ((LObject *)l1)->Print(); lbreak("first arg should be a list\n"); }
       do
       {
@@ -2875 +2878 @@
   if (item_type(sym)!=L_SYMBOL)
   {
-    lprint(sym);
+    ((LObject *)sym)->Print();
     lbreak("EVAL : is not a function name (not symbol either)");
     exit(0);
@@ -2890 +2893 @@
   if (item_type(fun)!=L_USER_FUNCTION)
   {
-    lprint(sym);
+    ((LObject *)sym)->Print();
     lbreak("is not a user defined function\n");
   }
@@ -2928 +2931 @@
     {
       if (!arg_list)
-      { lprint(sym);  lbreak("too few parameter to function\n"); exit(0); }
+      { ((LObject *)sym)->Print(); lbreak("too few parameter to function\n"); exit(0); }
       l_user_stack.push(eval(CAR(arg_list)));
       f_arg=CDR(f_arg);
@@ -2945 +2948 @@
 
   if (f_arg)
-  { lprint(sym);  lbreak("too many parameter to function\n"); exit(0); }
+  { ((LObject *)sym)->Print(); lbreak("too many parameter to function\n"); exit(0); }
 
 
@@ -2992 +2995 @@
           space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
           PtrRef::stack.son);
-      lprint(prog);
+      ((LObject *)prog)->Print();
 
       dprintf("\n");
@@ -3017 +3020 @@
                   ret = ((LSymbol *)prog)->GetValue();
                   if (item_type(ret)==L_OBJECT_VAR)
-                    ret=l_obj_get(((LObjectVar *)ret)->number);
+                    ret=l_obj_get(((LObjectVar *)ret)->index);
                 }
       } break;
@@ -3037 +3040 @@
           space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
           PtrRef::stack.son);
-    lprint(ret);
+    ((LObject *)ret)->Print();
     dprintf("\n");
   }
@@ -3047 +3050 @@
 
   return ret;
-}
-
-int total_symbols()
-{
-  return ltotal_syms;
 }
 
@@ -3090 +3088 @@
 {
   unsigned int i;
-  lsym_root = NULL;
+  LSymbol::root = NULL;
   total_user_functions = 0;
 
@@ -3110 +3108 @@
   current_space=TMP_SPACE;
   dprintf("Lisp : %d symbols defined, %d system functions, %d pre-compiled functions\n",
-      total_symbols(), sizeof(sys_funcs) / sizeof(*sys_funcs), total_user_functions);
+      LSymbol::count, sizeof(sys_funcs) / sizeof(*sys_funcs), total_user_functions);
 }
 
 void lisp_uninit()
 {
-  free(space[0]);
-  free(space[1]);
-  ldelete_syms(lsym_root);
-  lsym_root=NULL;
-  ltotal_syms=0;
+    free(space[0]);
+    free(space[1]);
+    ldelete_syms(LSymbol::root);
+    LSymbol::root = NULL;
+    LSymbol::count = 0;
 }
 
@@ -3132 +3130 @@
     if (item_type(this) != L_SYMBOL)
     {
-        lprint(this);
+        Print();
         lbreak("is not a symbol\n");
         exit(0);
@@ -3145 +3143 @@
     if (item_type(this) != L_SYMBOL)
     {
-        lprint(this);
+        Print();
         lbreak("is not a symbol\n");
         exit(0);
@@ -3161 +3159 @@
     if (item_type(this) != L_SYMBOL)
     {
-        lprint(this);
+        Print();
         lbreak("is not a symbol\n");
         exit(0);
@@ -3174 +3172 @@
     if (item_type(this) != L_SYMBOL)
     {
-        lprint(this);
+        Print();
         lbreak("is not a symbol\n");
         exit(0);
@@ -3187 +3185 @@
     if (item_type(this) != L_SYMBOL)
     {
-        lprint(this);
+        Print();
         lbreak("is not a symbol\n");
         exit(0);

abuse/trunk/src/lisp/lisp.h

@@ -47 +47 @@
 struct LObject
 {
+    void Print();
+
     ltype type;
 };
@@ -52 +54 @@
 struct LObjectVar : LObject
 {
-    long number;
+    static LObjectVar *Create(int index);
+
+    int index;
 };
 
@@ -73 +77 @@
 struct LRedirect : LObject
 {
-    LObject *new_reference;
+    LObject *ref;
 };
 
@@ -84 +88 @@
     char *GetString();
 
-    char str[1];
+private:
+    char str[1]; /* Can be allocated much larger than 1 */
 };
 
 struct LSymbol : LObject
 {
+    /* Factories */
     static LSymbol *Find(char const *name);
     static LSymbol *FindOrCreate(char const *name);
 
+    /* Methods */
     LString *GetName();
     LObject *GetFunction();
@@ -100 +107 @@
     void SetNumber(long num);
 
+    /* Members */
 #ifdef L_PROFILE
     float time_taken;
@@ -107 +115 @@
     LString *name;
     LSymbol *left, *right; // tree structure
+
+    /* Static members */
+    static LSymbol *root;
+    static size_t count;
 };
 
@@ -126 +138 @@
 struct LArray : LObject
 {
-    static LArray *Create(int size, void *rest);
-
+    /* Factories */
+    static LArray *Create(size_t len, void *rest);
+
+    /* Methods */
     inline LObject **GetData() { return data; }
-    LObject *Get(long x);
-
-    unsigned short size;
-    // size * sizeof (void *) follows1
+    LObject *Get(int x);
+
+    /* Members */
+    size_t len;
 
 private:
-    LObject *data[1];
+    LObject *data[1]; /* Can be allocated much larger than 1 */
 };
 
 struct LChar : LObject
 {
-    int16_t pad;
+    static LChar *Create(uint16_t ch);
+
     uint16_t ch;
 };
@@ -146 +161 @@
 struct LPointer : LObject
 {
+    static LPointer *Create(void *addr);
+
     void *addr;
 };
@@ -151 +168 @@
 struct LFixedPoint : LObject
 {
+    static LFixedPoint *Create(int32_t x);
+
     int32_t x;
 };
@@ -170 +189 @@
 void *lisp_eq(void *n1, void *n2);
 void *lisp_equal(void *n1, void *n2);
-void lprint(void *i);
 void *eval(void *prog);
 void *eval_block(void *list);
@@ -181 +199 @@
 
 void push_onto_list(void *object, void *&list);
-LSymbol *add_c_object(void *symbol, int16_t number);
+LSymbol *add_c_object(void *symbol, int index);
 LSymbol *add_c_function(char const *name, short min_args, short max_args, short number);
 LSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number);
@@ -189 +207 @@
 
 
-LPointer *new_lisp_pointer(void *addr);
-LChar *new_lisp_character(uint16_t ch);
-LFixedPoint *new_lisp_fixed_point(int32_t x);
-LObjectVar *new_lisp_object_var(int16_t number);
 LSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number);
 LSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number);
@@ -209 +223 @@
 void lisp_init(long perm_size, long tmp_size);
 void lisp_uninit();
-extern LSymbol *lsym_root;
 
 extern uint8_t *space[4], *free_space[4];

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -88 +88 @@
 static LArray *CollectArray(LArray *x)
 {
-    size_t s = x->size;
+    size_t s = x->len;
     LArray *a = LArray::Create(s, NULL);
     LObject **src = x->GetData();
@@ -110 +110 @@
         x = (LList *)CDR(x);
         ((LRedirect *)old_x)->type = L_COLLECTED_OBJECT;
-        ((LRedirect *)old_x)->new_reference = p;
+        ((LRedirect *)old_x)->ref = p;
 
         p->car = CollectObject(old_car);
@@ -163 +163 @@
         break;
       case L_CHARACTER:
-        ret = new_lisp_character(lcharacter_value(x));
+        ret = LChar::Create(lcharacter_value(x));
         break;
       case L_C_FUNCTION:
@@ -181 +181 @@
         break;
       case L_POINTER:
-        ret = new_lisp_pointer(lpointer_value(x));
+        ret = LPointer::Create(lpointer_value(x));
         break;
       case L_1D_ARRAY:
@@ -187 +187 @@
         break;
       case L_FIXED_POINT:
-        ret = new_lisp_fixed_point(lfixed_point_value(x));
+        ret = LFixedPoint::Create(lfixed_point_value(x));
         break;
       case L_CONS_CELL:
@@ -193 +193 @@
         break;
       case L_OBJECT_VAR:
-        ret = new_lisp_object_var(((LObjectVar *)x)->number);
+        ret = LObjectVar::Create(((LObjectVar *)x)->index);
         break;
       case L_COLLECTED_OBJECT:
-        ret = ((LRedirect *)x)->new_reference;
+        ret = ((LRedirect *)x)->ref;
         break;
       default:
@@ -206 +206 @@
     }
     ((LRedirect *)x)->type = L_COLLECTED_OBJECT;
-    ((LRedirect *)x)->new_reference = ret;
+    ((LRedirect *)x)->ref = ret;
   }
   else if ((uint8_t *)x < collected_start || (uint8_t *)x >= collected_end)
@@ -224 +224 @@
 static void collect_symbols(LSymbol *root)
 {
-  if (root)
-  {
+    if (!root)
+        return;
+
     root->value = CollectObject(root->value);
     root->function = CollectObject(root->function);
@@ -231 +232 @@
     collect_symbols(root->left);
     collect_symbols(root->right);
-  }
 }
 
@@ -276 +276 @@
 //dump_memory((char *)lsym_root->name, 128, 196);
 //dump_memory((char *)0xb6782025, 32, 48);
-  collect_symbols(lsym_root);
+  collect_symbols(LSymbol::root);
   collect_stacks();
 

abuse/trunk/src/menu.cpp

@@ -117 +117 @@
     default :
     {
-      lprint(arg);
+      ((LObject *)arg)->Print();
       printf(" is not a valid menu option\n");
       exit(0);

abuse/trunk/src/objects.cpp

@@ -495 +495 @@
     frm = LList::Create();
     PtrRef r2(frm);
-    frm->car = new_lisp_pointer(from);
+    frm->car = LPointer::Create(from);
 
     hx = LList::Create();
@@ -899 +899 @@
       if (hit_object)
       {
-    push_onto_list(new_lisp_pointer(hit_object),rlist);
+    push_onto_list(LPointer::Create(hit_object),rlist);
     push_onto_list(l_object,rlist);
       } else
@@ -1247 +1247 @@
     if (item_type(r)!=L_NUMBER)
     {
-      lprint(r);
+      ((LObject *)r)->Print();
       lbreak("Object %s did not return a number from its mover function!\n"
          "It should return a number to indicate its blocked status to the\n"

abuse/trunk/src/particle.cpp

@@ -64 +64 @@
   if (item_type(sym)!=L_SYMBOL)
   {
-    lprint(args);
+    ((LObject *)args)->Print();
     printf("expecting first arg to def-particle to be a symbol!\n");
     exit(0);
@@ -89 +89 @@
   {
     delete fp;
-    lprint(args);
+    ((LObject *)args)->Print();
     fprintf(stderr,"\nparticle sequence : Unable to open %s for reading\n",fn);
     fprintf(stderr,"total files open=%d\n",total_files_open);