Changeset 636Tweet

Timestamp:

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

Author:

Sam Hocevar

Message:

lisp: merge the Lisp and LispGC classes and improve coding style.

Location:

abuse/trunk/src

Files:

• chars.cpp (modified) (10 diffs)
• compiled.cpp (modified) (1 diff)
• lcache.cpp (modified) (2 diffs)
• lisp/lisp.cpp (modified) (97 diffs)
• lisp/lisp.h (modified) (16 diffs)
• lisp/lisp_gc.cpp (modified) (10 diffs)
• lisp/lisp_gc.h (modified) (1 diff)
• lisp/lisp_opt.cpp (modified) (1 diff)
• objects.cpp (modified) (2 diffs)

abuse/trunk/src/chars.cpp

@@ -208 +208 @@
      if so report a conflict if any occur */
   LSymbol *s=(LSymbol *)symbol;
-  if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
+  if (DEFINEDP(s->m_value) && (item_type(s->m_value)!=L_OBJECT_VAR))
   {
     ((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)->index;
+  } else if (DEFINEDP(s->m_value))
+  {
+    int index = ((LObjectVar *)s->m_value)->m_index;
     if (index<tiv)
     {
@@ -337 +337 @@
     if (f==l_abil)
     {
-      void *l=CDR(CAR(field));
+      LObject *l = CDR(CAR(field));
       PtrRef r4(l);
       for (i=0; i<TOTAL_ABILITIES; i++)
       {
-    Cell *ab=assoc(LSymbol::FindOrCreate(ability_names[i]),l);
+    Cell *ab = LSymbol::FindOrCreate(ability_names[i])->Assoc(l);
     PtrRef r5(ab);
     if (!NILP(ab))
@@ -348 +348 @@
     } else if (f==l_funs)
     {
-      void *l=CDR(CAR(field));
+      LObject *l = CDR(CAR(field));
       PtrRef r4(l);
       for (i=0; i<TOTAL_OFUNS; i++)
       {
-    Cell *ab=assoc(LSymbol::FindOrCreate(ofun_names[i]),l);
+    Cell *ab = LSymbol::FindOrCreate(ofun_names[i])->Assoc(l);
     PtrRef r5(ab);
     if (!NILP(ab) && lcar(lcdr(ab)))
@@ -359 +359 @@
     } else if (f==l_flags)
     {
-      void *l=CDR(CAR(field));
+      LObject *l = CDR(CAR(field));
       PtrRef r4(l);
       for (i=0; i<TOTAL_CFLAGS; i++)
       {
-    Cell *ab=assoc(LSymbol::FindOrCreate(cflag_names[i]),l);
+
+    Cell *ab = LSymbol::FindOrCreate(cflag_names[i])->Assoc(l);
     PtrRef r5(ab);
     if (!NILP(ab) && lcar(lcdr(ab))->Eval())
@@ -456 +457 @@
 
 
-  Cell *mrph=assoc(l_morph,desc);     // check for morph info
+  Cell *mrph = l_morph->Assoc(desc);     // check for morph info
   morph_power=0;
   if (!NILP(mrph))
@@ -465 +466 @@
   } else morph_mask=-1;
 
-  Cell *sa=assoc(l_state_art,desc);
+  Cell *sa = l_state_art->Assoc(desc);
   if (NILP(sa))
   {
@@ -484 +485 @@
   }
 
-  Cell *range=assoc(l_range,desc);
+  Cell *range = l_range->Assoc(desc);
   if (!NILP(range))
   {
@@ -498 +499 @@
 
 
-  Cell *mf=assoc(l_fields,desc);
+  Cell *mf = l_fields->Assoc(desc);
   if (!NILP(mf))
   {
@@ -512 +513 @@
       if (find<0)
       {
-    lprint(assoc(l_fields,desc));
+    lprint(l_fields->Assoc(desc));
     printf("fields : no such var name \"%s\"\n",name);
     printf("current possiblities are : \n");
@@ -529 +530 @@
 
 
-  Cell *lg=assoc(l_logo,desc);
+  Cell *lg = l_logo->Assoc(desc);
   if (NILP(lg))
   {

abuse/trunk/src/compiled.cpp

@@ -48 +48 @@
   if (sym)
   {
-    if (item_type(((LSymbol *)sym)->value)!=L_NUMBER)
+    if (item_type(((LSymbol *)sym)->m_value)!=L_NUMBER)
       compile_error=1;
     else
-      return lnumber_value(((LSymbol *)sym)->value);
+      return lnumber_value(((LSymbol *)sym)->m_value);
   } else compile_error=1;
   return 0;

abuse/trunk/src/lcache.cpp

@@ -84 +84 @@
         break;
     case L_CHARACTER:
-        fp->write_uint16(lcharacter_value(level));
+        fp->write_uint16(((LChar *)level)->GetValue());
         break;
     case L_STRING:
@@ -126 +126 @@
                 LList *c = LList::Create();
                 if (first)
-                    last->cdr = c;
+                    last->m_cdr = c;
                 else
                     first = c;
                 last = c;
             }
-            last->cdr = (t < 0) ? (LObject *)load_block(fp) : NULL;
+            last->m_cdr = (t < 0) ? (LObject *)load_block(fp) : NULL;
 
             last = first;
-            for (size_t count = abs(t); count--; last = (LList *)last->cdr)
-                last->car = load_block(fp);
+            for (size_t count = abs(t); count--; last = (LList *)last->m_cdr)
+                last->m_car = load_block(fp);
             return first;
         }

abuse/trunk/src/lisp/lisp.cpp

@@ -191 +191 @@
     {
         if (this == &LSpace::Perm || this == &LSpace::Tmp)
-            LispGC::CollectSpace(this, 0);
+            Lisp::CollectSpace(this, 0);
 
         if (size > GetFree())
-            LispGC::CollectSpace(this, 1);
+            Lisp::CollectSpace(this, 1);
 
         if (size > GetFree())
@@ -228 +228 @@
 
     LArray *p = (LArray *)LSpace::Current->Alloc(size);
-    p->type = L_1D_ARRAY;
-    p->len = len;
+    p->m_type = L_1D_ARRAY;
+    p->m_len = len;
     LObject **data = p->GetData();
     memset(data, 0, len * sizeof(LObject *));
@@ -281 +281 @@
 
     LFixedPoint *p = (LFixedPoint *)LSpace::Current->Alloc(size);
-    p->type = L_FIXED_POINT;
-    p->x = x;
+    p->m_type = L_FIXED_POINT;
+    p->m_fixed = x;
     return p;
 }
@@ -291 +291 @@
 
     LObjectVar *p = (LObjectVar *)LSpace::Current->Alloc(size);
-    p->type = L_OBJECT_VAR;
-    p->index = index;
+    p->m_type = L_OBJECT_VAR;
+    p->m_index = index;
     return p;
 }
@@ -303 +303 @@
 
     LPointer *p = (LPointer *)LSpace::Current->Alloc(size);
-    p->type = L_POINTER;
-    p->addr = addr;
+    p->m_type = L_POINTER;
+    p->m_addr = addr;
     return p;
 }
@@ -313 +313 @@
 
     LChar *c = (LChar *)LSpace::Current->Alloc(size);
-    c->type = L_CHARACTER;
-    c->ch = ch;
+    c->m_type = L_CHARACTER;
+    c->m_ch = ch;
     return c;
 }
@@ -321 +321 @@
 {
     LString *s = Create(strlen(string) + 1);
-    strcpy(s->str, string);
+    strcpy(s->m_str, string);
     return s;
 }
@@ -328 +328 @@
 {
     LString *s = Create(length + 1);
-    memcpy(s->str, string, length);
-    s->str[length] = 0;
+    memcpy(s->m_str, string, length);
+    s->m_str[length] = 0;
     return s;
 }
@@ -338 +338 @@
 
     LString *s = (LString *)LSpace::Current->Alloc(size);
-    s->type = L_STRING;
-    s->str[0] = '\0';
+    s->m_type = L_STRING;
+    s->m_str[0] = '\0';
     return s;
 }
@@ -350 +350 @@
 
     LUserFunction *lu = (LUserFunction *)LSpace::Current->Alloc(size);
-    lu->type = L_USER_FUNCTION;
+    lu->m_type = L_USER_FUNCTION;
     lu->arg_list = arg_list;
     lu->block_list = block_list;
@@ -364 +364 @@
                      ? (LSysFunction *)LSpace::Gc.Alloc(size)
                      : (LSysFunction *)LSpace::Perm.Alloc(size);
-    ls->type = L_SYS_FUNCTION;
+    ls->m_type = L_SYS_FUNCTION;
     ls->min_args = min_args;
     ls->max_args = max_args;
@@ -374 +374 @@
 {
     LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
-    ls->type = L_C_FUNCTION;
+    ls->m_type = L_C_FUNCTION;
     return ls;
 }
@@ -381 +381 @@
 {
     LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
-    ls->type = L_C_BOOL;
+    ls->m_type = L_C_BOOL;
     return ls;
 }
@@ -388 +388 @@
 {
     LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
-    ls->type = L_L_FUNCTION;
+    ls->m_type = L_L_FUNCTION;
     return ls;
 }
@@ -399 +399 @@
     PtrRef ref(s);
 
-    s->type = L_SYMBOL;
-    s->name = LString::Create(name);
-    s->value = l_undefined;
-    s->function = l_undefined;
+    s->m_type = L_SYMBOL;
+    s->m_name = LString::Create(name);
+    s->m_value = l_undefined;
+    s->m_function = l_undefined;
 #ifdef L_PROFILE
     s->time_taken = 0;
@@ -414 +414 @@
 
     LNumber *n = (LNumber *)LSpace::Current->Alloc(size);
-    n->type = L_NUMBER;
-    n->num = num;
+    n->m_type = L_NUMBER;
+    n->m_num = num;
     return n;
 }
@@ -424 +424 @@
 
     LList *c = (LList *)LSpace::Current->Alloc(size);
-    c->type = L_CONS_CELL;
-    c->car = NULL;
-    c->cdr = NULL;
+    c->m_type = L_CONS_CELL;
+    c->m_car = NULL;
+    c->m_cdr = NULL;
     return c;
 }
@@ -477 +477 @@
   }
 #endif
-  return ((LPointer *)lpointer)->addr;
+  return ((LPointer *)lpointer)->m_addr;
 }
 
 int32_t lnumber_value(void *lnumber)
 {
-  switch (item_type(lnumber))
-  {
-    case L_NUMBER :
-      return ((LNumber *)lnumber)->num;
-    case L_FIXED_POINT :
-      return (((LFixedPoint *)lnumber)->x)>>16;
-    case L_STRING :
-      return (uint8_t)*lstring_value(lnumber);
-    case L_CHARACTER :
-      return lcharacter_value(lnumber);
-    default :
-    {
-      ((LObject *)lnumber)->Print();
-      lbreak(" is not a number\n");
-      exit(0);
-    }
-  }
-  return 0;
+    switch (item_type(lnumber))
+    {
+    case L_NUMBER:
+        return ((LNumber *)lnumber)->m_num;
+    case L_FIXED_POINT:
+        return ((LFixedPoint *)lnumber)->m_fixed >> 16;
+    case L_STRING:
+        return (uint8_t)*lstring_value(lnumber);
+    case L_CHARACTER:
+        return ((LChar *)lnumber)->m_ch;
+    default:
+        ((LObject *)lnumber)->Print();
+        lbreak(" is not a number\n");
+        exit(0);
+    }
+    return 0;
 }
 
