Changeset 133Tweet

Timestamp:

Apr 10, 2008, 11:07:07 PM (15 years ago)

Author:

Sam Hocevar

Message:

• Made lisp.cpp slightly more readable by using an enum instead of hardcoded values for the system functions.

Location:

abuse/trunk/src/lisp

Files:

• Makefile.am (modified) (1 diff)
• lisp.cpp (modified) (139 diffs)
• symbols.hpp (added)

abuse/trunk/src/lisp/Makefile.am

@@ -7 +7 @@
     lisp_gc.cpp lisp_gc.hpp \
     trig.cpp \
-    stack.hpp \
+    stack.hpp symbols.hpp \
     $(NULL)
 

abuse/trunk/src/lisp/lisp.cpp

@@ -21 +21 @@
 #include "lisp.hpp"
 #include "lisp_gc.hpp"
+#include "symbols.hpp"
+
 #ifdef NO_LIBS
-#include "fakelib.hpp"
+#   include "fakelib.hpp"
 #else
-#include "status.hpp"
-#include "macs.hpp"
-#include "specs.hpp"
-#include "dprint.hpp"
-#include "cache.hpp"
-#include "dev.hpp"
+#   include "status.hpp"
+#   include "macs.hpp"
+#   include "specs.hpp"
+#   include "dprint.hpp"
+#   include "cache.hpp"
+#   include "dev.hpp"
 #endif
 
@@ -44 +46 @@
 
 
-char *space[4],*free_space[4];
-int space_size[4],print_level=0,trace_level=0,trace_print_level=1000;
+char *space[4], *free_space[4];
+int space_size[4], print_level=0, trace_level=0, trace_print_level=1000;
 int total_user_functions;
 
 int current_space;  // normally set to TMP_SPACE, unless compiling or other needs
 
-// when you don't need as much as strcmp, this is faster...
-inline int streq(char const *s1, char const *s2)
-{
-  while (*s1)
-  {
-    if (*(s1++)!=*(s2++))
-      return 0;
-  }
-  return (*s2==0);
-}
-
 int break_level=0;
 
 void l1print(void *block)
 {
-  if (!block)
-    lprint(block);
-  else
-  {
-    if (item_type(block)==L_CONS_CELL)
-    {
-      dprintf("(");
-      for (;block && item_type(block)==L_CONS_CELL;block=CDR(block))
-      {
-    void *a=CAR(block);
-    if (item_type(a)==L_CONS_CELL)
-      dprintf("[...]");
-    else lprint(a);
-      }
-      if (block)
-      {
+    if(!block || item_type(block) != L_CONS_CELL)
+    {
+        lprint(block);
+        return;
+    }
+
+    dprintf("(");
+    for( ; block && item_type(block) == L_CONS_CELL; block = CDR(block))
+    {
+        void *a = CAR(block);
+        if(item_type(a) == L_CONS_CELL)
+            dprintf("[...]");
+        else
+            lprint(a);
+    }
+    if (block)
+    {
         dprintf(" . ");
-    lprint(block);
-      }
-      dprintf(")");
-    } else lprint(block);
-  }
-}
-
-void where_print(int max_lev=-1)
-{
-  dprintf("Main program\n");
-  if (max_lev==-1) max_lev=l_ptr_stack.son;
-  else if (max_lev>=l_ptr_stack.son) max_lev=l_ptr_stack.son-1;
-
-  for (int i=0;i<max_lev;i++)
-  {
-    dprintf("%d> ",i);
-    lprint(*l_ptr_stack.sdata[i]);
-  }
+        lprint(block);
+    }
+    dprintf(")");
+}
+
+void where_print(int max_lev = -1)
+{
+    dprintf("Main program\n");
+    if (max_lev==-1) max_lev=l_ptr_stack.son;
+    else if (max_lev>=l_ptr_stack.son) max_lev=l_ptr_stack.son-1;
+
+    for (int i=0;i<max_lev;i++)
+    {
+        dprintf("%d> ", i);
+        lprint(*l_ptr_stack.sdata[i]);
+    }
 }
 
 void print_trace_stack(int max_levels)
 {
-  where_print(max_levels);
+    where_print(max_levels);
 }
 
@@ -115 +105 @@
   va_list ap;
   va_start(ap, format);
-  vsprintf(st,format,ap);
+  vsprintf(st, format, ap);
   va_end(ap);
