Changeset 483Tweet

Timestamp:

Apr 17, 2011, 10:28:16 AM (12 years ago)

Author:

Sam Hocevar

Message:

lisp: move all array-related functions to the LispArray? struct.

Location:

abuse/trunk/src

Files:

• cop.cpp (modified) (3 diffs)
• lisp/lisp.cpp (modified) (8 diffs)
• lisp/lisp.h (modified) (3 diffs)
• lisp/lisp_gc.cpp (modified) (1 diff)
• lisp/lisp_gc.h (modified) (1 diff)

abuse/trunk/src/cop.cpp

@@ -727 +727 @@
     if (o->lvars[just_fired_var])
     {
-      o->draw_double_tint(lnumber_value(lget_array_element(symbol_value(l_player_tints),num)),S_bright_tint);
+      o->draw_double_tint(lnumber_value(((LispArray *)symbol_value(l_player_tints))->Get(num)),S_bright_tint);
       o->lvars[just_fired_var]=0;
     } else
-      o->draw_tint(lnumber_value(lget_array_element(symbol_value(l_player_tints),num)));
+      o->draw_tint(lnumber_value(((LispArray *)symbol_value(l_player_tints))->Get(num)));
   }
   return NULL;
@@ -1021 +1021 @@
     for (i=0;i<tp;i++)
     {
-      int color=lnumber_value(lget_array_element(symbol_value(l_player_text_color),sorted_players[i]->get_tint()));
+      int color=lnumber_value(((LispArray *)symbol_value(l_player_text_color))->Get(sorted_players[i]->get_tint()));
       sprintf(msg,"%3ld %s",(long)sorted_players[i]->kills,sorted_players[i]->name);
       if (sorted_players[i]==local)
@@ -1062 +1062 @@
   {
     enum { NAME_LEN=18 } ;
-    int color=lnumber_value(lget_array_element(symbol_value(l_player_text_color),v->get_tint()));
+    int color=lnumber_value(((LispArray *)symbol_value(l_player_text_color))->Get(v->get_tint()));
     char max_name[NAME_LEN];
     strncpy(max_name,v->name,NAME_LEN-1);

abuse/trunk/src/lisp/lisp.cpp

@@ -220 +220 @@
 }
 
-LispArray *new_lisp_1d_array(int size, void *rest)
+LispArray *LispArray::Create(int size, void *rest)
 {
   p_ref r11(rest);
-  size_t s=sizeof(LispArray)+size*sizeof(void *);
-  if (s<8 + sizeof(intptr_t)) s=8 + sizeof(intptr_t);
-  void *p=(LispArray *)lmalloc(s, current_space);
-  ((LispArray *)p)->type=L_1D_ARRAY;
-  ((LispArray *)p)->size=size;
-  void **data=(void **)(((LispArray *)p)+1);
-  memset(data, 0, size*sizeof(void *));
+  size_t s = sizeof(LispArray)
+           + ((size < 1 ? 1 : size) - 1) * sizeof(LispObject *);
+  LispArray *p = (LispArray *)lmalloc(s, current_space);
+  p->type = L_1D_ARRAY;
+  p->size = size;
+  LispObject **data = p->GetData();
+  memset(data, 0, size * sizeof(LispObject *));
   p_ref r1(p);
 
@@ -238 +238 @@
     {
       x=eval(CAR(CDR(rest)));
-      data=(void **)(((LispArray *)p)+1);
+      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]=CAR(x);
-      }
-      if (x) { lprint(rest); lbreak("(make-array) incorrect list length\n"); exit(0); }
+        if (!x)
+        {
+          lprint(rest);
+          lbreak("(make-array) incorrect list length\n");
+          exit(0);
+        }
+        data[i] = (LispObject *)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=(void **)(((LispArray *)p)+1);
+      data = p->GetData();
       for (int i=0;i<size;i++)
-        data[i]=x;
+        data[i] = (LispObject *)x;
     }
     else
@@ -266 +271 @@
   }
 
-  return ((LispArray *)p);
+  return p;
 }
 
@@ -623 +628 @@
 }
 
-void *lget_array_element(void *a, long x)
+LispObject *LispArray::Get(long x)
 {
 #ifdef TYPE_CHECKING
-  if (item_type(a)!=L_1D_ARRAY)
-  {
-    lprint(a);
-    lbreak("is not an array\n");
-    exit(0);
-  }
-#endif
-  if (x>=((LispArray *)a)->size || x<0)
-  {
-    lbreak("array refrence out of bounds (%d)\n", x);
-    exit(0);
-  }
-  return ((void **)(((LispArray *)a)+1))[x];
+    if (type != L_1D_ARRAY)
+    {
+        lprint(this);
+        lbreak("is not an array\n");
+        exit(0);
+    }
+#endif
+    if (x >= size || x < 0)
+    {
+        lbreak("array reference out of bounds (%d)\n", x);
+        exit(0);
+    }
+    return GetData()[x];
 }
 