@@ -512 +510 @@
     }
 #endif
-    return str;
+    return m_str;
 }
 
@@ -526 +524 @@
   if (!c) return NULL;
   else if (item_type(c)==(ltype)L_CONS_CELL)
-    return ((LList *)c)->cdr;
+    return ((LList *)c)->m_cdr;
   else
     return NULL;
@@ -535 +533 @@
   if (!c) return NULL;
   else if (item_type(c)==(ltype)L_CONS_CELL)
-    return ((LList *)c)->car;
+    return ((LList *)c)->m_car;
   else return NULL;
 }
 
-uint16_t lcharacter_value(void *c)
+uint16_t LChar::GetValue()
 {
 #ifdef TYPE_CHECKING
-  if (item_type(c)!=L_CHARACTER)
-  {
-    ((LObject *)c)->Print();
-    lbreak("is not a character\n");
-    exit(0);
-  }
-#endif
-  return ((LChar *)c)->ch;
+    if (item_type(this) != L_CHARACTER)
+    {
+        Print();
+        lbreak("is not a character\n");
+        exit(0);
+    }
+#endif
+    return m_ch;
 }
 
@@ -557 +555 @@
   {
     case L_NUMBER :
-      return ((LNumber *)c)->num<<16; break;
+      return ((LNumber *)c)->m_num<<16; break;
     case L_FIXED_POINT :
-      return (((LFixedPoint *)c)->x); break;
+      return (((LFixedPoint *)c)->m_fixed); break;
     default :
     {
@@ -578 +576 @@
     if (t1!=t2) return NULL;
     else if (t1==L_NUMBER)
-    { if (((LNumber *)n1)->num==((LNumber *)n2)->num)
+    { if (((LNumber *)n1)->m_num==((LNumber *)n2)->m_num)
         return true_symbol;
       else return NULL;
     } else if (t1==L_CHARACTER)
     {
-      if (((LChar *)n1)->ch==((LChar *)n2)->ch)
+      if (((LChar *)n1)->m_ch==((LChar *)n2)->m_ch)
         return true_symbol;
       else return NULL;
@@ -598 +596 @@
 {
 #ifdef TYPE_CHECKING
-    if (type != L_1D_ARRAY)
+    if (m_type != L_1D_ARRAY)
     {
         Print();
@@ -605 +603 @@
     }
 #endif
-    if (x >= (int)len || x < 0)
+    if (x >= (int)m_len || x < 0)
     {
         lbreak("array reference out of bounds (%d)\n", x);
         exit(0);
     }
-    return data[x];
+    return m_data[x];
 }
 
@@ -758 +756 @@
   for (cs=(LList *)symbol_list; cs; cs=(LList *)CDR(cs))
   {
-    if (!strcmp( ((char *)((LSymbol *)cs->car)->name)+sizeof(LString), name))
-      return (LSymbol *)(cs->car);
+    if (!strcmp( ((char *)((LSymbol *)cs->m_car)->m_name)+sizeof(LString), name))
+      return (LSymbol *)(cs->m_car);
   }
   return NULL;
@@ -777 +775 @@
     cs=LList::Create();
     s=new_lisp_symbol(name);
-    cs->car=s;
-    cs->cdr=symbol_list;
+    cs->m_car=s;
+    cs->m_cdr=symbol_list;
     symbol_list=cs;
     LSpace::Current = sp;
@@ -792 +790 @@
     while (p)
     {
-        int cmp = strcmp(name, p->name->GetString());
+        int cmp = strcmp(name, p->m_name->GetString());
         if (cmp == 0)
             return p;
-        p = (cmp < 0) ? p->left : p->right;
+        p = (cmp < 0) ? p->m_left : p->m_right;
     }
     return NULL;
@@ -806 +804 @@
     while (p)
     {
-        int cmp = strcmp(name, p->name->GetString());
+        int cmp = strcmp(name, p->m_name->GetString());
         if (cmp == 0)
             return p;
-        parent = (cmp < 0) ? &p->left : &p->right;
+        parent = (cmp < 0) ? &p->m_left : &p->m_right;
         p = *parent;
     }
@@ -818 +816 @@
         LSpace::Current = &LSpace::Perm;
 
+    // These permanent objects cannot be GCed, so malloc() them
     p = (LSymbol *)malloc(sizeof(LSymbol));
-    p->type = L_SYMBOL;
-    p->name = LString::Create(name);
+    p->m_type = L_SYMBOL;
+    p->m_name = LString::Create(name);
 
     // If constant, set the value to ourself
-    p->value = (name[0] == ':') ? p : l_undefined;
-    p->function = l_undefined;
+    p->m_value = (name[0] == ':') ? p : l_undefined;
+    p->m_function = l_undefined;
 #ifdef L_PROFILE
     p->time_taken = 0;
 #endif
-    p->left = p->right = NULL;
+    p->m_left = p->m_right = NULL;
     *parent = p;
     count++;
@@ -840 +839 @@
     if (root)
     {
-        DeleteAllSymbols(root->left);
-        DeleteAllSymbols(root->right);
+        DeleteAllSymbols(root->m_left);
+        DeleteAllSymbols(root->m_right);
         free(root);
     }
 }
 
-void *assoc(void *item, void *list)
-{
-  if (item_type(list)!=(ltype)L_CONS_CELL)
+LObject *LObject::Assoc(LObject *item)
+{
+    if (item_type(this) != L_CONS_CELL)
+        return NULL;
+
+    LObject *list = this;
+    while (list)
+    {
+        if (lisp_eq(CAR(CAR(list)), item))
+            return lcar(list);
+        list = CDR(list);
+    }
+
     return NULL;
-  else
-  {
-    while (list)
-    {
-      if (lisp_eq(CAR(CAR(list)), item))
-        return lcar(list);
-      list=(LList *)(CDR(list));
-    }
-  }
-  return NULL;
 }
 
@@ -907 +906 @@
         first = cur;
       if (last)
-        last->cdr = cur;
+        last->m_cdr = cur;
       last = cur;
 
       LList *cell = LList::Create();
       tmp = (LObject *)lcar(list1);
-      cell->car = tmp;
+      cell->m_car = tmp;
       tmp = (LObject *)lcar(list2);
-      cell->cdr = tmp;
-      cur->car = cell;
-
-      list1 = ((LList *)list1)->cdr;
-      list2 = ((LList *)list2)->cdr;
-    }
-    cur->cdr = (LObject *)list3;
+      cell->m_cdr = tmp;
+      cur->m_car = cell;
+
+      list1 = ((LList *)list1)->m_cdr;
+      list2 = ((LList *)list2)->m_cdr;
+    }
+    cur->m_cdr = (LObject *)list3;
     ret=first;
   } else ret=NULL;
@@ -926 +925 @@
 }
 