-  dprintf("%s\n",st);
+  dprintf("%s\n", st);
   int cont=0;
   do
   {
     dprintf("type q to quit\n");
-    dprintf("%d. Break> ",break_level);
-    dgets(st,300);
-    if (!strcmp(st,"c") || !strcmp(st,"cont") || !strcmp(st,"continue"))
+    dprintf("%d. Break> ", break_level);
+    dgets(st, 300);
+    if (!strcmp(st, "c") || !strcmp(st, "cont") || !strcmp(st, "continue"))
       cont=1;
-    else if (!strcmp(st,"w") || !strcmp(st,"where"))
+    else if (!strcmp(st, "w") || !strcmp(st, "where"))
       where_print();
-    else if (!strcmp(st,"q") || !strcmp(st,"quit"))
+    else if (!strcmp(st, "q") || !strcmp(st, "quit"))
       exit(1);
-    else if (!strcmp(st,"e") || !strcmp(st,"env") || !strcmp(st,"environment"))
+    else if (!strcmp(st, "e") || !strcmp(st, "env") || !strcmp(st, "environment"))
     {
       dprintf("Enviorment : \nnot supported right now\n");
 
-    } else if (!strcmp(st,"h") || !strcmp(st,"help") || !strcmp(st,"?"))
+    }
+    else if (!strcmp(st, "h") || !strcmp(st, "help") || !strcmp(st, "?"))
     {
       dprintf("CLIVE Debugger\n");
@@ -164 +155 @@
   if (current_space!=PERM_SPACE && current_space!=GC_SPACE)
   {
-    lbreak("%s : action requires permanant space\n",why);
+    lbreak("%s : action requires permanant space\n", why);
     exit(0);
   }
@@ -181 +172 @@
 void *lmalloc(int size, int which_space)
 {
-  return malloc(size); /* XXX */
+  return malloc(size); /* XXX FIXME: do we want to fix this one day? */
 
 #ifdef WORD_ALIGN
@@ -203 +194 @@
     if (fart)
     {
-      lbreak("lisp : cannot malloc %d bytes in space #%d\n",size,which_space);
+      lbreak("lisp : cannot malloc %d bytes in space #%d\n", size, which_space);
       exit(0);
     }
@@ -229 +220 @@
   long s=sizeof(lisp_1d_array)+size*sizeof(void *);
   if (s<8) s=8;
-  void *p=(lisp_1d_array *)lmalloc(s,current_space);
+  void *p=(lisp_1d_array *)lmalloc(s, current_space);
   ((lisp_1d_array *)p)->type=L_1D_ARRAY;
   ((lisp_1d_array *)p)->size=size;
   void **data=(void **)(((lisp_1d_array *)p)+1);
-  memset(data,0,size*sizeof(void *));
+  memset(data, 0, size*sizeof(void *));
   p_ref r1(p);
 
@@ -243 +234 @@
       x=eval(CAR(CDR(rest)));
       data=(void **)(((lisp_1d_array *)p)+1);
-      for (int i=0;i<size;i++,x=CDR(x))
+      for (int i=0;i<size;i++, x=CDR(x))
       {
     if (!x)
@@ -275 +266 @@
 lisp_fixed_point *new_lisp_fixed_point(int32_t x)
 {
-  lisp_fixed_point *p=(lisp_fixed_point *)lmalloc(sizeof(lisp_fixed_point),current_space);
+  lisp_fixed_point *p=(lisp_fixed_point *)lmalloc(sizeof(lisp_fixed_point), current_space);
   p->type=L_FIXED_POINT;
   p->x=x;
@@ -284 +275 @@
 lisp_object_var *new_lisp_object_var(int16_t number)
 {
-  lisp_object_var *p=(lisp_object_var *)lmalloc(sizeof(lisp_object_var),current_space);
+  lisp_object_var *p=(lisp_object_var *)lmalloc(sizeof(lisp_object_var), current_space);
   p->type=L_OBJECT_VAR;
   p->number=number;
@@ -294 +285 @@
 {
   if (addr==NULL) return NULL;
-  lisp_pointer *p=(lisp_pointer *)lmalloc(sizeof(lisp_pointer),current_space);
+  lisp_pointer *p=(lisp_pointer *)lmalloc(sizeof(lisp_pointer), current_space);
   p->type=L_POINTER;
   p->addr=addr;
@@ -302 +293 @@
 struct lisp_character *new_lisp_character(uint16_t ch)
 {
-  lisp_character *c=(lisp_character *)lmalloc(sizeof(lisp_character),current_space);
+  lisp_character *c=(lisp_character *)lmalloc(sizeof(lisp_character), current_space);
   c->type=L_CHARACTER;
   c->ch=ch;
@@ -313 +304 @@
   if (size<8) size=8;
 
-  lisp_string *s=(lisp_string *)lmalloc(size,current_space);
+  lisp_string *s=(lisp_string *)lmalloc(size, current_space);
   s->type=L_STRING;
   char *sloc=((char *)s)+sizeof(lisp_string);
-  strcpy(sloc,string);
+  strcpy(sloc, string);
   return s;
 }
@@ -324 +315 @@
   int size=sizeof(lisp_string)+length+1;
   if (size<8) size=8;
-  lisp_string *s=(lisp_string *)lmalloc(size,current_space);
+  lisp_string *s=(lisp_string *)lmalloc(size, current_space);
   s->type=L_STRING;
   char *sloc=((char *)s)+sizeof(lisp_string);
-  memcpy(sloc,string,length);
+  memcpy(sloc, string, length);
   sloc[length]=0;
   return s;
@@ -336 +327 @@
   int size=sizeof(lisp_string)+length;
   if (size<8) size=8;
-  lisp_string *s=(lisp_string *)lmalloc(size,current_space);
+  lisp_string *s=(lisp_string *)lmalloc(size, current_space);
   s->type=L_STRING;
   char *sloc=((char *)s)+sizeof(lisp_string);
-  strcpy(sloc,"");
+  strcpy(sloc, "");
   return s;
 }
@@ -346 +337 @@
 lisp_user_function *new_lisp_user_function(void *arg_list, void *block_list)
 {
-  p_ref r1(arg_list),r2(block_list);
-  lisp_user_function *lu=(lisp_user_function *)lmalloc(sizeof(lisp_user_function),current_space);
+  p_ref r1(arg_list), r2(block_list);
+  lisp_user_function *lu=(lisp_user_function *)lmalloc(sizeof(lisp_user_function), current_space);
   lu->type=L_USER_FUNCTION;
   lu->arg_list=arg_list;
@@ -360 +351 @@
     current_space=PERM_SPACE;       // make sure all functions get defined in permanant space
 
-  lisp_user_function *lu=(lisp_user_function *)lmalloc(sizeof(lisp_user_function),current_space);
+  lisp_user_function *lu=(lisp_user_function *)lmalloc(sizeof(lisp_user_function), current_space);
   lu->type=L_USER_FUNCTION;
   lu->alist=arg_list;
@@ -422 +413 @@
 lisp_number *new_lisp_node(long num)
 {
-  lisp_number *n=(lisp_number *)lmalloc(sizeof(lisp_number),current_space);
+  lisp_number *n=(lisp_number *)lmalloc(sizeof(lisp_number), current_space);
   n->type=L_NUMBER;
   n->num=num;
@@ -430 +421 @@
 lisp_symbol *new_lisp_symbol(char *name)
 {
-  lisp_symbol *s=(lisp_symbol *)lmalloc(sizeof(lisp_symbol),current_space);
+  lisp_symbol *s=(lisp_symbol *)lmalloc(sizeof(lisp_symbol), current_space);
   s->type=L_SYMBOL;
   s->name=new_lisp_string(name);
@@ -443 +434 @@
 lisp_number *new_lisp_number(long num)
 {
-  lisp_number *s=(lisp_number *)lmalloc(sizeof(lisp_number),current_space);
+  lisp_number *s=(lisp_number *)lmalloc(sizeof(lisp_number), current_space);
   s->type=L_NUMBER;
   s->num=num;
@@ -452 +443 @@
 cons_cell *new_cons_cell()
 {
-  cons_cell *c=(cons_cell *)lmalloc(sizeof(cons_cell),current_space);
+  cons_cell *c=(cons_cell *)lmalloc(sizeof(cons_cell), current_space);
   c->type=L_CONS_CELL;
   c->car=NULL;
@@ -468 +459 @@
     {
       if (*loc=='\n') lines++;
-      dprintf("%c",*loc);
+      dprintf("%c", *loc);
     }
     dprintf("\nPROGRAM LOCATION : \n");
   }
   if (cause)
-    dprintf("ERROR MESSAGE : %s\n",cause);
+    dprintf("ERROR MESSAGE : %s\n", cause);
   lbreak("");
   exit(0);
@@ -483 +474 @@
   if (num<0)
   {
-    lbreak("NTH: %d is not a nonnegative fixnum and therefore not a valid index\n",num);
+    lbreak("NTH: %d is not a nonnegative fixnum and therefore not a valid index\n", num);
     exit(1);
   }
@@ -607 +598 @@
   else if ((n1 && !n2) || (n2 && !n1)) return NULL;
   {
-    int t1=*((ltype *)n1),t2=*((ltype *)n2);
+    int t1=*((ltype *)n1), t2=*((ltype *)n2);
     if (t1!=t2) return NULL;
     else if (t1==L_NUMBER)
@@ -639 +630 @@
   if (x>=((lisp_1d_array *)a)->size || x<0)
   {
-    lbreak("array refrence out of bounds (%d)\n",x);
+    lbreak("array refrence out of bounds (%d)\n", x);
     exit(0);
   }
@@ -647 +638 @@
 void *lisp_equal(void *n1, void *n2)
 {
-
-  if (!n1 && !n2)           // if both nil, then equal
-    return true_symbol;    
-  else if ((n1 && !n2) || (n2 && !n1))   // one nil, nope
-    return NULL;
-  else
-  {
-    int t1=item_type(n1),t2=item_type(n2);
-    if (t1!=t2) return NULL;
-    else
-    {
-      switch (t1)
-      {
+    if(!n1 && !n2) // if both nil, then equal
+        return true_symbol;
+
+    if(!n1 || !n2) // one nil, nope
+        return NULL;
+
+    int t1 = item_type(n1), t2 = item_type(n2);
+    if(t1 != t2)
+        return NULL;
+
+    switch (t1)
+    {
     case L_STRING :
-    { if (streq(lstring_value(n1),lstring_value(n2))) return true_symbol; else return NULL; }
-    break;
+        if (!strcmp(lstring_value(n1), lstring_value(n2)))
+            return true_symbol;
+        return NULL;
     case L_CONS_CELL :
-    {
-      while (n1 && n2) // loop through the list and compare each element
-      {
-        if (!lisp_equal(CAR(n1),CAR(n2)))
-          return NULL;
-        n1=CDR(n1);
-        n2=CDR(n2);
-        if (n1 && *((ltype *)n1)!=L_CONS_CELL)
-          return lisp_equal(n1,n2);
-      }
-      if (n1 || n2) return NULL;   // if one is longer than the other
-      else return true_symbol;
-    } break;
+        while (n1 && n2) // loop through the list and compare each element
+        {
+          if (!lisp_equal(CAR(n1), CAR(n2)))
+            return NULL;
+          n1=CDR(n1);
+          n2=CDR(n2);
+          if (n1 && *((ltype *)n1)!=L_CONS_CELL)
+            return lisp_equal(n1, n2);
+        }
+        if (n1 || n2)
+            return NULL;   // if one is longer than the other
+        return true_symbol;
     default :
-          return lisp_eq(n1,n2);
-    break;
-      }
-    }
-  }
+        return lisp_eq(n1, n2);
+    }
 }
 
@@ -794 +781 @@
   for (cs=(cons_cell *)symbol_list;cs;cs=(cons_cell *)CDR(cs))
   {
-    if (streq( ((char *)((lisp_symbol *)cs->car)->name)+sizeof(lisp_string),name))
+    if (!strcmp( ((char *)((lisp_symbol *)cs->car)->name)+sizeof(lisp_string), name))
       return (lisp_symbol *)(cs->car);
   }
@@ -828 +815 @@
   while (p)
   {
-    int cmp=strcmp(name,((char *)p->name)+sizeof(lisp_string));
+    int cmp=strcmp(name, ((char *)p->name)+sizeof(lisp_string));
     if (cmp==0) return p;
     else if (cmp<0) p=p->left;
@@ -844 +831 @@
   while (p)
   {
-    int cmp=strcmp(name,((char *)p->name)+sizeof(lisp_string));
+    int cmp=strcmp(name, ((char *)p->name)+sizeof(lisp_string));
     if (cmp==0) return p;
     else if (cmp<0)
@@ -900 +887 @@
     while (list)
     {
-      if (lisp_eq(CAR(CAR(list)),item))
+      if (lisp_eq(CAR(CAR(list)), item))
         return lcar(list);    
       list=(cons_cell *)(CDR(list));
@@ -934 +921 @@
 
   void *ret=NULL;
-  long l1=list_length(list1),l2=list_length(list2);
+  long l1=list_length(list1), l2=list_length(list2);
   if (l1!=l2)
   {    
@@ -944 +931 @@
   if (l1!=0)
   {
-    void *first=NULL,*last=NULL,*cur=NULL,*tmp;
-    p_ref r1(first),r2(last),r3(cur);
+    void *first=NULL, *last=NULL, *cur=NULL, *tmp;
+    p_ref r1(first), r2(last), r3(cur);
     while (list1)
     {
@@ -1008 +995 @@
   if (s->function!=l_undefined)
   {
-    lbreak("add_sys_fucntion -> symbol %s already has a function\n",name);
+    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->function=new_lisp_sys_function(min_args, max_args, number);
   return s;
 }
@@ -1021 +1008 @@
   if (s->value!=l_undefined)
   {
-    lbreak("add_c_object -> symbol %s already has a value\n",lstring_value(symbol_name(s)));
+    lbreak("add_c_object -> symbol %s already has a value\n", lstring_value(symbol_name(s)));
     exit(0);
   }
@@ -1035 +1022 @@
   if (s->function!=l_undefined)
   {
-    lbreak("add_sys_fucntion -> symbol %s already has a function\n",name);
+    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->function=new_lisp_c_function(min_args, max_args, number);
   return s;
 }
@@ -1049 +1036 @@
   if (s->function!=l_undefined)
   {
-    lbreak("add_sys_fucntion -> symbol %s already has a function\n",name);
+    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->function=new_lisp_c_bool(min_args, max_args, number);
   return s;
 }
@@ -1064 +1051 @@
   if (s->function!=l_undefined)
   {
-    lbreak("add_sys_fucntion -> symbol %s already has a function\n",name);
+    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->function=new_user_lisp_function(min_args, max_args, number);
   return s;
 }
@@ -1101 +1088 @@
   {
     while (*s && *s!='\n' && *s!='\r' && *s!=26) s++;
-    return read_ltoken(s,buffer);
+    return read_ltoken(s, buffer);
   } else if  (*s=='/' && *(s+1)=='*')   // c style comment
   {
     skip_c_comment(s);
-    return read_ltoken(s,buffer);
+    return read_ltoken(s, buffer);
   }
   else if (*s==0)
@@ -1139 +1126 @@
 int end_of_program(char const *s)
 {
-  return !read_ltoken(s,n);
+  return !read_ltoken(s, n);
 }
 
@@ -1145 +1132 @@
 void push_onto_list(void *object, void *&list)
 {
-  p_ref r1(object),r2(list);
+  p_ref r1(object), r2(list);
   cons_cell *c=new_cons_cell();
   c->car=object;
@@ -1157 +1144 @@
 {
   void *ret=NULL;
-  if (!read_ltoken(s,n))
-    lerror(NULL,"unexpected end of program");
-  if (streq(n,"nil"))
+  if (!read_ltoken(s, n))
+    lerror(NULL, "unexpected end of program");
+  if (!strcmp(n, "nil"))
     return NULL;
   else if (toupper(n[0])=='T' && !n[1])
@@ -1165 +1152 @@
   else if (n[0]=='\'')                    // short hand for quote function
   {
-    void *cs=new_cons_cell(),*c2=NULL,*tmp;
-    p_ref r1(cs),r2(c2);
+    void *cs=new_cons_cell(), *c2=NULL, *tmp;
+    p_ref r1(cs), r2(c2);
 
     ((cons_cell *)cs)->car=quote_symbol;
@@ -1178 +1165 @@
   else if (n[0]=='`')                    // short hand for backquote function
   {
-    void *cs=new_cons_cell(),*c2=NULL,*tmp;
-    p_ref r1(cs),r2(c2);
+    void *cs=new_cons_cell(), *c2=NULL, *tmp;
+    p_ref r1(cs), r2(c2);
 
     ((cons_cell *)cs)->car=backquote_symbol;
@@ -1190 +1177 @@
   }  else if (n[0]==',')              // short hand for comma function
   {
-    void *cs=new_cons_cell(),*c2=NULL,*tmp;
-    p_ref r1(cs),r2(c2);
+    void *cs=new_cons_cell(), *c2=NULL, *tmp;
+    p_ref r1(cs), r2(c2);
 
     ((cons_cell *)cs)->car=comma_symbol;
@@ -1203 +1190 @@
   else if (n[0]=='(')                     // make a list of everything in ()
   {
-    void *first=NULL,*cur=NULL,*last=NULL;
-    p_ref r1(first),r2(cur),r3(last);
+    void *first=NULL, *cur=NULL, *last=NULL;
+    p_ref r1(first), r2(cur), r3(last);
     int done=0;
     do
     {
       char const *tmp=s;
-      if (!read_ltoken(tmp,n))           // check for the end of the list
-        lerror(NULL,"unexpected end of program");
+      if (!read_ltoken(tmp, n))           // check for the end of the list
+        lerror(NULL, "unexpected end of program");
       if (n[0]==')')
       {
                 done=1;
-                read_ltoken(s,n);                // read off the ')'
+                read_ltoken(s, n);                // read off the ')'
       }
       else
@@ -1221 +1208 @@
                 {
                   if (!first)
-                    lerror(s,"token '.' not allowed here\n");    
+                    lerror(s, "token '.' not allowed here\n");    
                   else
                   {
                     void *tmp;
-                    read_ltoken(s,n);              // skip the '.'
+                    read_ltoken(s, n);              // skip the '.'
                     tmp=compile(s);
                     ((cons_cell *)last)->cdr=tmp;          // link the last cdr to
@@ -1231 +1218 @@
                   }
                 } else if (!last && first)
-                  lerror(s,"illegal end of dotted list\n");
+                  lerror(s, "illegal end of dotted list\n");
                 else
                 {        
@@ -1249 +1236 @@
 
   } else if (n[0]==')')
-    lerror(s,"mismatched )");
+    lerror(s, "mismatched )");
   else if (isdigit(n[0]) || (n[0]=='-' && isdigit(n[1])))
   {
     lisp_number *num=new_lisp_number(0);
-    sscanf(n,"%ld",&num->num);
+    sscanf(n, "%ld", &num->num);
     ret=num;
   } else if (n[0]=='"')
@@ -1259 +1246 @@
     ret=new_lisp_string(str_token_len(s));
     char *start=lstring_value(ret);
-    for (;*s && (*s!='"' || s[1]=='"');s++,start++)
+    for (;*s && (*s!='"' || s[1]=='"');s++, start++)
     {
       if (*s=='\\')
@@ -1277 +1264 @@
     if (n[1]=='\\')
     {
-      read_ltoken(s,n);                   // read character name
-      if (streq(n,"newline"))
+      read_ltoken(s, n);                   // read character name
+      if (!strcmp(n, "newline"))
         ret=new_lisp_character('\n');
-      else if (streq(n,"space"))
+      else if (!strcmp(n, "space"))
         ret=new_lisp_character(' ');
       else
@@ -1287 +1274 @@
     else if (n[1]==0)                           // short hand for function
     {
-      void *cs=new_cons_cell(),*c2=NULL,*tmp;
-      p_ref r4(cs),r5(c2);
+      void *cs=new_cons_cell(), *c2=NULL, *tmp;
+      p_ref r4(cs), r5(c2);
       tmp=make_find_symbol("function");
       ((cons_cell *)cs)->car=tmp;
@@ -1299 +1286 @@
     else
     {
-      lbreak("Unknown #\\ notation : %s\n",n);
+      lbreak("Unknown #\\ notation : %s\n", n);
       exit(0);
     }
@@ -1369 +1356 @@
       {
                 char num[10];
-                sprintf(num,"%ld",((lisp_number *)i)->num);
+                sprintf(num, "%ld", ((lisp_number *)i)->num);
         lprint_string(num);
       }
@@ -1394 +1381 @@
                      lprint_string(lstring_value(i));
                 else
-             dprintf("\"%s\"",lstring_value(i));
+             dprintf("\"%s\"", lstring_value(i));
       }
       break;
@@ -1401 +1388 @@
       {
                 char ptr[10];
-                    sprintf(ptr,"%p",lpointer_value(i));
+                    sprintf(ptr, "%p", lpointer_value(i));
                 lprint_string(ptr);
       }
@@ -1408 +1395 @@
       {
                 char num[20];
-                sprintf(num,"%g",(lfixed_point_value(i)>>16)+
+                sprintf(num, "%g", (lfixed_point_value(i)>>16)+
                           ((lfixed_point_value(i)&0xffff))/(double)0x10000);
                 lprint_string(num);
@@ -1417 +1404 @@
                 {
                   uint8_t ch=((lisp_character *)i)->ch;
-                  current_print_file->write(&ch,1);
+                  current_print_file->write(&ch, 1);
                 } else
                 {
@@ -1429 +1416 @@
                     { dprintf("space"); break; }
                     default :
-                      dprintf("%c",ch);
+                      dprintf("%c", ch);
                   }
                 }
@@ -1468 +1455 @@
 void *eval_function(lisp_symbol *sym, void *arg_list)
 {
-
-
 #ifdef TYPE_CHECKING
-  int args,req_min,req_max;
+  int args, req_min, req_max;
   if (item_type(sym)!=L_SYMBOL)
   {
@@ -1499 +1484 @@
     case L_USER_FUNCTION :
     {
-      return eval_user_fun(sym,arg_list);
+      return eval_user_fun(sym, arg_list);
     } break;
     default :
@@ -1541 +1526 @@
   {
     case L_SYS_FUNCTION :
-    { ret=eval_sys_function( ((lisp_sys_function *)fun),arg_list); } break;
+    { ret=eval_sys_function( ((lisp_sys_function *)fun), arg_list); } break;
     case L_L_FUNCTION :
-    { ret=l_caller( ((lisp_sys_function *)fun)->fun_number,arg_list); } break;
+    { ret=l_caller( ((lisp_sys_function *)fun)->fun_number, arg_list); } break;
     case L_USER_FUNCTION :
     {
-      return eval_user_fun(sym,arg_list);
+      return eval_user_fun(sym, arg_list);
     } break;
     case L_C_FUNCTION :
-    {
-      void *first=NULL,*cur=NULL,*tmp;
-      p_ref r1(first),r2(cur);
+    case L_C_BOOL :
+    {
+      void *first=NULL, *cur=NULL, *tmp;
+      p_ref r1(first), r2(cur);
       while (arg_list)
       {
-                if (first) {
-                  tmp=new_cons_cell();
-                  ((cons_cell *)cur)->cdr=tmp;
-                  cur=tmp;
-                } else
-                  cur=first=new_cons_cell();
-            
-                void *val=eval(CAR(arg_list));
-                ((cons_cell *)cur)->car=val;
-                arg_list=lcdr(arg_list);
-      }
-      ret=new_lisp_number(c_caller( ((lisp_sys_function *)fun)->fun_number,first));
-    } break;
-    case L_C_BOOL :
-    {
-      void *first=NULL,*cur=NULL,*tmp;
-      p_ref r1(first),r2(cur);
-      while (arg_list)
-      {
-                if (first) {
-                  tmp=new_cons_cell();
-                  ((cons_cell *)cur)->cdr=tmp;
-                  cur=tmp;
-                } else
-                  cur=first=new_cons_cell();
-            
-                void *val=eval(CAR(arg_list));
-                ((cons_cell *)cur)->car=val;
-                arg_list=lcdr(arg_list);
-      }
-
-      if (c_caller( ((lisp_sys_function *)fun)->fun_number,first))
+        if (first) {
+          tmp=new_cons_cell();
+          ((cons_cell *)cur)->cdr=tmp;
+          cur=tmp;
+        } else
+          cur=first=new_cons_cell();
+    
+        void *val=eval(CAR(arg_list));
+        ((cons_cell *)cur)->car=val;
+        arg_list=lcdr(arg_list);
+      }
+      if(t == L_C_FUNCTION)
+        ret=new_lisp_number(c_caller( ((lisp_sys_function *)fun)->fun_number, first));
+      else if (c_caller( ((lisp_sys_function *)fun)->fun_number, first))
         ret=true_symbol;
       else ret=NULL;
     } break;
     default :
-      fprintf(stderr,"not a fun, shouldn't happen\n");
+      fprintf(stderr, "not a fun, shouldn't happen\n");
   }
 
@@ -1598 +1566 @@
 #endif
 
-
   return ret;
 }    
@@ -1607 +1574 @@
   if (p)
   {
-    pro_print(out,p->right);
+    pro_print(out, p->right);
     {
       char st[100];
-      sprintf(st,"%20s %f\n",lstring_value(symbol_name(p)),((lisp_symbol *)p)->time_taken);
-      out->write(st,strlen(st));
-    }
-    pro_print(out,p->left);
+      sprintf(st, "%20s %f\n", lstring_value(symbol_name(p)), ((lisp_symbol *)p)->time_taken);
+      out->write(st, strlen(st));
+    }
+    pro_print(out, p->left);
   }
 }
@@ -1619 +1586 @@
 void preport(char *fn)
 {
-  bFILE *fp=open_file("preport.out","wb");
-  pro_print(fp,lsym_root);
+  bFILE *fp=open_file("preport.out", "wb");
+  pro_print(fp, lsym_root);
   delete fp;
 }
@@ -1642 +1609 @@
     }
   }
-  int num_args=list_length(CDR(arg_list)),i,stop=0;
+  int num_args=list_length(CDR(arg_list)), i, stop=0;
   if (!num_args) return 0;
 
@@ -1664 +1631 @@
   }
 
-  cons_cell *na_list=NULL,*return_list=NULL,*last_return=NULL;
+  cons_cell *na_list=NULL, *return_list=NULL, *last_return=NULL;
 
   do
@@ -1692 +1659 @@
     {
       cons_cell *c=new_cons_cell();
-      c->car=eval_function((lisp_symbol *)sym,first);
+      c->car=eval_function((lisp_symbol *)sym, first);
       if (return_list)
         last_return->cdr=c;
@@ -1710 +1677 @@
 {
   void *el_list=CDR(prog_list);
-  p_ref ref1(prog_list),ref2(el_list);
+  p_ref ref1(prog_list), ref2(el_list);
   void *ret=NULL;
   void *rtype=eval(CAR(prog_list));
@@ -1722 +1689 @@
     {
       void **str_eval=(void **)malloc(elements*sizeof(void *));
-      int i,old_ptr_stack_start=l_ptr_stack.son;
+      int i, old_ptr_stack_start=l_ptr_stack.son;
 
       // evalaute all the strings and count their lengths
-      for (i=0;i<elements;i++,el_list=CDR(el_list))
+      for (i=0;i<elements;i++, el_list=CDR(el_list))
       {
         str_eval[i]=eval(CAR(el_list));
@@ -1777 +1744 @@
       case L_STRING :
       {
-        memcpy(s,lstring_value(str_eval[i]),strlen(lstring_value(str_eval[i])));
+        memcpy(s, lstring_value(str_eval[i]), strlen(lstring_value(str_eval[i])));
         s+=strlen(lstring_value(str_eval[i]));
       } break;
@@ -1809 +1776 @@
   else
   {
-    void *first=NULL,*last=NULL,*cur=NULL,*tmp;
-    p_ref ref1(first),ref2(last),ref3(cur),ref4(args);
+    void *first=NULL, *last=NULL, *cur=NULL, *tmp;
+    p_ref ref1(first), ref2(last), ref3(cur), ref4(args);
     while (args)
     {
@@ -1853 +1820 @@
   switch (fun->fun_number)
   {
-    case 0 :                                                    // print
+    case SYS_FUNC_PRINT:
     {
       ret=NULL;
@@ -1863 +1830 @@
       return ret;
     } break;
-    case 1 :                                                    // car
+    case SYS_FUNC_CAR:
     { ret=lcar(eval(CAR(arg_list))); } break;
-    case 2 :                                                    // cdr
+    case SYS_FUNC_CDR:
     { ret=lcdr(eval(CAR(arg_list))); } break;
-    case 3 :                                                    // length
+    case SYS_FUNC_LENGTH:
     {
       void *v=eval(CAR(arg_list));
       switch (item_type(v))
       {
-    case L_STRING : ret=new_lisp_number(strlen(lstring_value(v))); break;
-    case L_CONS_CELL : ret=new_lisp_number(list_length(v)); break;
-    default :
-    { lprint(v);
-      lbreak("length : type not supported\n");
-    }
+        case L_STRING : ret=new_lisp_number(strlen(lstring_value(v))); break;
+        case L_CONS_CELL : ret=new_lisp_number(list_length(v)); break;
+        default :
+        { lprint(v);
+          lbreak("length : type not supported\n");
+        }
       }
     } break;                        
-    case 4 :                                                    // list
-    {
-      void *cur=NULL,*last=NULL,*first=NULL;
-      p_ref r1(cur),r2(first),r3(last);
+    case SYS_FUNC_LIST:
+    {
+      void *cur=NULL, *last=NULL, *first=NULL;
+      p_ref r1(cur), r2(first), r3(last);
       while (arg_list)
       {
@@ -1897 +1864 @@
       ret=first;
     } break;
-    case 5 :                                             // cons
+    case SYS_FUNC_CONS:
     { void *c=new_cons_cell();
       p_ref r1(c);
@@ -1906 +1873 @@
       ret=c;
     } break;
-    case 6 :                                             // quote
+    case SYS_FUNC_QUOTE:
     ret=CAR(arg_list);
     break;
-    case 7 :                                             // eq
+    case SYS_FUNC_EQ:
     {
       l_user_stack.push(eval(CAR(arg_list)));
       l_user_stack.push(eval(CAR(CDR(arg_list))));
-      ret=lisp_eq(l_user_stack.pop(1),l_user_stack.pop(1));
-    } break;
-    case 24 :                                             // equal
+      ret=lisp_eq(l_user_stack.pop(1), l_user_stack.pop(1));
+    } break;
+    case SYS_FUNC_EQUAL:
     {
       l_user_stack.push(eval(CAR(arg_list)));
       l_user_stack.push(eval(CAR(CDR(arg_list))));
-      ret=lisp_equal(l_user_stack.pop(1),l_user_stack.pop(1));
-    } break;
-    case 8 :                                           // +
+      ret=lisp_equal(l_user_stack.pop(1), l_user_stack.pop(1));
+    } break;
+    case SYS_FUNC_PLUS:
     {
       long sum=0;
@@ -1932 +1899 @@
     }
     break;
-    case 28 :                                          // *
+    case SYS_FUNC_TIMES:
     {
       long sum;
@@ -1960 +1927 @@
     }
     break;
-    case 29 :                                           // /
-    {
-      long sum=0,first=1;
+    case SYS_FUNC_SLASH:
+    {
+      long sum=0, first=1;
       while (arg_list)
       {
@@ -1983 +1950 @@
     }
     break;
-    case 9 :                                           // -
+    case SYS_FUNC_MINUS:
     {
       long x=lnumber_value(eval(CAR(arg_list)));         arg_list=CDR(arg_list);
@@ -1994 +1961 @@
     }
     break;
-    case 10 :                                         // if
+    case SYS_FUNC_IF:
     {
       if (eval(CAR(arg_list)))
@@ -2005 +1972 @@
       }
     } break;
-    case 63 :
-    case 11 :                                         // setf
-    {
-      void *set_to=eval(CAR(CDR(arg_list))),*i=NULL;
-      p_ref r1(set_to),r2(i);
+    case SYS_FUNC_SETQ:
+    case SYS_FUNC_SETF:
+    {
+      void *set_to=eval(CAR(CDR(arg_list))), *i=NULL;
+      p_ref r1(set_to), r2(i);
       i=CAR(arg_list);
 
@@ -2015 +1982 @@
       switch (item_type(i))
       {
-    case L_SYMBOL :
-    {
-      switch (item_type (((lisp_symbol *)i)->value))
-      {
-        case L_NUMBER :
+        case L_SYMBOL :
         {
-          if (x==L_NUMBER && ((lisp_symbol *)i)->value!=l_undefined)
-          ((lisp_number *)(((lisp_symbol *)i)->value))->num=lnumber_value(set_to);
-          else
-          ((lisp_symbol *)i)->value=set_to;
+          switch (item_type (((lisp_symbol *)i)->value))
+          {
+            case L_NUMBER :
+            {
+              if (x==L_NUMBER && ((lisp_symbol *)i)->value!=l_undefined)
+              ((lisp_number *)(((lisp_symbol *)i)->value))->num=lnumber_value(set_to);
+              else
+              ((lisp_symbol *)i)->value=set_to;
+            } break;
+            case L_OBJECT_VAR :
+            {
+              l_obj_set(((lisp_object_var *)(((lisp_symbol *)i)->value))->number, set_to);
+            } break;
+            default :
+            ((lisp_symbol *)i)->value=set_to;
+          }
+          ret=((lisp_symbol *)i)->value;
         } break;
-        case L_OBJECT_VAR :
+        case L_CONS_CELL :   // this better be an 'aref'
         {
-          l_obj_set(((lisp_object_var *)(((lisp_symbol *)i)->value))->number,set_to);
+#ifdef TYPE_CHECKING
+          void *car=((cons_cell *)i)->car;
+          if (car==car_symbol)
+          {
+            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); }
+            ((cons_cell *)car)->car=set_to;
+          } else if (car==cdr_symbol)
+          {
+            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); }
+            ((cons_cell *)car)->cdr=set_to;
+          } else if (car==aref_symbol)
+          {
+#endif
+            void *a=(lisp_1d_array *)eval(CAR(CDR(i)));
+            p_ref r1(a);
+#ifdef TYPE_CHECKING
+            if (item_type(a)!=L_1D_ARRAY)
+            {
+              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>=((lisp_1d_array *)a)->size || num<0)
+            {
+              lbreak("aref : value of bounds (%d)\n", num);
+              exit(0);
+            }
+#endif
+            void **data=(void **)(((lisp_1d_array *)a)+1);
+            data[num]=set_to;
+#ifdef TYPE_CHECKING
+          } else
+          {
+            lbreak("expected (aref, car, cdr, or symbol) in setq\n");
+            exit(0);
+          }
+#endif
+          ret=set_to;
         } break;
+
         default :
-        ((lisp_symbol *)i)->value=set_to;
-      }
-      ret=((lisp_symbol *)i)->value;
-    } break;
-    case L_CONS_CELL :   // this better be an 'aref'
-    {
-#ifdef TYPE_CHECKING
-      void *car=((cons_cell *)i)->car;
-      if (car==car_symbol)
-      {
-        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); }
-        ((cons_cell *)car)->car=set_to;
-      } else if (car==cdr_symbol)
-      {
-        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); }
-        ((cons_cell *)car)->cdr=set_to;
-      } else if (car==aref_symbol)
-      {
-#endif
-        void *a=(lisp_1d_array *)eval(CAR(CDR(i)));
-        p_ref r1(a);
-#ifdef TYPE_CHECKING
-        if (item_type(a)!=L_1D_ARRAY)
         {
-          lprint(a);
-          lbreak("is not an array (aref)\n");
+          lprint(i);
+          lbreak("setq/setf only defined for symbols and arrays now..\n");
           exit(0);
         }
-#endif
-        long num=lnumber_value(eval(CAR(CDR(CDR(i)))));
-#ifdef TYPE_CHECKING
-        if (num>=((lisp_1d_array *)a)->size || num<0)
-        {
-          lbreak("aref : value of bounds (%d)\n",num);
-          exit(0);
-        }
-#endif
-        void **data=(void **)(((lisp_1d_array *)a)+1);
-        data[num]=set_to;
-#ifdef TYPE_CHECKING
-      } else
-      {
-        lbreak("expected (aref, car, cdr, or symbol) in setq\n");
-        exit(0);
-      }
-#endif
-      ret=set_to;
-    } break;
-
-    default :
-    {
-      lprint(i);
-      lbreak("setq/setf only defined for symbols and arrays now..\n");
-      exit(0);
-    }
-      }
-    } break;
-    case 12 :                                      // symbol-list
+      }
+    } break;
+    case SYS_FUNC_SYMBOL_LIST:
       ret=NULL;
     break;
-    case 13 :                                      // assoc
+    case SYS_FUNC_ASSOC:
     {
       void *item=eval(CAR(arg_list));
@@ -2101 +2068 @@
       void *list=(cons_cell *)eval(CAR(CDR(arg_list)));
       p_ref r2(list);
-      ret=assoc(item,(cons_cell *)list);
-    } break;
-    case 20 :                                       // not is the same as null
-    case 14 :                                       // null
+      ret=assoc(item, (cons_cell *)list);
+    } break;
+    case SYS_FUNC_NOT:
+    case SYS_FUNC_NULL:
     if (eval(CAR(arg_list))==NULL) ret=true_symbol; else ret=NULL;
     break;
-    case 15 :                                       // acons
-    {
-      void *i1=eval(CAR(arg_list)),*i2=eval(CAR(CDR(arg_list)));
+    case SYS_FUNC_ACONS:
+    {
+      void *i1=eval(CAR(arg_list)), *i2=eval(CAR(CDR(arg_list)));
       p_ref r1(i1);
       cons_cell *cs=new_cons_cell();
@@ -2117 +2084 @@
     } break;
 
-    case 16 :                                       // pairlis
+    case SYS_FUNC_PAIRLIS:
     {    
       l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list);
@@ -2124 +2091 @@
       void *n2=l_user_stack.pop(1);
       void *n1=l_user_stack.pop(1);
-      ret=pairlis(n1,n2,n3);
-    } break;
-    case 17 :                                      // let
+      ret=pairlis(n1, n2, n3);
+    } break;
+    case SYS_FUNC_LET:
     {
       // make an a-list of new variable names and new values
       void *var_list=CAR(arg_list),
            *block_list=CDR(arg_list);
-      p_ref r1(block_list),r2(var_list);
+      p_ref r1(block_list), r2(var_list);
       long stack_start=l_user_stack.son;
 
       while (var_list)
       {
-    void *var_name=CAR(CAR(var_list)),*tmp;
+    void *var_name=CAR(CAR(var_list)), *tmp;
 #ifdef TYPE_CHECKING
     if (item_type(var_name)!=L_SYMBOL)
@@ -2171 +2138 @@
     }
     break;
-    case 18 :                                   // defun
+    case SYS_FUNC_DEFUN:
     {
       void *symbol=CAR(arg_list);
@@ -2194 +2161 @@
       intptr_t a=cache.reg_lisp_block(lcar(lcdr(arg_list)));
       intptr_t b=cache.reg_lisp_block(block_list);
-      lisp_user_function *ufun=new_lisp_user_function(a,b);
+      lisp_user_function *ufun=new_lisp_user_function(a, b);
 #else
-      lisp_user_function *ufun=new_lisp_user_function(lcar(lcdr(arg_list)),block_list);
-#endif
-      set_symbol_function(symbol,ufun);
+      lisp_user_function *ufun=new_lisp_user_function(lcar(lcdr(arg_list)), block_list);
+#endif
+      set_symbol_function(symbol, ufun);
       ret=symbol;
     } break;
-    case 19 :                                       // atom
+    case SYS_FUNC_ATOM:
     { ret=lisp_atom(eval(CAR(arg_list))); }
-    case 21 :                                           // and
+    case SYS_FUNC_AND:
     {
       void *l=arg_list;
@@ -2217 +2184 @@
       }
     } break;
-    case 22 :                                           // or
+    case SYS_FUNC_OR:
     {
       void *l=arg_list;
@@ -2231 +2198 @@
       }
     } break;
-    case 23 :                                          // progn
+    case SYS_FUNC_PROGN:
     { ret=eval_block(arg_list); } break;
-    case 25 :                                        // concatenate
+    case SYS_FUNC_CONCATENATE:
       ret=concatenate(arg_list);
     break;
-    case 26 :                                        // char-code
+    case SYS_FUNC_CHAR_CODE:
     {
       void *i=eval(CAR(arg_list));
@@ -2243 +2210 @@
       switch (item_type(i))
       {
-    case L_CHARACTER :
-    { ret=new_lisp_number(((lisp_character *)i)->ch); } break;
-    case L_STRING :
-    {  ret=new_lisp_number(*lstring_value(i)); } break;
-    default :
-    {
-      lprint(i);
-      lbreak(" is not character type\n");
-      exit(0);
-    }
+        case L_CHARACTER :
+        { ret=new_lisp_number(((lisp_character *)i)->ch); } break;
+        case L_STRING :
+        {  ret=new_lisp_number(*lstring_value(i)); } break;
+        default :
+        {
+          lprint(i);
+          lbreak(" is not character type\n");
+          exit(0);
+        }
       }        
     } break;
-    case 27 :                                        // code-char
+    case SYS_FUNC_CODE_CHAR:
     {
       void *i=eval(CAR(arg_list));
@@ -2267 +2234 @@
       ret=new_lisp_character(((lisp_number *)i)->num);
     } break;
-    case 30 :                                       // cond
+    case SYS_FUNC_COND:
     {
       void *block_list=CAR(arg_list);
@@ -2283 +2250 @@
       }
     } break;
-    case 31 :                                       // select
+    case SYS_FUNC_SELECT:
     {
       void *selector=eval(CAR(arg_list));
       void *sel=CDR(arg_list);
-      p_ref r1(selector),r2(sel);
+      p_ref r1(selector), r2(sel);
       while (sel)
       {
-    if (lisp_equal(selector,eval(CAR(CAR(sel)))))
+    if (lisp_equal(selector, eval(CAR(CAR(sel)))))
     {
       sel=CDR(CAR(sel));
@@ -2302 +2269 @@
       }
     } break;
-    case 32 :                                      // function
+    case SYS_FUNC_FUNCTION:
       ret=lookup_symbol_function(eval(CAR(arg_list)));
     break;
-    case 33 :                                      // mapcar
+    case SYS_FUNC_MAPCAR:
       ret=mapcar(arg_list);
-    case 34 :                                      // funcall
+    case SYS_FUNC_FUNCALL:
     {
       void *n1=eval(CAR(arg_list));
-      ret=eval_function((lisp_symbol *)n1,CDR(arg_list));
-    } break;
-    case 35 :                                                   // >
+      ret=eval_function((lisp_symbol *)n1, CDR(arg_list));
+    } break;
+    case SYS_FUNC_GT:
     {
       long n1=lnumber_value(eval(CAR(arg_list)));
@@ -2319 +2286 @@
     }
     break;
-    case 36 :                                                   // <
+    case SYS_FUNC_LT:
     {
       long n1=lnumber_value(eval(CAR(arg_list)));
@@ -2326 +2293 @@
     }
     break;
-    case 47 :                                                   // >=
+    case SYS_FUNC_GE:
     {
       long n1=lnumber_value(eval(CAR(arg_list)));
@@ -2333 +2300 @@
     }
     break;
-    case 48 :                                                   // <=
+    case SYS_FUNC_LE:
     {
       long n1=lnumber_value(eval(CAR(arg_list)));
@@ -2341 +2308 @@
     break;
 
-    case 37 :                                                  // tmp-space
+    case SYS_FUNC_TMP_SPACE:
       tmp_space();
       ret=true_symbol;
     break;
-    case 38 :                                                  // perm-space
+    case SYS_FUNC_PERM_SPACE:
       perm_space();
       ret=true_symbol;
     break;
-    case 39 :
+    case SYS_FUNC_SYMBOL_NAME:
       void *symb;
       symb=eval(CAR(arg_list));
@@ -2362 +2329 @@
       ret=((lisp_symbol *)symb)->name;
     break;
-    case 40 :                                                  // trace
+    case SYS_FUNC_TRACE:
       trace_level++;
       if (arg_list)
@@ -2368 +2335 @@
       ret=true_symbol;
     break;
-    case 41 :                                                  // untrace
+    case SYS_FUNC_UNTRACE:
       if (trace_level>0)
       {
@@ -2375 +2342 @@
       } else ret=NULL;
     break;
-    case 42 :                                                 // digitstr
-    {
-      char tmp[50],*tp;
+    case SYS_FUNC_DIGSTR:
+    {
+      char tmp[50], *tp;
       long num=lnumber_value(eval(CAR(arg_list)));
       long dig=lnumber_value(eval(CAR(CDR(arg_list))));
@@ -2394 +2361 @@
       ret=new_lisp_string(tp+1);
     } break;
-    case 98:
-    case 66:
-    case 43:                                     // compile-file
+    case SYS_FUNC_LOCAL_LOAD:
+    case SYS_FUNC_LOAD:
+    case SYS_FUNC_COMPILE_FILE:
     {
             void *fn = eval( CAR( arg_list ) );
@@ -2402 +2369 @@
             p_ref r1( fn );
             bFILE *fp;
-            if( fun->fun_number == 98 )          // local_load
+            if( fun->fun_number == SYS_FUNC_LOCAL_LOAD )
             {
                 // A special test for gamma.lsp
@@ -2420 +2387 @@
             else
             {
-                fp = open_file(st,"rb");
+                fp = open_file(st, "rb");
             }
 
@@ -2427 +2394 @@
                 delete fp;
                 if( DEFINEDP(symbol_value(load_warning)) && symbol_value(load_warning) )
-                    dprintf("Warning : file %s does not exists\n",st);
+                    dprintf("Warning : file %s does not exist\n", st);
                 ret = NULL;
             }
@@ -2440 +2407 @@
                 }
             
-                fp->read(s,l);
+                fp->read(s, l);
                 s[l]=0;
                 delete fp;
@@ -2446 +2413 @@
             #ifndef NO_LIBS
                 char msg[100];
-                sprintf(msg,"(load \"%s\")",st);
-                if (stat_man) stat_man->push(msg,NULL);
+                sprintf(msg, "(load \"%s\")", st);
+                if (stat_man) stat_man->push(msg, NULL);
                 crc_manager.get_filenumber(st);               // make sure this file gets crc'ed
             #endif
@@ -2461 +2428 @@
                   eval(compiled_form);
                   compiled_form=NULL;
-                  restore_heap(m,TMP_SPACE);
+                  restore_heap(m, TMP_SPACE);
                 }    
             #ifndef NO_LIBS
@@ -2471 +2438 @@
       }
     } break;
-    case 44 :                                                 // abs
+    case SYS_FUNC_ABS:
       ret=new_lisp_number(abs(lnumber_value(eval(CAR(arg_list))))); break;
-    case 45 :                                                 // min
-    {
-      int x=lnumber_value(eval(CAR(arg_list))),y=lnumber_value(eval(CAR(CDR(arg_list))));
+    case SYS_FUNC_MIN:
+    {
+      int x=lnumber_value(eval(CAR(arg_list))), y=lnumber_value(eval(CAR(CDR(arg_list))));
       if (x<y) ret=new_lisp_number(x); else ret=new_lisp_number(y);
     } break;
-    case 46 :                                                 // max
-    {
-      int x=lnumber_value(eval(CAR(arg_list))),y=lnumber_value(eval(CAR(CDR(arg_list))));
+    case SYS_FUNC_MAX:
+    {
+      int x=lnumber_value(eval(CAR(arg_list))), y=lnumber_value(eval(CAR(CDR(arg_list))));
       if (x>y) ret=new_lisp_number(x); else ret=new_lisp_number(y);
     } break;
-    case 49 :                        // backquote
+    case SYS_FUNC_BACKQUOTE:
     {
       ret=backquote_eval(CAR(arg_list));
     } break;
-    case 50 :
+    case SYS_FUNC_COMMA:
     {
       lprint(arg_list);
@@ -2494 +2461 @@
       ret=NULL;
     } break;
-    case 51 :
+    case SYS_FUNC_NTH:
     {
       long x=lnumber_value(eval(CAR(arg_list)));
-      ret=nth(x,eval(CAR(CDR(arg_list))));
-    } break;
-    case 52 : resize_tmp(lnumber_value(eval(CAR(arg_list)))); break;
-    case 53 : resize_perm(lnumber_value(eval(CAR(arg_list)))); break;
-    case 54 : ret=new_lisp_fixed_point(lisp_cos(lnumber_value(eval(CAR(arg_list))))); break;
-    case 55 : ret=new_lisp_fixed_point(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
-    case 56 :
+      ret=nth(x, eval(CAR(CDR(arg_list))));
+    } break;
+    case SYS_FUNC_RESIZE_TMP:
+        resize_tmp(lnumber_value(eval(CAR(arg_list)))); break;
+    case SYS_FUNC_RESIZE_PERM:
+        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;
+    case SYS_FUNC_SIN:
+        ret=new_lisp_fixed_point(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
+    case SYS_FUNC_ATAN2:
     {
       long y=(lnumber_value(eval(CAR(arg_list))));   arg_list=CDR(arg_list);
       long x=(lnumber_value(eval(CAR(arg_list))));
-      ret=new_lisp_number(lisp_atan2(y,x));
-    } break;
-    case 57 :
+      ret=new_lisp_number(lisp_atan2(y, x));
+    } break;
+    case SYS_FUNC_ENUM:
     {
       int sp=current_space;
@@ -2548 +2519 @@
       current_space=sp;
     } break;
-    case 58 :
+    case SYS_FUNC_QUIT:
     {
       exit(0);
     } break;
-    case 59 :
+    case SYS_FUNC_EVAL:
     {
       ret=eval(eval(CAR(arg_list)));
     } break;
-    case 60 : lbreak("User break"); break;
-    case 61 :
+    case SYS_FUNC_BREAK: lbreak("User break"); break;
+    case SYS_FUNC_MOD:
     {
       long x=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
@@ -2564 +2535 @@
       ret=new_lisp_number(x%y);
     } break;
-/*    case 62 :
+/*    case SYS_FUNC_WRITE_PROFILE:
     {
       char *fn=lstring_value(eval(CAR(arg_list)));
-      FILE *fp=fopen(fn,"wb");
+      FILE *fp=fopen(fn, "wb");
       if (!fp)
-        lbreak("could not open %s for writing",fn);
+        lbreak("could not open %s for writing", fn);
       else
       {    
     for (void *s=symbol_list;s;s=CDR(s))        
-      fprintf(fp,"%8d  %s\n",((lisp_symbol *)(CAR(s)))->call_counter,
+      fprintf(fp, "%8d  %s\n", ((lisp_symbol *)(CAR(s)))->call_counter,
           lstring_value(((lisp_symbol *)(CAR(s)))->name));
     fclose(fp);
       }
     } break;*/
-    case 64 :
+    case SYS_FUNC_FOR:
     {
       void *bind_var=CAR(arg_list); arg_list=CDR(arg_list);
@@ -2596 +2567 @@
       arg_list=CDR(arg_list);
 
-      void *block=NULL,*ret=NULL;
+      void *block=NULL, *ret=NULL;
       p_ref r3(block);
       l_user_stack.push(symbol_value(bind_var));  // save old symbol value
       while (ilist)
       {
-                set_symbol_value(bind_var,CAR(ilist));
+                set_symbol_value(bind_var, CAR(ilist));
                 for (block=arg_list;block;block=CDR(block))
                   ret=eval(CAR(block));
                 ilist=CDR(ilist);
       }
-      set_symbol_value(bind_var,l_user_stack.pop(1));
+      set_symbol_value(bind_var, l_user_stack.pop(1));
       ret=ret;
     } break;
-    case 65 :
+    case SYS_FUNC_OPEN_FILE:
     {
       bFILE *old_file=current_print_file;
@@ -2632 +2603 @@
 
     } break;
-    case 67 :
+    case SYS_FUNC_BIT_AND:
     {
       long first=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
@@ -2642 +2613 @@
       ret=new_lisp_number(first);
     } break;
-    case 68 :
+    case SYS_FUNC_BIT_OR:
     {
       long first=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
@@ -2652 +2623 @@
       ret=new_lisp_number(first);
     } break;
-    case 69 :
+    case SYS_FUNC_BIT_XOR:
     {
       long first=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
@@ -2662 +2633 @@
       ret=new_lisp_number(first);
     } break;
-    case 70 :  // make-array
+    case SYS_FUNC_MAKE_ARRAY:
     {
       long l=lnumber_value(eval(CAR(arg_list)));
       if (l>=2<<16 || l<=0)
       {
-                lbreak("bad array size %d\n",l);
+                lbreak("bad array size %d\n", l);
                 exit(0);
       }
-      ret=new_lisp_1d_array(l,CDR(arg_list));
-    } break;
-    case 71 : // aref
+      ret=new_lisp_1d_array(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);
-    } break;
-    case 72 : // if-1progn
+      ret=lget_array_element(eval(CAR(arg_list)), x);
+    } break;
+    case SYS_FUNC_IF_1PROGN:
     {
       if (eval(CAR(arg_list)))
@@ -2684 +2655 @@
 
     } break;
-    case 73 : // if-2progn
+    case SYS_FUNC_IF_2PROGN:
     {
       if (eval(CAR(arg_list)))
@@ -2691 +2662 @@
 
     } break;
-    case 74 : // if-12progn
+    case SYS_FUNC_IF_12PROGN:
     {
       if (eval(CAR(arg_list)))
@@ -2698 +2669 @@
 
     } break;
-    case 75 : // eq0
+    case SYS_FUNC_EQ0:
     {
       void *v=eval(CAR(arg_list));
@@ -2705 +2676 @@
       else ret=true_symbol;
     } break;
-    case 76 : // preport
+    case SYS_FUNC_PREPORT:
     {
 #ifdef L_PROFILE
@@ -2712 +2683 @@
 #endif
     } break;
-    case 77 : // search
+    case SYS_FUNC_SEARCH:
     {
       void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
@@ -2719 +2690 @@
       char *needle=lstring_value(arg1);
 
-      char *find=strstr(haystack,needle);
+      char *find=strstr(haystack, needle);
       if (find)
         ret=new_lisp_number(find-haystack);
       else ret=NULL;
     } break;
-    case 78 : // elt
+    case SYS_FUNC_ELT:
     {
       void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
@@ -2735 +2706 @@
         ret=new_lisp_character(st[x]);
     } break;
-    case 79 : // listp
+    case SYS_FUNC_LISTP:
     {
       return item_type(eval(CAR(arg_list)))==L_CONS_CELL ? true_symbol : NULL;
     } break;
-    case 80 : // numberp
+    case SYS_FUNC_NUMBERP:
     {
       int t=item_type(eval(CAR(arg_list)));
       if (t==L_NUMBER || t==L_FIXED_POINT) return true_symbol; else return NULL;
     } break;
-    case 81 : // do
+    case SYS_FUNC_DO:
     {
       void *init_var=CAR(arg_list);
       p_ref r1(init_var);
-      int i,ustack_start=l_user_stack.son;      // restore stack at end
+      int i, ustack_start=l_user_stack.son;      // restore stack at end
       void *sym=NULL;
       p_ref r2(sym);
@@ -2767 +2738 @@
 
       // now set all the symbols
-      for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var),do_evaled++)
+      for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var), do_evaled++)
       {
                 sym=CAR(CAR(init_var));
-                set_symbol_value(sym,*do_evaled);
+                set_symbol_value(sym, *do_evaled);
       }
 
@@ -2789 +2760 @@
       // restore old values for symbols
       do_evaled=l_user_stack.sdata+ustack_start;
-      for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var),do_evaled++)
+      for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var), do_evaled++)
       {
                 sym=CAR(CAR(init_var));
-                set_symbol_value(sym,*do_evaled);
+                set_symbol_value(sym, *do_evaled);
       }
 
@@ -2798 +2769 @@
 
     } break;
-    case 82 : // gc
+    case SYS_FUNC_GC:
     {
       collect_space(current_space);
     } break;
-    case 83 : // schar
+    case SYS_FUNC_SCHAR:
     {
       char *s=lstring_value(eval(CAR(arg_list)));      arg_list=CDR(arg_list);
@@ -2808 +2779 @@
 
       if ((unsigned)x >= strlen(s))
-      { lbreak("SCHAR: index %d should be less than the length of the string\n",x); exit(0); }
+      { lbreak("SCHAR: index %d should be less than the length of the string\n", x); exit(0); }
       else if (x<0)
       { lbreak("SCHAR: index should not be negative\n"); exit(0); }
       return new_lisp_character(s[x]);
     } break;
-    case 84 :// symbolp
+    case SYS_FUNC_SYMBOLP:
     { if (item_type(eval(CAR(arg_list)))==L_SYMBOL) return true_symbol;
       else return NULL; } break;
-    case 85 :  // num2str
+    case SYS_FUNC_NUM2STR:
     {
       char str[20];
-      sprintf(str,"%ld",(long int)lnumber_value(eval(CAR(arg_list))));
+      sprintf(str, "%ld", (long int)lnumber_value(eval(CAR(arg_list))));
       ret=new_lisp_string(str);
     } break;
-    case 86 : // nconc
+    case SYS_FUNC_NCONC:
     {
       void *l1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
       p_ref r1(l1);
-      void *first=l1,*next;
+      void *first=l1, *next;
       p_ref r2(first);
 
@@ -2846 +2817 @@
       ret=first;
     } break;
-    case 87 : // first
+    case SYS_FUNC_FIRST:
     { ret=CAR(eval(CAR(arg_list))); } break;
-    case 88 : // second
+    case SYS_FUNC_SECOND:
     { ret=CAR(CDR(eval(CAR(arg_list)))); } break;
-    case 89 : // third
+    case SYS_FUNC_THIRD:
     { ret=CAR(CDR(CDR(eval(CAR(arg_list))))); } break;
-    case 90 : // fourth
+    case SYS_FUNC_FOURTH:
     { ret=CAR(CDR(CDR(CDR(eval(CAR(arg_list)))))); } break;
-    case 91 : // fifth
+    case SYS_FUNC_FIFTH:
     { ret=CAR(CDR(CDR(CDR(CDR(eval(CAR(arg_list))))))); } break;
-    case 92 : // sixth
+    case SYS_FUNC_SIXTH:
     { ret=CAR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list)))))))); } break;