@@ -1431 +1436 @@
       case L_1D_ARRAY :
       {
-                LispArray *a=(LispArray *)i;
-                void **data=(void **)(a+1);
-                dprintf("#(");
-                for (int j=0;j<a->size;j++)
-                {
-                  lprint(data[j]);
-                  if (j!=a->size-1)
-                    dprintf(" ");
-                }
-                dprintf(")");
+          LispArray *a = (LispArray *)i;
+          LispObject **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 :
@@ -2026 +2031 @@
           {
 #endif
-            void *a=(LispArray *)eval(CAR(CDR(i)));
+            LispArray *a = (LispArray *)eval(CAR(CDR(i)));
             p_ref r1(a);
 #ifdef TYPE_CHECKING
-            if (item_type(a)!=L_1D_ARRAY)
+            if (item_type(a) != L_1D_ARRAY)
             {
-              lprint(a);
-              lbreak("is not an array (aref)\n");
-              exit(0);
+                lprint(a);
+                lbreak("is not an array (aref)\n");
+                exit(0);
             }
 #endif
             long num=lnumber_value(eval(CAR(CDR(CDR(i)))));
 #ifdef TYPE_CHECKING
-            if (num>=((LispArray *)a)->size || num<0)
+            if (num >= a->size || num < 0)
             {
               lbreak("aref : value of bounds (%d)\n", num);
@@ -2044 +2049 @@
             }
 #endif
-            void **data=(void **)(((LispArray *)a)+1);
-            data[num]=set_to;
+            a->GetData()[num] = (LispObject *)set_to;
 #ifdef TYPE_CHECKING
           } else
@@ -2646 +2650 @@
                 exit(0);
       }
-      ret=new_lisp_1d_array(l, CDR(arg_list));
+      ret = LispArray::Create(l, CDR(arg_list));
     } break;
     case SYS_FUNC_AREF:
     {
       long x=lnumber_value(eval(CAR(CDR(arg_list))));
-      ret=lget_array_element(eval(CAR(arg_list)), x);
+      ret = ((LispArray *)eval(CAR(arg_list)))->Get(x);
     } break;
     case SYS_FUNC_IF_1PROGN:

abuse/trunk/src/lisp/lisp.h

@@ -97 +97 @@
 struct LispArray : LispObject
 {
+    static LispArray *Create(int size, void *rest);
+
+    inline LispObject **GetData() { return data; }
+    LispObject *Get(long x);
+
     unsigned short size;
     // size * sizeof (void *) follows1
+
+private:
+    LispObject *data[1];
 };
 
@@ -129 +137 @@
 void use_user_space(void *addr, long size);
 #define item_type(c) ((c) ? *((ltype *)c) : (ltype)L_CONS_CELL)
-void *lget_array_element(void *a, long x);
 void *lpointer_value(void *lpointer);
 int32_t lnumber_value(void *lnumber);
@@ -176 +183 @@
 LispFixedPoint *new_lisp_fixed_point(int32_t x);
 LispObjectVar *new_lisp_object_var(int16_t number);
-LispArray   *new_lisp_1d_array(int size, void *rest);
 LispSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number);
 LispSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number);

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -86 +86 @@
 static void *collect_array(void *x)
 {
-  long s = ((LispArray *)x)->size;
-  LispArray *a = new_lisp_1d_array(s, NULL);
-  void **src, **dst;
-  src = (void **)(((LispArray *)x)+1);
-  dst = (void **)(a+1);
-  for (int i = 0; i<s; i++)
-    dst[i] = collect_object(src[i]);
-
-  return a;
+    long s = ((LispArray *)x)->size;
+    LispArray *a = LispArray::Create(s, NULL);
+    LispObject **src = ((LispArray *)x)->GetData();
+    LispObject **dst = a->GetData();
+    for (int i = 0; i < s; i++)
+        dst[i] = (LispObject *)collect_object(src[i]);
+
+    return a;
 }
 

abuse/trunk/src/lisp/lisp_gc.h

@@ -23 +23 @@
   public :
   p_ref(void *&ref) { l_ptr_stack.push(&ref); }
+  p_ref(LispObject *&ref) { l_ptr_stack.push((void **)&ref); }
+  p_ref(LispArray *&ref) { l_ptr_stack.push((void **)&ref); }
   ~p_ref() { l_ptr_stack.pop(1); }
 } ;