-void LSymbol::SetFunction(LObject *fun)
-{
-    function = fun;
+void LSymbol::SetFunction(LObject *function)
+{
+    m_function = function;
 }
 
@@ -935 +934 @@
   need_perm_space("add_sys_function");
   LSymbol *s = LSymbol::FindOrCreate(name);
-  if (s->function!=l_undefined)
+  if (s->m_function!=l_undefined)
   {
     lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
     exit(0);
   }
-  else s->function=new_lisp_sys_function(min_args, max_args, number);
+  else s->m_function=new_lisp_sys_function(min_args, max_args, number);
   return s;
 }
@@ -948 +947 @@
   need_perm_space("add_c_object");
   LSymbol *s=(LSymbol *)symbol;
-  if (s->value!=l_undefined)
+  if (s->m_value!=l_undefined)
   {
     lbreak("add_c_object -> symbol %s already has a value\n", lstring_value(s->GetName()));
     exit(0);
   }
-  else s->value=LObjectVar::Create(index);
+  else s->m_value=LObjectVar::Create(index);
   return NULL;
 }
@@ -962 +961 @@
   need_perm_space("add_c_function");
   LSymbol *s = LSymbol::FindOrCreate(name);
-  if (s->function!=l_undefined)
+  if (s->m_function!=l_undefined)
   {
     lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
     exit(0);
   }