-    case 93 : // seventh
+    case SYS_FUNC_SEVENTH:
     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list))))))))); } break;
-    case 94 : // eight
+    case SYS_FUNC_EIGHTH:
     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list)))))))))); } break;
-    case 95 : // ninth
+    case SYS_FUNC_NINTH:
     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list))))))))))); } break;
-    case 96 : // tenth
+    case SYS_FUNC_TENTH:
     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list)))))))))))); } break;
-    case 97 :
+    case SYS_FUNC_SUBSTR:
     {
       long x1=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
@@ -2878 +2849 @@
       lisp_string *s=new_lisp_string(x2-x1+2);
       if (x2-x1)
-        memcpy(lstring_value(s),lstring_value(st)+x1,x2-x1+1);
+        memcpy(lstring_value(s), lstring_value(st)+x1, x2-x1+1);
 
       *(lstring_value(s)+(x2-x1+1))=0;
@@ -2885 +2856 @@
     case 99 :
     {
-      void *r=NULL,*rstart=NULL;
-      p_ref r1(r),r2(rstart);
+      void *r=NULL, *rstart=NULL;
+      p_ref r1(r), r2(rstart);
       while (arg_list)
       {
-                void *q=eval(CAR(arg_list));
-                if (!rstart) rstart=q;
-                while (r && CDR(r)) r=CDR(r);
-                CDR(r)=q;    
-                arg_list=CDR(arg_list);
+        void *q=eval(CAR(arg_list));
+        if (!rstart) rstart=q;
+        while (r && CDR(r)) r=CDR(r);
+        CDR(r)=q;    
+        arg_list=CDR(arg_list);
       }
       return rstart;
@@ -2899 +2870 @@
 
     default :
-    { dprintf("Undefined system function number %d\n",((lisp_sys_function *)fun)->fun_number); }
+    { dprintf("Undefined system function number %d\n", ((lisp_sys_function *)fun)->fun_number); }
   }
   return ret;
@@ -2953 +2924 @@
   void *fun_arg_list=cache.lblock(fun->alist);
   void *block_list=cache.lblock(fun->blist);
-  p_ref r9(block_list),r10(fun_arg_list);
+  p_ref r9(block_list), r10(fun_arg_list);
 #else
   void *fun_arg_list=fun->arg_list;
   void *block_list=fun->block_list;
-  p_ref r9(block_list),r10(fun_arg_list);
+  p_ref r9(block_list), r10(fun_arg_list);
 #endif
 
@@ -3043 +3014 @@
     if (trace_level<=trace_print_level)
     {
-      dprintf("%d (%d,%d,%d) TRACE : ",trace_level,
+      dprintf("%d (%d, %d, %d) TRACE : ", trace_level,
           space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]),
           space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
@@ -3077 +3048 @@
       case L_CONS_CELL :
       {
-        ret=eval_function((lisp_symbol *)CAR(prog),CDR(prog));
+        ret=eval_function((lisp_symbol *)CAR(prog), CDR(prog));
       }
       break;
       default :
-        fprintf(stderr,"shouldn't happen\n");
+        fprintf(stderr, "shouldn't happen\n");
     }
   }