-  else s->function=new_lisp_c_function(min_args, max_args, number);
+  else s->m_function=new_lisp_c_function(min_args, max_args, number);
   return s;
 }
@@ -976 +975 @@
   need_perm_space("add_c_bool_fun");
   LSymbol *s = LSymbol::FindOrCreate(name);
-  if (s->function!=l_undefined)
+  if (s->m_function!=l_undefined)
   {
     lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
     exit(0);
   }
-  else s->function=new_lisp_c_bool(min_args, max_args, number);
+  else s->m_function=new_lisp_c_bool(min_args, max_args, number);
   return s;
 }
@@ -991 +990 @@
   need_perm_space("add_c_bool_fun");
   LSymbol *s = LSymbol::FindOrCreate(name);
-  if (s->function!=l_undefined)
+  if (s->m_function!=l_undefined)
   {
     lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
     exit(0);
   }
-  else s->function=new_user_lisp_function(min_args, max_args, number);
+  else s->m_function=new_user_lisp_function(min_args, max_args, number);
   return s;
 }
@@ -1076 +1075 @@
   PtrRef r1(object), r2(list);
   LList *c = LList::Create();
-  c->car = (LObject *)object;
-  c->cdr = (LObject *)list;
+  c->m_car = (LObject *)object;
+  c->m_cdr = (LObject *)list;
   list=c;
 }
@@ -1099 +1098 @@
     PtrRef r1(cs), r2(c2);
 
-    ((LList *)cs)->car=quote_symbol;
+    ((LList *)cs)->m_car=quote_symbol;
     c2 = LList::Create();
     tmp=Compile(code);
-    ((LList *)c2)->car = (LObject *)tmp;
-    ((LList *)c2)->cdr=NULL;
-    ((LList *)cs)->cdr = (LObject *)c2;
+    ((LList *)c2)->m_car = (LObject *)tmp;
+    ((LList *)c2)->m_cdr=NULL;
+    ((LList *)cs)->m_cdr = (LObject *)c2;
     ret=cs;
   }
@@ -1112 +1111 @@
     PtrRef r1(cs), r2(c2);
 
-    ((LList *)cs)->car=backquote_symbol;
+    ((LList *)cs)->m_car=backquote_symbol;
     c2 = LList::Create();
     tmp=Compile(code);
-    ((LList *)c2)->car = (LObject *)tmp;
-    ((LList *)c2)->cdr=NULL;
-    ((LList *)cs)->cdr = (LObject *)c2;
+    ((LList *)c2)->m_car = (LObject *)tmp;
+    ((LList *)c2)->m_cdr=NULL;
+    ((LList *)cs)->m_cdr = (LObject *)c2;
     ret=cs;
   }  else if (n[0]==',')              // short hand for comma function
@@ -1124 +1123 @@
     PtrRef r1(cs), r2(c2);
 
-    ((LList *)cs)->car=comma_symbol;
+    ((LList *)cs)->m_car=comma_symbol;
     c2 = LList::Create();
     tmp=Compile(code);
-    ((LList *)c2)->car = (LObject *)tmp;
-    ((LList *)c2)->cdr=NULL;
-    ((LList *)cs)->cdr = (LObject *)c2;
+    ((LList *)c2)->m_car = (LObject *)tmp;
+    ((LList *)c2)->m_cdr=NULL;
+    ((LList *)cs)->m_cdr = (LObject *)c2;
     ret=cs;
   }
@@ -1158 +1157 @@
                     read_ltoken(code, n);              // skip the '.'
                     tmp=Compile(code);
-                    ((LList *)last)->cdr = (LObject *)tmp;          // link the last cdr to
+                    ((LList *)last)->m_cdr = (LObject *)tmp;          // link the last cdr to
                     last=NULL;
                   }
@@ -1170 +1169 @@
                   if (!first) first=cur;
                   tmp=Compile(code);
-                  ((LList *)cur)->car = (LObject *)tmp;
+                  ((LList *)cur)->m_car = (LObject *)tmp;
                   if (last)
-                    ((LList *)last)->cdr = (LObject *)cur;
+                    ((LList *)last)->m_cdr = (LObject *)cur;
                   last=cur;
                 }
@@ -1184 +1183 @@
   {
     LNumber *num = LNumber::Create(0);
-    sscanf(n, "%ld", &num->num);
+    sscanf(n, "%ld", &num->m_num);
     ret=num;
   } else if (n[0]=='"')
@@ -1221 +1220 @@
       PtrRef r4(cs), r5(c2);
       tmp = LSymbol::FindOrCreate("function");
-      ((LList *)cs)->car = (LObject *)tmp;
+      ((LList *)cs)->m_car = (LObject *)tmp;
       c2 = LList::Create();
       tmp=Compile(code);
-      ((LList *)c2)->car = (LObject *)tmp;
-      ((LList *)cs)->cdr = (LObject *)c2;
+      ((LList *)c2)->m_car = (LObject *)tmp;
+      ((LList *)cs)->m_cdr = (LObject *)c2;
       ret=cs;
     }
@@ -1287 +1286 @@
                 if (item_type(cs) == (ltype)L_CONS_CELL)
                 {
-                    cs->car->Print();
-                    if (cs->cdr)
+                    cs->m_car->Print();
+                    if (cs->m_cdr)
                         lprint_string(" ");
                 }
@@ -1302 +1301 @@
         break;
     case L_NUMBER:
-        sprintf(buf, "%ld", ((LNumber *)this)->num);
+        sprintf(buf, "%ld", ((LNumber *)this)->m_num);
         lprint_string(buf);
         break;
     case L_SYMBOL:
-        lprint_string(((LSymbol *)this)->name->GetString());
+        lprint_string(((LSymbol *)this)->m_name->GetString());
         break;
     case L_USER_FUNCTION:
@@ -1339 +1338 @@
         if (current_print_file)
         {
-            uint8_t ch = ((LChar *)this)->ch;
+            uint8_t ch = ((LChar *)this)->m_ch;
             current_print_file->write(&ch, 1);
         }
         else
         {
-            uint16_t ch = ((LChar *)this)->ch;
+            uint16_t ch = ((LChar *)this)->m_ch;
             dprintf("#\\");
             switch (ch)
@@ -1358 +1357 @@
         break;
     case L_OBJECT_VAR:
-        l_obj_print(((LObjectVar *)this)->index);
+        l_obj_print(((LObjectVar *)this)->m_index);
         break;
     case L_1D_ARRAY:
@@ -1365 +1364 @@
             LObject **data = a->GetData();
             dprintf("#(");
-            for (size_t j = 0; j < a->len; j++)
+            for (size_t j = 0; j < a->m_len; j++)
             {
                 data[j]->Print();
-                if (j != a->len - 1)
+                if (j != a->m_len - 1)
                     dprintf(" ");
             }
@@ -1376 +1375 @@
     case L_COLLECTED_OBJECT:
         lprint_string("GC_reference->");
-        ((LRedirect *)this)->ref->Print();
+        ((LRedirect *)this)->m_ref->Print();
         break;
     default:
@@ -1400 +1399 @@
 #endif
 
-    LObject *fun = function;
+    LObject *fun = m_function;
     PtrRef ref2(fun);
     PtrRef ref3(arg_list);
@@ -1435 +1434 @@
         {
             ((LObject *)arg_list)->Print();
-            name->Print();
+            m_name->Print();
             lbreak("\nToo few parameters to function\n");
             exit(0);
@@ -1442 +1441 @@
         {
             ((LObject *)arg_list)->Print();
-            name->Print();
+            m_name->Print();
             lbreak("\nToo many parameters to function\n");
             exit(0);
@@ -1474 +1473 @@
             LList *tmp = LList::Create();
             if (first)
-                cur->cdr = tmp;
+                cur->m_cdr = tmp;
             else
                 first = tmp;
@@ -1480 +1479 @@
 
             LObject *val = CAR(arg_list)->Eval();
-            ((LList *)cur)->car = val;
+            ((LList *)cur)->m_car = val;
             arg_list = lcdr(arg_list);
         }
@@ -1508 +1507 @@
   if (p)
   {
-    pro_print(out, p->right);
+    pro_print(out, p->m_right);
     {
       char st[100];
@@ -1514 +1513 @@
       out->write(st, strlen(st));
     }
-    pro_print(out, p->left);
+    pro_print(out, p->m_left);
   }
 }
@@ -1578 +1577 @@
       else
       {
-        na_list->cdr = (LObject *)LList::Create();
+        na_list->m_cdr = (LObject *)LList::Create();
                 na_list=(LList *)CDR(na_list);
       }
@@ -1585 +1584 @@
       if (arg_on[i])
       {
-                na_list->car = (LObject *)CAR(arg_on[i]);
+                na_list->m_car = (LObject *)CAR(arg_on[i]);
                 arg_on[i]=(LList *)CDR(arg_on[i]);
       }
@@ -1593 +1592 @@
     {
       LList *c = LList::Create();
-      c->car = ((LSymbol *)sym)->EvalFunction(first);
+      c->m_car = ((LSymbol *)sym)->EvalFunction(first);
       if (return_list)
-        last_return->cdr=c;
+        last_return->m_cdr=c;
       else
         return_list=c;
@@ -1672 +1671 @@
         {
           if (item_type(CAR(char_list))==L_CHARACTER)
-            *(s++)=((LChar *)CAR(char_list))->ch;
+            *(s++)=((LChar *)CAR(char_list))->m_ch;
           char_list=(LList *)CDR(char_list);
         }
@@ -1706 +1705 @@
   else if (args==NULL)
     return NULL;
-  else if ((LSymbol *) (((LList *)args)->car)==comma_symbol)
+  else if ((LSymbol *) (((LList *)args)->m_car)==comma_symbol)
     return CAR(CDR(args))->Eval();
   else
@@ -1719 +1718 @@
     {
       tmp = CAR(CDR(args))->Eval();
-      ((LList *)last)->cdr = (LObject *)tmp;
+      ((LList *)last)->m_cdr = (LObject *)tmp;
       args=NULL;
     }
@@ -1726 +1725 @@
       cur = LList::Create();
       if (first)
-        ((LList *)last)->cdr = (LObject *)cur;
+        ((LList *)last)->m_cdr = (LObject *)cur;
       else
             first=cur;
       last=cur;
           tmp=backquote_eval(CAR(args));
-          ((LList *)cur)->car = (LObject *)tmp;
+          ((LList *)cur)->m_car = (LObject *)tmp;
        args=CDR(args);
     }
@@ -1737 +1736 @@
       {
     tmp=backquote_eval(args);
-    ((LList *)last)->cdr = (LObject *)tmp;
+    ((LList *)last)->m_cdr = (LObject *)tmp;
     args=NULL;
       }
@@ -1796 +1795 @@
             cur = LList::Create();
             LObject *val = CAR(arg_list)->Eval();
-            cur->car = val;
+            cur->m_car = val;
             if (last)
-                last->cdr = cur;
+                last->m_cdr = cur;
             else
                 first = cur;
@@ -1812 +1811 @@
         PtrRef r1(c);
         LObject *val = CAR(arg_list)->Eval();
-        c->car = val;
+        c->m_car = val;
         val = CAR(CDR(arg_list))->Eval();
-        c->cdr = val;
+        c->m_cdr = val;
         ret = c;
         break;
@@ -1887 +1886 @@
             else if (first)
             {
-                quot = ((LNumber *)i)->num;
+                quot = ((LNumber *)i)->m_num;
                 first = 0;
             }
             else
-                quot /= ((LNumber *)i)->num;
+                quot /= ((LNumber *)i)->m_num;
             arg_list = (LList *)CDR(arg_list);
         }
@@ -1932 +1931 @@
         {
         case L_SYMBOL:
-            switch (item_type(((LSymbol *)i)->value))
+            switch (item_type(((LSymbol *)i)->m_value))
             {
             case L_NUMBER:
-                if (x == L_NUMBER && ((LSymbol *)i)->value != l_undefined)
+                if (x == L_NUMBER && ((LSymbol *)i)->m_value != l_undefined)
                     ((LSymbol *)i)->SetNumber(lnumber_value(set_to));
                 else
@@ -1941 +1940 @@
                 break;
             case L_OBJECT_VAR:
-                l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->index, set_to);
+                l_obj_set(((LObjectVar *)(((LSymbol *)i)->m_value))->m_index, set_to);
                 break;
             default:
                 ((LSymbol *)i)->SetValue((LObject *)set_to);
             }
-            ret = ((LSymbol *)i)->value;
+            ret = ((LSymbol *)i)->m_value;
             break;
         case L_CONS_CELL:   // this better be an 'aref'
         {
 #ifdef TYPE_CHECKING
-            LObject *car = ((LList *)i)->car;
+            LObject *car = ((LList *)i)->m_car;
             if (car == car_symbol)
             {
@@ -1961 +1960 @@
                     exit(0);
                 }
-                ((LList *)car)->car = set_to;
+                ((LList *)car)->m_car = set_to;
             }
             else if (car == cdr_symbol)
@@ -1972 +1971 @@
                     exit(0);
                 }
-                ((LList *)car)->cdr = set_to;
+                ((LList *)car)->m_cdr = set_to;
             }
             else if (car != aref_symbol)
@@ -1994 +1993 @@
                 int num = lnumber_value(CAR(CDR(CDR(i)))->Eval());
 #ifdef TYPE_CHECKING
-                if (num >= (int)a->len || num < 0)
+                if (num >= (int)a->m_len || num < 0)
                 {
                     lbreak("aref : value of bounds (%d)\n", num);
@@ -2024 +2023 @@
         LList *list = (LList *)CAR(CDR(arg_list))->Eval();
         PtrRef r2(list);
-        ret = (LObject *)assoc(item, list);
+        ret = list->Assoc(item);
         break;
     }
@@ -2041 +2040 @@
         PtrRef r2(i2);
         LList *cs = LList::Create();
-        cs->car = i1;
-        cs->cdr = i2;
+        cs->m_car = i1;
+        cs->m_cdr = i2;
         ret = cs;
         break;
@@ -2078 +2077 @@
 #endif
 
-            l_user_stack.push(((LSymbol *)var_name)->value);
+            l_user_stack.push(((LSymbol *)var_name)->m_value);
             tmp = CAR(CDR(CAR(var_list)))->Eval();
             ((LSymbol *)var_name)->SetValue(tmp);
@@ -2180 +2179 @@
         {
         case L_CHARACTER:
-            ret = LNumber::Create(((LChar *)i)->ch);
+            ret = LNumber::Create(((LChar *)i)->m_ch);
             break;
         case L_STRING:
@@ -2203 +2202 @@
             exit(0);
         }
-        ret = LChar::Create(((LNumber *)i)->num);
+        ret = LChar::Create(((LNumber *)i)->m_num);
         break;
     }
@@ -2302 +2301 @@
         }
 #endif
-        ret = symb->name;
+        ret = symb->m_name;
         break;
     }
@@ -2482 +2481 @@
             {
                 LObject *tmp = LNumber::Create(x);
-                ((LSymbol *)sym)->value = tmp;
+                ((LSymbol *)sym)->m_value = tmp;
                 break;
             }
@@ -2499 +2498 @@
                 x = lnumber_value(CAR(CDR(sym))->Eval());
                 LObject *tmp = LNumber::Create(x);
-                ((LSymbol *)sym)->value = tmp;
+                ((LSymbol *)sym)->m_value = tmp;
                 break;
             }
@@ -2545 +2544 @@
             for (void *s = symbol_list; s; s = CDR(s))
                 fprintf(fp, "%8d  %s\n", ((LSymbol *)(CAR(s)))->call_counter,
-                        lstring_value(((LSymbol *)(CAR(s)))->name));
+                        lstring_value(((LSymbol *)(CAR(s)))->m_name));
             fclose(fp);
         }
@@ -2691 +2690 @@
     {
         LObject *v = CAR(arg_list)->Eval();
-        if (item_type(v) != L_NUMBER || (((LNumber *)v)->num != 0))
+        if (item_type(v) != L_NUMBER || (((LNumber *)v)->m_num != 0))
             ret = NULL;
         else
@@ -2806 +2805 @@
     }
     case SYS_FUNC_GC:
-        LispGC::CollectSpace(LSpace::Current, 0);
+        Lisp::CollectSpace(LSpace::Current, 0);
         break;
     case SYS_FUNC_SCHAR:
@@ -2864 +2863 @@
             }
             LObject *tmp = CAR(arg_list)->Eval();
-            ((LList *)l1)->cdr = tmp;
+            ((LList *)l1)->m_cdr = tmp;
             arg_list = (LList *)CDR(arg_list);
         } while (arg_list);
@@ -2971 +2970 @@
 #endif
 
-    LUserFunction *fun = (LUserFunction *)function;
+    LUserFunction *fun = (LUserFunction *)m_function;
 
 #ifdef TYPE_CHECKING
@@ -2996 +2995 @@
     {
         LSymbol *s = (LSymbol *)CAR(f_arg);
-        l_user_stack.push(s->value);
+        l_user_stack.push(s->m_value);
     }
 
@@ -3095 +3094 @@
                 ret = ((LSymbol *)this)->GetValue();
                 if (item_type(ret) == L_OBJECT_VAR)
-                    ret = (LObject *)l_obj_get(((LObjectVar *)ret)->index);
+                    ret = (LObject *)l_obj_get(((LObjectVar *)ret)->m_index);
             }
             break;
@@ -3119 +3118 @@
 
 /*  l_user_stack.push(ret);
-  LispGC::CollectSpace(&LSpace::Perm);
+  Lisp::CollectSpace(&LSpace::Perm);
   ret=l_user_stack.pop(1);  */
 
     return ret;
 }
-
-void l_comp_init();
 
 void Lisp::Init()
@@ -3144 +3141 @@
     LSpace::Current = &LSpace::Perm;
 
-    l_comp_init();
+    InitConstants();
+
     for(size_t i = 0; i < sizeof(sys_funcs) / sizeof(*sys_funcs); i++)
         add_sys_function(sys_funcs[i].name,
@@ -3179 +3177 @@
     }
 #endif