@@ -3088 +3059 @@
     trace_level--;
     if (trace_level<=trace_print_level)
-      dprintf("%d (%d,%d,%d) TRACE ==> ",trace_level,
+      dprintf("%d (%d, %d, %d) TRACE ==> ", trace_level,
           space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]),
           space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
@@ -3104 +3075 @@
 }
 
-#define TOTAL_SYS_FUNCS 99
-char const *sys_funcs[TOTAL_SYS_FUNCS] =
-{
-    //  0      1    2       3       4      5      6      7
-    "print","car","cdr","length","list","cons","quote","eq",
-    // 8   9   10    11       12          13     14      15      16
-    "+","-","if","setf","symbol-list","assoc","null","acons","pairlis",
-    // 17     18     19     20     21     22    23      24
-    "let","defun","atom","not", "and", "or","progn","equal",
-    // 25               26          27       28  29   30     31
-    "concatenate","char-code","code-char","*","/","cond","select",
-    // 32            33         34     35    36    37
-    "function", "mapcar", "funcall", ">", "<", "tmp-space",
-    //   38              39        40       41         42
-    "perm-space","symbol-name","trace","untrace","digstr",
-    //   43            44   45    46    47  48       49
-    "compile-file","abs","min","max",">=","<=","backquote",
-    //  50      51      52         53           54    55     56
-    "comma","nth","resize-tmp","resize-perm","cos","sin","atan2",
-    // 57       58     59     60     61   62              63
-    "enum", "quit","eval","break","mod","write_profile","setq",
-    // 64    65          66      67       68        69        70
-    "for", "open_file","load","bit-and","bit-or","bit-xor","make-array",
-    // 71      72          73          74        75      76
-    "aref","if-1progn","if-2progn","if-12progn","eq0","preport",
-    // 77     78         79        80       81     82     83
-    "search","elt",    "listp", "numberp", "do",  "gc", "schar",
-    // 84       85        86      87      88        89    90
-    "symbolp","num2str","nconc","first","second","third","fourth",
-    // 91       92       93       94       95      96
-    "fifth", "sixth", "seventh","eighth","ninth","tenth",
-    "substr",       // 97
-    "local_load"    // 98, filename
-};
-
-/* select, digistr, load-file are not a common lisp functions! */
-
-short sys_args[TOTAL_SYS_FUNCS*2]={
-
-// 0      1       2        3       4         5       6      7        8
- 1, -1,   1, 1,   1, 1,   0, -1,   0, -1,   2, 2,   1, 1,   2, 2,  0, -1,
-// 9      10      11      12       13       14      15      16      17
- 1, -1,   2, 3,   2, 2,   0, 0,    2, 2,    1, 1,   2, 2,   2, 2,   1, -1,
-// 18     19      20      21       22       23      24      25      26
- 2, -1,  1, 1,   1, 1,  -1, -1,  -1, -1,  -1, -1,  2, 2,   1,-1,   1, 1,
-// 27      28      29     30       31      32        33,     34      35
- 1, 1,   -1,-1,  1,-1,  -1, -1,   1,-1,    1, 1,   2, -1,  1,-1,   2,2,
-// 36     37     38       39       40       41      42      43      44
- 2,2,    0,0,   0,0,      1,1,    0,-1,    0,-1,   2,2,    1,1,    1,1,
-// 45     46     47       48       49       50      51      52      53
- 2,2,    2,2,   2,2,     2,2,     1,1,     1,1,    2,2,    1,1,    1,1,
-// 54     55     56       57       58       59      60      61      62
- 1,1,    1,1,   2,2,     1,-1,    0,0,     1,1,    0,0,    2,2,    1,1,
-// 63     64     65      66        67       68      69      70      71
- 2,2,    4,-1,  2,-1,    1,1,     1,-1,    1,-1,   1,-1,   1,-1,    2,2,
-// 72     73     74      75        76       77      78      79       80
- 2,3,     2,3,  2,3,     1,1,     1,1,     2,2,    2,2,    1,1,     1,1,
-// 81     82     83      84        85       86      87       88      89
- 2,3,     0,0,  2,2,     1,1,     1,1,     2,-1,   1,1,     1,1,    1,1,
-// 90      91    92      93        94       95      96       97     98
- 1,1,     1,1,   1,1,    1,1,     1,1,      1,1,     1,1,   3,3,    1,1
-
-};
-
 int total_symbols()
 {
@@ -3177 +3084 @@
   if (new_size<((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]))
   {
-    lbreak("resize perm : %d is to small to hold current heap\n",new_size);
+    lbreak("resize perm : %d is to small to hold current heap\n", new_size);
     exit(0);
   } else if (new_size>space_size[PERM_SPACE])
@@ -3191 +3098 @@
   if (new_size<((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]))
   {
-    lbreak("resize perm : %d is to small to hold current heap\n",new_size);
+    lbreak("resize perm : %d is to small to hold current heap\n", new_size);
     exit(0);
   } else if (new_size>space_size[TMP_SPACE])
@@ -3199 +3106 @@
   } else if (free_space[TMP_SPACE]==space[TMP_SPACE])
   {
-    free_space[TMP_SPACE]=space[TMP_SPACE]=(char *)realloc(space[TMP_SPACE],new_size);
+    free_space[TMP_SPACE]=space[TMP_SPACE]=(char *)realloc(space[TMP_SPACE], new_size);
     space_size[TMP_SPACE]=new_size;
-    dprintf("Lisp : tmp space resized to %d\n",new_size);
+    dprintf("Lisp : tmp space resized to %d\n", new_size);
   } else dprintf("Lisp :tmp not empty, cannot resize\n");
 }
@@ -3223 +3130 @@
 
   l_comp_init();
-  for (i=0;i<TOTAL_SYS_FUNCS;i++)
-    add_sys_function(sys_funcs[i],sys_args[i*2],sys_args[i*2+1],i);
+  for(i = 0; i < sizeof(sys_funcs) / sizeof(*sys_funcs); i++)
+    add_sys_function(sys_funcs[i].name,
+                     sys_funcs[i].min_args, sys_funcs[i].max_args, i);
   clisp_init();
   current_space=TMP_SPACE;
   dprintf("Lisp : %d symbols defined, %d system functions, %d pre-compiled functions\n",
-      total_symbols(),TOTAL_SYS_FUNCS,total_user_functions);
+      total_symbols(), sizeof(sys_funcs) / sizeof(*sys_funcs), total_user_functions);
 }