-    return name;
+    return m_name;
 }
 
@@ -3192 +3190 @@
     }
 #endif
-    if (value != l_undefined && item_type(value) == L_NUMBER)
-        ((LNumber *)value)->num = num;
+    if (m_value != l_undefined && item_type(m_value) == L_NUMBER)
+        ((LNumber *)m_value)->m_num = num;
     else
-        value = LNumber::Create(num);
+        m_value = LNumber::Create(num);
 }
 
@@ -3208 +3206 @@
     }
 #endif
-    value = val;
+    m_value = val;
 }
 
@@ -3221 +3219 @@
     }
 #endif
-    return function;
+    return m_function;
 }
 
@@ -3234 +3232 @@
     }
 #endif
-    return value;
-}
-
+    return m_value;
+}
+

abuse/trunk/src/lisp/lisp.h

@@ -38 +38 @@
        L_FIXED_POINT, L_COLLECTED_OBJECT };
 
-typedef uint32_t ltype;    // make sure structures aren't packed differently on various compiler
+typedef uint8_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
@@ -73 +66 @@
     /* Methods */
     LObject *Eval();
+    LObject *Assoc(LObject *item);
     void Print();
 
     /* Members */
-    ltype type;
+    ltype m_type;
 };
 
@@ -85 +79 @@
 
     /* Members */
-    int index;
+    int m_index;
 };
 
@@ -97 +91 @@
 
     /* Members */
-    LObject *cdr, *car;
+    LObject *m_cdr, *m_car;
 };
 
@@ -106 +100 @@
 
     /* Members */
-    long num;
+    long m_num;
 };
 
@@ -112 +106 @@
 {
     /* Members */
-    LObject *ref;
+    LObject *m_ref;
 };
 
@@ -127 +121 @@
     /* Members */
 private:
-    char str[1]; /* Can be allocated much larger than 1 */
+    char m_str[1]; /* Can be allocated much larger than 1 */
 };
 
@@ -152 +146 @@
     float time_taken;
 #endif
-    LObject *value;
-    LObject *function;
-    LString *name;
-    LSymbol *left, *right; // tree structure
+    LObject *m_value;
+    LObject *m_function;
+    LString *m_name;
+    LSymbol *m_left, *m_right; // tree structure
 
     /* Static members */
@@ -183 +177 @@
 
     /* Methods */
-    inline LObject **GetData() { return data; }
+    inline LObject **GetData() { return m_data; }
     LObject *Get(int x);
 
     /* Members */
-    size_t len;
+    size_t m_len;
 
 private:
-    LObject *data[1]; /* Can be allocated much larger than 1 */
+    LObject *m_data[1]; /* Can be allocated much larger than 1 */
 };
 
@@ -198 +192 @@
     static LChar *Create(uint16_t ch);
 
-    /* Members */
-    uint16_t ch;
+    /* Methods */
+    uint16_t GetValue();
+
+    /* Members */
+    uint16_t m_ch;
 };
 
@@ -208 +205 @@
 
     /* Members */
-    void *addr;
+    void *m_addr;
 };
 
@@ -217 +214 @@
 
     /* Members */
-    int32_t x;
-};
-
-static inline LObject *&CAR(void *x) { return ((LList *)x)->car; }
-static inline LObject *&CDR(void *x) { return ((LList *)x)->cdr; }
+    int32_t m_fixed;
+};
+
+class Lisp
+{
+public:
+    static void Init();
+    static void Uninit();
+
+    static void InitConstants();
+
+    // Collect temporary or permanent spaces
+    static void CollectSpace(LSpace *which_space, int grow);
+
+private:
+    static LArray *CollectArray(LArray *x);
+    static LList *CollectList(LList *x);
+    static LObject *CollectObject(LObject *x);
+    static void CollectSymbols(LSymbol *root);
+    static void CollectStacks();
+};
+
+static inline LObject *&CAR(void *x) { return ((LList *)x)->m_car; }
+static inline LObject *&CDR(void *x) { return ((LList *)x)->m_cdr; }
 static inline ltype item_type(void *x) { if (x) return *(ltype *)x; return L_CONS_CELL; }
 
@@ -228 +244 @@
 void *lpointer_value(void *lpointer);
 int32_t lnumber_value(void *lnumber);
-unsigned short lcharacter_value(void *c);
 long lfixed_point_value(void *c);
 void *lisp_atom(void *i);
@@ -236 +251 @@
 void *lisp_equal(void *n1, void *n2);
 void *eval_block(void *list);
-void *assoc(void *item, void *list);
 void resize_tmp(size_t new_size);
 void resize_perm(size_t new_size);
@@ -258 +272 @@
 
 int end_of_program(char *s);
-void lisp_init();
-void lisp_uninit();
 
 void *nth(int num, void *list);
@@ -265 +277 @@
 int32_t lisp_sin(int32_t x);
 int32_t lisp_cos(int32_t x);
-void restore_heap(void *val, int heap);
-void *mark_heap(int heap);
 
 extern "C" {

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -41 +41 @@
 static uint8_t *cstart, *cend, *collected_start, *collected_end;
 
-LArray *LispGC::CollectArray(LArray *x)
-{
-    size_t s = x->len;
+LArray *Lisp::CollectArray(LArray *x)
+{
+    size_t s = x->m_len;
     LArray *a = LArray::Create(s, NULL);
     LObject **src = x->GetData();
@@ -53 +53 @@
 }
 
-LList *LispGC::CollectList(LList *x)
+LList *Lisp::CollectList(LList *x)
 {
     LList *prev = NULL, *first = NULL;
@@ -60 +60 @@
     {
         LList *p = LList::Create();
-        LObject *old_car = x->car;
+        LObject *old_car = x->m_car;
         LObject *old_x = x;
         x = (LList *)CDR(x);
-        ((LRedirect *)old_x)->type = L_COLLECTED_OBJECT;
-        ((LRedirect *)old_x)->ref = p;
-
-        p->car = CollectObject(old_car);
+        ((LRedirect *)old_x)->m_type = L_COLLECTED_OBJECT;
+        ((LRedirect *)old_x)->m_ref = p;
+
+        p->m_car = CollectObject(old_car);
 
         if (prev)
-            prev->cdr = p;
+            prev->m_cdr = p;
         else
             first = p;
@@ -75 +75 @@
     }
     if (x)
-        prev->cdr = CollectObject(x);
+        prev->m_cdr = CollectObject(x);
 
     return first; // we already set the collection pointers
 }
 
-LObject *LispGC::CollectObject(LObject *x)
+LObject *Lisp::CollectObject(LObject *x)
 {
     LObject *ret = x;
@@ -92 +92 @@
             break;
         case L_NUMBER:
-            ret = LNumber::Create(((LNumber *)x)->num);
+            ret = LNumber::Create(((LNumber *)x)->m_num);
             break;
         case L_SYS_FUNCTION:
@@ -111 +111 @@
             break;
         case L_CHARACTER:
-            ret = LChar::Create(lcharacter_value(x));
+            ret = LChar::Create(((LChar *)x)->m_ch);
             break;
         case L_C_FUNCTION:
@@ -141 +141 @@
             break;
         case L_OBJECT_VAR:
-            ret = LObjectVar::Create(((LObjectVar *)x)->index);
+            ret = LObjectVar::Create(((LObjectVar *)x)->m_index);
             break;
         case L_COLLECTED_OBJECT:
-            ret = ((LRedirect *)x)->ref;
+            ret = ((LRedirect *)x)->m_ref;
             break;
         default:
@@ -150 +150 @@
             break;
         }
-        ((LRedirect *)x)->type = L_COLLECTED_OBJECT;
-        ((LRedirect *)x)->ref = ret;
+        ((LRedirect *)x)->m_type = L_COLLECTED_OBJECT;
+        ((LRedirect *)x)->m_ref = ret;
     }
     else if ((uint8_t *)x < collected_start || (uint8_t *)x >= collected_end)
@@ -172 +172 @@
 }
 
-void LispGC::CollectSymbols(LSymbol *root)
+void Lisp::CollectSymbols(LSymbol *root)
 {
     if (!root)
         return;
 
-    root->value = CollectObject(root->value);
-    root->function = CollectObject(root->function);
-    root->name = (LString *)CollectObject(root->name);
-    CollectSymbols(root->left);
-    CollectSymbols(root->right);
-}
-
-void LispGC::CollectStacks()
+    root->m_value = CollectObject(root->m_value);
+    root->m_function = CollectObject(root->m_function);
+    root->m_name = (LString *)CollectObject(root->m_name);
+    CollectSymbols(root->m_left);
+    CollectSymbols(root->m_right);
+}
+
+void Lisp::CollectStacks()
 {
     void **d = l_user_stack.sdata;
@@ -205 +205 @@
 }
 
-void LispGC::CollectSpace(LSpace *which_space, int grow)
+void Lisp::CollectSpace(LSpace *which_space, int grow)
 {
     LSpace *old_space = LSpace::Current;

abuse/trunk/src/lisp/lisp_gc.h

@@ -15 +15 @@
 // Stack user progs can push data and have it GCed
 extern GrowStack<void> l_user_stack;
-
-class LispGC
-{
-public:
-    // Collect temporary or permanent spaces
-    static void CollectSpace(LSpace *which_space, int grow);
-
-private:
-    static LArray *CollectArray(LArray *x);
-    static LList *CollectList(LList *x);
-    static LObject *CollectObject(LObject *x);
-    static void CollectSymbols(LSymbol *root);
-    static void CollectStacks();
-};
 
 // This pointer reference stack lists all pointers to temporary lisp

abuse/trunk/src/lisp/lisp_opt.cpp

@@ -93 +93 @@
 }
 
-void l_comp_init()
+void Lisp::InitConstants()
 {
     // This needs to be defined first
-    l_undefined = LSymbol::FindOrCreate(":UNDEFINED");
-
+    LSymbol *tmp = LSymbol::FindOrCreate(":UNDEFINED");
+    l_undefined = tmp;
     // Collection problems result if we don't do this
-    ((LSymbol *)l_undefined)->function = NULL;
-    ((LSymbol *)l_undefined)->value = NULL;
+    tmp->m_function = NULL;
+    tmp->m_value = NULL;
 
     true_symbol = LSymbol::FindOrCreate("T");

abuse/trunk/src/objects.cpp

@@ -488 +488 @@
     am = LList::Create();
     PtrRef r1(am);
-    am->car = LNumber::Create(amount);
+    am->m_car = LNumber::Create(amount);
 
     frm = LList::Create();
     PtrRef r2(frm);
-    frm->car = LPointer::Create(from);
+    frm->m_car = LPointer::Create(from);
 
     hx = LList::Create();
     PtrRef r3(hx);
-    hx->car = LNumber::Create(hitx);
+    hx->m_car = LNumber::Create(hitx);
 
     hy = LList::Create();
     PtrRef r4(hy);
-    hy->car = LNumber::Create(hity);
+    hy->m_car = LNumber::Create(hity);
 
     px = LList::Create();
     PtrRef r5(px);
-    px->car = LNumber::Create(push_xvel);
+    px->m_car = LNumber::Create(push_xvel);
 
     py = LList::Create();
     PtrRef r6(py);
-    py->car = LNumber::Create(push_yvel);
-
-    px->cdr = py;
-    hy->cdr = px;
-    hx->cdr = hy;
-    frm->cdr = hx;
-    am->cdr = frm;
+    py->m_car = LNumber::Create(push_yvel);
+
+    px->m_cdr = py;
+    hy->m_cdr = px;
+    hx->m_cdr = hy;
+    frm->m_cdr = hx;
+    am->m_cdr = frm;
 
     time_marker *prof1 = NULL;
@@ -1203 +1203 @@
     lcx = LList::Create();
     PtrRef r1(lcx);
-    lcx->car = LNumber::Create(cx);
+    lcx->m_car = LNumber::Create(cx);
 
     lcy = LList::Create();
     PtrRef r2(lcy);
-    lcy->car = LNumber::Create(cy);
+    lcy->m_car = LNumber::Create(cy);
 
     lb = LList::Create();
     PtrRef r3(lb);
-    lb->car = LNumber::Create(button);
-
-    lcx->cdr = lcy;
-    lcy->cdr = lb;
+    lb->m_car = LNumber::Create(button);
+
+    lcx->m_cdr = lcy;
+    lcy->m_cdr = lb;
 
     void *m = LSpace::Tmp.Mark();