Changeset 493


Ignore:
Timestamp:
Apr 17, 2011, 3:58:41 PM (7 years ago)
Author:
Sam Hocevar
Message:

lisp: refactor stuff for better type checking.

Location:
abuse/trunk/src
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/ant.cpp

    r492 r493  
    112112    void *call_list=NULL;
    113113    PtrRef r1(call_list);
    114     push_onto_list(new_lisp_pointer(b),call_list);
     114    push_onto_list(LPointer::Create(b),call_list);
    115115    push_onto_list(LNumber::Create(angle),call_list);
    116116    push_onto_list(LNumber::Create(firey),call_list);
    117117    push_onto_list(LNumber::Create(firex),call_list);
    118118    push_onto_list(LNumber::Create(o->aitype()),call_list);
    119     push_onto_list(new_lisp_pointer(o),call_list);
     119    push_onto_list(LPointer::Create(o),call_list);
    120120    eval_user_fun((LSymbol *)l_fire_object,call_list);
    121121    o->set_state((character_state)S_weapon_fire);
  • abuse/trunk/src/cache.cpp

    r492 r493  
    879879    {
    880880      delete cache_file;
    881       lprint(block);
     881      ((LObject *)block)->Print();
    882882      fprintf(stderr,"Unable to open lisp cache file name %s\n",lfname);
    883883      exit(0);
  • abuse/trunk/src/chars.cpp

    r492 r493  
    8585  if (item_type(symbol)!=L_SYMBOL)
    8686  {
    87     lprint(symbol);
     87    ((LObject *)symbol)->Print();
    8888    lbreak("is not a symbol (in def_char)");
    8989    exit(0);
     
    9797    if (item_type(val)!=L_NUMBER)
    9898    {
    99       lprint(symbol);
     99      ((LObject *)symbol)->Print();
    100100      dprintf("expecting symbol value to be a number, instead got : ");
    101       lprint(val);
     101      ((LObject *)val)->Print();
    102102      lbreak("");
    103103      exit(0);
     
    116116  if (num<ts && seq[num])
    117117  {
    118     lprint(symbol);
     118    ((LObject *)symbol)->Print();
    119119    lbreak("symbol has been assigned value %d, but value already in use by state %s\n"
    120120       "use a different symbol for this state\n",
     
    205205  if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
    206206  {
    207     lprint(symbol);
     207    ((LObject *)symbol)->Print();
    208208    lbreak("symbol already has a value, cannot instantiate an object varible");
    209209    exit(0);
    210210  } else if (DEFINEDP(s->value))
    211211  {
    212     int index=((LObjectVar *)s->value)->number;
     212    int index=((LObjectVar *)s->value)->index;
    213213    if (index<tiv)
    214214    {
     
    405405    if (!isa_var_name(real))
    406406    {
    407       lprint(field);
     407      ((LObject *)field)->Print();
    408408      lbreak("fields : no such var name \"%s\"\n",name);
    409409      exit(0);
     
    432432    else
    433433    {
    434       lprint(lcar(field));
     434      ((LObject *)lcar(field))->Print();
    435435      lbreak("Unknown field for character definition");
    436436      exit(0);
  • abuse/trunk/src/clisp.cpp

    r492 r493  
    602602      game_object *hit=current_object->bmove(whit,o);
    603603      if (hit)
    604         return new_lisp_pointer(hit);
     604        return LPointer::Create(hit);
    605605      else if (whit) return NULL;
    606606      else return true_symbol;
    607607    } break;
    608608
    609     case 3 : return new_lisp_pointer(current_object); break;
     609    case 3 : return LPointer::Create(current_object); break;
    610610    case 4 :
    611611    { if (player_list->next)
    612         return new_lisp_pointer(current_level->attacker(current_object));
    613       else return new_lisp_pointer(player_list->focus); } break;
    614     case 5 : return new_lisp_pointer(current_level->find_closest(current_object->x,
     612        return LPointer::Create(current_level->attacker(current_object));
     613      else return LPointer::Create(player_list->focus); } break;
     614    case 5 : return LPointer::Create(current_level->find_closest(current_object->x,
    615615                                 current_object->y,
    616616                               lnumber_value(eval(CAR(args))),
    617617                                       current_object)); break;
    618     case 6 : return new_lisp_pointer(current_level->find_xclosest(current_object->x,
     618    case 6 : return LPointer::Create(current_level->find_xclosest(current_object->x,
    619619                                  current_object->y,
    620620                                  lnumber_value(eval(CAR(args))),
     
    625625      long n1=lnumber_value(eval(CAR(args)));
    626626      long n2=lnumber_value(eval(CAR(CDR(args))));
    627       return new_lisp_pointer(current_level->find_xrange(current_object->x,
     627      return LPointer::Create(current_level->find_xrange(current_object->x,
    628628                             current_object->y,
    629629                             n1,
     
    643643      if (current_level)
    644644        current_level->add_object(o);
    645       return new_lisp_pointer(o);
     645      return LPointer::Create(o);
    646646    } break;
    647647    case 22 :
     
    657657      if (current_level)
    658658        current_level->add_object_after(o,current_object);
    659       return new_lisp_pointer(o);
    660     } break;
    661 
    662     case 9 : return new_lisp_pointer(the_game->first_view->focus); break;
     659      return LPointer::Create(o);
     660    } break;
     661
     662    case 9 : return LPointer::Create(the_game->first_view->focus); break;
    663663    case 10 :
    664664    {
    665665      view *v=((game_object *)lpointer_value(eval(CAR(args))))->controller()->next;
    666666      if (v)
    667         return new_lisp_pointer(v->focus);
     667        return LPointer::Create(v->focus);
    668668      else return NULL;
    669669    } break;
    670670    case 11 :
    671671    {
    672       return new_lisp_pointer
     672      return LPointer::Create
    673673      ((void *)current_object->get_object(lnumber_value(eval(CAR(args)))));
    674674    } break;
    675675    case 12 :
    676676    {
    677       return new_lisp_pointer
     677      return LPointer::Create
    678678      ((void *)current_object->get_light(lnumber_value(eval(CAR(args)))));
    679679    } break;
     
    699699      int xs=lnumber_value(eval(CAR(args))); args=lcdr(args);
    700700      int ys=lnumber_value(eval(CAR(args)));
    701       return new_lisp_pointer(add_light_source(t,x,y,r1,r2,xs,ys));
     701      return LPointer::Create(add_light_source(t,x,y,r1,r2,xs,ys));
    702702    } break;
    703703    case 15 :
     
    722722      }
    723723      time_marker end;
    724       return new_lisp_fixed_point((long)(end.diff_time(&start)*(1<<16)));
     724      return LFixedPoint::Create((long)(end.diff_time(&start)*(1<<16)));
    725725    } break;
    726726    case 18 :
     
    739739                          current_object->y,
    740740                          x1,y1,x2,y2,list,current_object);
    741       if (find) return new_lisp_pointer(find);
     741      if (find) return LPointer::Create(find);
    742742      else return NULL;
    743743    } break;
     
    753753                            current_object->y,
    754754                            a1,a2,list,current_object);
    755       if (find) return new_lisp_pointer(find);
     755      if (find) return LPointer::Create(find);
    756756      else return NULL;
    757757    } break;
     
    928928      return ret;
    929929    } break;
    930     case 51 :   return new_lisp_pointer(wm->font()); break;
     930    case 51 :   return LPointer::Create(wm->font()); break;
    931931    case 52 :
    932932    {
     
    995995        long x;
    996996        sscanf(lstring_value(eval(CAR(args))),"%lx",&x);
    997         return new_lisp_pointer((void *)(intptr_t)x);
     997        return LPointer::Create((void *)(intptr_t)x);
    998998    } break;
    999999    case 64 :
     
    13921392      if (!a)
    13931393      {
    1394         lprint(args);
     1394        ((LObject *)args)->Print();
    13951395        lbreak("expecting y after x in play_sound\n");
    13961396        exit(1);
     
    14781478      if (a<0 || a>=TOTAL_ABILITIES)
    14791479      {
    1480     lprint(args);
     1480    ((LObject *)args)->Print();
    14811481    lbreak("bad ability number for get_ability, should be 0..%d, not %d\n",
    14821482        TOTAL_ABILITIES,a);
     
    15731573      if (r<0 || b<0 || g<0 || r>255 || g>255 || b>255)
    15741574      {
    1575     lprint(args);
     1575    ((LObject *)args)->Print();
    15761576    lbreak("color out of range (0..255) in color lookup\n");
    15771577    exit(0);
     
    15821582    {
    15831583      view *v=current_object->controller();
    1584       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1584      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    15851585      else return v->x_suggestion;
    15861586    } break;
     
    15881588    {
    15891589      view *v=current_object->controller();
    1590       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1590      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    15911591      else return v->y_suggestion;
    15921592    } break;
     
    15941594    {
    15951595      view *v=current_object->controller();
    1596       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1596      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    15971597      else return v->b1_suggestion;
    15981598    } break;
     
    16001600    {
    16011601      view *v=current_object->controller();
    1602       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1602      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    16031603      else return v->b2_suggestion;
    16041604    } break;
     
    16061606    {
    16071607      view *v=current_object->controller();
    1608       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1608      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    16091609      else return v->b3_suggestion;
    16101610    } break;
     
    16151615      bg_ymul=lnumber_value(CAR(args)); args=CDR(args);
    16161616      bg_ydiv=lnumber_value(CAR(args));
    1617       if (bg_xdiv==0) { bg_xdiv=1; lprint(args); dprintf("bg_set_scroll : cannot set xdiv to 0\n"); }
    1618       if (bg_ydiv==0) { bg_ydiv=1; lprint(args); dprintf("bg_set_scroll : cannot set ydiv to 0\n"); }
     1617      if (bg_xdiv==0) { bg_xdiv=1; ((LObject *)args)->Print(); dprintf("bg_set_scroll : cannot set xdiv to 0\n"); }
     1618      if (bg_ydiv==0) { bg_ydiv=1; ((LObject *)args)->Print(); dprintf("bg_set_scroll : cannot set ydiv to 0\n"); }
    16191619    } break;
    16201620    case 179 :
     
    19831983    {
    19841984      view *v=current_object->controller();
    1985       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1985      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    19861986      else return v->pointer_x;
    19871987    } break;
     
    19891989    {
    19901990      view *v=current_object->controller();
    1991       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     1991      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    19921992      else return v->pointer_y;
    19931993    } break;
     
    20642064    {
    20652065      view *v=current_object->controller();
    2066       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2066      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    20672067      else return v->kills;
    20682068    } break;
     
    20702070    {
    20712071      view *v=current_object->controller();
    2072       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2072      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    20732073      else return v->tkills;
    20742074    } break;
     
    20762076    {
    20772077      view *v=current_object->controller();
    2078       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2078      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    20792079      else return v->secrets;
    20802080    } break;
     
    20822082    {
    20832083      view *v=current_object->controller();
    2084       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2084      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    20852085      else return v->tsecrets;
    20862086    } break;
     
    20882088    {
    20892089      view *v=current_object->controller();
    2090       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2090      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    20912091      else v->kills=lnumber_value(CAR(args));
    20922092    } break;
     
    20942094    {
    20952095      view *v=current_object->controller();
    2096       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2096      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    20972097      else v->tkills=lnumber_value(CAR(args));
    20982098    } break;
     
    21002100    {
    21012101      view *v=current_object->controller();
    2102       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2102      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    21032103      else v->secrets=lnumber_value(CAR(args));
    21042104    } break;
     
    21062106    {
    21072107      view *v=current_object->controller();
    2108       if (!v) { lprint(args); printf("get_player_inputs : object has no view!\n"); }
     2108      if (!v) { ((LObject *)args)->Print(); printf("get_player_inputs : object has no view!\n"); }
    21092109      else v->tsecrets=lnumber_value(CAR(args));
    21102110    } break;
  • abuse/trunk/src/cop.cpp

    r492 r493  
    227227  void *list=NULL;
    228228  PtrRef r1(list);
    229   push_onto_list(new_lisp_pointer(target),list);
     229  push_onto_list(LPointer::Create(target),list);
    230230  push_onto_list(LNumber::Create(angle),list);
    231231  push_onto_list(LNumber::Create(y2),list);
    232232  push_onto_list(LNumber::Create(x2),list);
    233233  push_onto_list(LNumber::Create(type),list);
    234   push_onto_list(new_lisp_pointer(o->get_object(0)),list);
     234  push_onto_list(LPointer::Create(o->get_object(0)),list);
    235235  eval_function((LSymbol *)l_fire_object,list);
    236236  o->lvars[top_just_fired]=1;
  • abuse/trunk/src/game.cpp

    r492 r493  
    23132313                    l_user_stack.push(prog);
    23142314                    while(*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
    2315                     lprint(eval(prog));
     2315                    ((LObject *)eval(prog))->Print();
    23162316                    l_user_stack.pop(1);
    23172317                }
  • abuse/trunk/src/lcache.cpp

    r492 r493  
    105105    { return LNumber::Create(fp->read_uint32()); } break;
    106106    case L_CHARACTER :
    107     { return new_lisp_character(fp->read_uint16()); } break;
     107    { return LChar::Create(fp->read_uint16()); } break;
    108108    case L_STRING :
    109109    { long l=fp->read_uint32();
  • abuse/trunk/src/lisp/lisp.cpp

    r492 r493  
    4141
    4242bFILE *current_print_file=NULL;
    43 LSymbol *lsym_root=NULL;
    44 long ltotal_syms=0;
    45 
     43
     44LSymbol *LSymbol::root = NULL;
     45size_t LSymbol::count = 0;
    4646
    4747
     
    5858    if(!block || item_type(block) != L_CONS_CELL)
    5959    {
    60         lprint(block);
     60        ((LObject *)block)->Print();
    6161        return;
    6262    }
     
    6969            dprintf("[...]");
    7070        else
    71             lprint(a);
     71            ((LObject *)a)->Print();
    7272    }
    7373    if (block)
    7474    {
    7575        dprintf(" . ");
    76         lprint(block);
     76        ((LObject *)block)->Print();
    7777    }
    7878    dprintf(")");
     
    8888    {
    8989        dprintf("%d> ", i);
    90         lprint(*PtrRef::stack.sdata[i]);
     90        ((LObject *)*PtrRef::stack.sdata[i])->Print();
    9191    }
    9292}
     
    142142                PtrRef r1(prog);
    143143                while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
    144                 lprint(eval(prog));
     144                ((LObject *)eval(prog))->Print();
    145145      } while (*s);
    146146    }
     
    220220}
    221221
    222 LArray *LArray::Create(int size, void *rest)
    223 {
    224   PtrRef r11(rest);
    225   size_t s = sizeof(LArray)
    226            + ((size < 1 ? 1 : size) - 1) * sizeof(LObject *);
    227   LArray *p = (LArray *)lmalloc(s, current_space);
    228   p->type = L_1D_ARRAY;
    229   p->size = size;
    230   LObject **data = p->GetData();
    231   memset(data, 0, size * sizeof(LObject *));
    232   PtrRef r1(p);
    233 
    234   if (rest)
    235   {
    236     void *x=eval(CAR(rest));
    237     if (x==colon_initial_contents)
    238     {
    239       x=eval(CAR(CDR(rest)));
    240       data = p->GetData();
    241       for (int i=0;i<size;i++, x=CDR(x))
    242       {
    243         if (!x)
    244         {
    245           lprint(rest);
    246           lbreak("(make-array) incorrect list length\n");
    247           exit(0);
    248         }
    249         data[i] = (LObject *)CAR(x);
    250       }
    251       if (x)
    252       {
    253         lprint(rest);
    254         lbreak("(make-array) incorrect list length\n");
    255         exit(0);
    256       }
    257     }
    258     else if (x==colon_initial_element)
    259     {
    260       x=eval(CAR(CDR(rest)));
    261       data = p->GetData();
    262       for (int i=0;i<size;i++)
    263         data[i] = (LObject *)x;
    264     }
    265     else
    266     {
    267       lprint(x);
    268       lbreak("Bad option argument to make-array\n");
    269       exit(0);
    270     }
    271   }
    272 
    273   return p;
    274 }
    275 
    276 LFixedPoint *new_lisp_fixed_point(int32_t x)
    277 {
    278   LFixedPoint *p=(LFixedPoint *)lmalloc(sizeof(LFixedPoint), current_space);
    279   p->type=L_FIXED_POINT;
    280   p->x=x;
    281   return p;
    282 }
    283 
    284 
    285 LObjectVar *new_lisp_object_var(int16_t number)
    286 {
    287   LObjectVar *p=(LObjectVar *)lmalloc(sizeof(LObjectVar), current_space);
    288   p->type=L_OBJECT_VAR;
    289   p->number=number;
    290   return p;
    291 }
    292 
    293 
    294 struct LPointer *new_lisp_pointer(void *addr)
    295 {
    296   if (addr==NULL) return NULL;
    297   LPointer *p=(LPointer *)lmalloc(sizeof(LPointer), current_space);
    298   p->type=L_POINTER;
    299   p->addr=addr;
    300   return p;
    301 }
    302 
    303 struct LChar *new_lisp_character(uint16_t ch)
    304 {
    305   LChar *c=(LChar *)lmalloc(sizeof(LChar), current_space);
    306   c->type=L_CHARACTER;
    307   c->ch=ch;
    308   return c;
    309 }
    310 
    311 struct LString *LString::Create(char const *string)
    312 {
    313     size_t size = sizeof(LString) + strlen(string);
     222LArray *LArray::Create(size_t len, void *rest)
     223{
     224    PtrRef r11(rest);
     225    size_t size = sizeof(LArray) + (len - 1) * sizeof(LObject *);
    314226    if (size < sizeof(LRedirect))
    315227        size = sizeof(LRedirect);
    316228
    317     LString *s = (LString *)lmalloc(size, current_space);
    318     s->type = L_STRING;
     229    LArray *p = (LArray *)lmalloc(size, current_space);
     230    p->type = L_1D_ARRAY;
     231    p->len = len;
     232    LObject **data = p->GetData();
     233    memset(data, 0, len * sizeof(LObject *));
     234    PtrRef r1(p);
     235
     236    if (rest)
     237    {
     238        void *x = eval(CAR(rest));
     239        if (x == colon_initial_contents)
     240        {
     241            x = eval(CAR(CDR(rest)));
     242            data = p->GetData();
     243            for (size_t i = 0; i < len; i++, x = CDR(x))
     244            {
     245                if (!x)
     246                {
     247                    ((LObject *)rest)->Print();
     248                    lbreak("(make-array) incorrect list length\n");
     249                    exit(0);
     250                }
     251                data[i] = (LObject *)CAR(x);
     252            }
     253            if (x)
     254            {
     255                ((LObject *)rest)->Print();
     256                lbreak("(make-array) incorrect list length\n");
     257                exit(0);
     258            }
     259        }
     260        else if (x == colon_initial_element)
     261        {
     262            x = eval(CAR(CDR(rest)));
     263            data = p->GetData();
     264            for (size_t i = 0; i < len; i++)
     265                data[i] = (LObject *)x;
     266        }
     267        else
     268        {
     269            ((LObject *)x)->Print();
     270            lbreak("Bad option argument to make-array\n");
     271            exit(0);
     272        }
     273    }
     274
     275    return p;
     276}
     277
     278LFixedPoint *LFixedPoint::Create(int32_t x)
     279{
     280    size_t size = sizeof(LFixedPoint);
     281    if (size < sizeof(LRedirect))
     282        size = sizeof(LRedirect);
     283
     284    LFixedPoint *p = (LFixedPoint *)lmalloc(size, current_space);
     285    p->type = L_FIXED_POINT;
     286    p->x = x;
     287    return p;
     288}
     289
     290LObjectVar *LObjectVar::Create(int index)
     291{
     292    size_t size = sizeof(LObjectVar);
     293    if (size < sizeof(LRedirect))
     294        size = sizeof(LRedirect);
     295
     296    LObjectVar *p = (LObjectVar *)lmalloc(size, current_space);
     297    p->type = L_OBJECT_VAR;
     298    p->index = index;
     299    return p;
     300}
     301
     302LPointer *LPointer::Create(void *addr)
     303{
     304    if (addr == NULL)
     305        return NULL;
     306    size_t size = sizeof(LPointer);
     307    if (size < sizeof(LRedirect))
     308        size = sizeof(LRedirect);
     309
     310    LPointer *p = (LPointer *)lmalloc(size, current_space);
     311    p->type = L_POINTER;
     312    p->addr = addr;
     313    return p;
     314}
     315
     316LChar *LChar::Create(uint16_t ch)
     317{
     318    size_t size = sizeof(LChar);
     319    if (size < sizeof(LRedirect))
     320        size = sizeof(LRedirect);
     321
     322    LChar *c = (LChar *)lmalloc(size, current_space);
     323    c->type = L_CHARACTER;
     324    c->ch = ch;
     325    return c;
     326}
     327
     328struct LString *LString::Create(char const *string)
     329{
     330    LString *s = Create(strlen(string) + 1);
    319331    strcpy(s->str, string);
    320332    return s;
     
    323335struct LString *LString::Create(char const *string, int length)
    324336{
    325     size_t size = sizeof(LString) + length;
    326     if (size < sizeof(LRedirect))
    327         size = sizeof(LRedirect);
    328 
    329     LString *s = (LString *)lmalloc(size, current_space);
    330     s->type = L_STRING;
     337    LString *s = Create(length + 1);
    331338    memcpy(s->str, string, length);
    332339    s->str[length] = 0;
     
    349356LUserFunction *new_lisp_user_function(void *arg_list, void *block_list)
    350357{
    351   PtrRef r1(arg_list), r2(block_list);
    352   LUserFunction *lu=(LUserFunction *)lmalloc(sizeof(LUserFunction), current_space);
    353   lu->type=L_USER_FUNCTION;
    354   lu->arg_list=arg_list;
    355   lu->block_list=block_list;
    356   return lu;
     358    PtrRef r1(arg_list), r2(block_list);
     359
     360    size_t size = sizeof(LUserFunction);
     361    if (size < sizeof(LRedirect))
     362        size = sizeof(LRedirect);
     363
     364    LUserFunction *lu = (LUserFunction *)lmalloc(size, current_space);
     365    lu->type = L_USER_FUNCTION;
     366    lu->arg_list = arg_list;
     367    lu->block_list = block_list;
     368    return lu;
    357369}
    358370#else
    359371LUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
    360372{
    361   int sp=current_space;
    362   if (current_space!=GC_SPACE)
    363     current_space=PERM_SPACE;       // make sure all functions get defined in permanant space
    364 
    365   LUserFunction *lu=(LUserFunction *)lmalloc(sizeof(LUserFunction), current_space);
    366   lu->type=L_USER_FUNCTION;
    367   lu->alist=arg_list;
    368   lu->blist=block_list;
    369 
    370   current_space=sp;
    371 
    372   return lu;
    373 }
    374 #endif
    375 
     373    // Make sure all functions get defined in permanent space
     374    int sp = current_space;
     375    if (current_space != GC_SPACE)
     376        current_space = PERM_SPACE;
     377
     378    size_t size = sizeof(LUserFunction);
     379    if (size < sizeof(LRedirect))
     380        size = sizeof(LRedirect);
     381
     382    LUserFunction *lu = (LUserFunction *)lmalloc(size, current_space);
     383    lu->type = L_USER_FUNCTION;
     384    lu->alist = arg_list;
     385    lu->blist = block_list;
     386
     387    current_space = sp;
     388
     389    return lu;
     390}
     391#endif
    376392
    377393LSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number)
    378394{
    379   // sys functions should reside in permanant space
    380   LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
    381                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    382   ls->type=L_SYS_FUNCTION;
    383   ls->min_args=min_args;
    384   ls->max_args=max_args;
    385   ls->fun_number=fun_number;
    386   return ls;
     395    size_t size = sizeof(LSysFunction);
     396    if (size < sizeof(LRedirect))
     397        size = sizeof(LRedirect);
     398
     399    // System functions should reside in permanant space
     400    int space = (current_space == GC_SPACE) ? GC_SPACE : PERM_SPACE;
     401    LSysFunction *ls = (LSysFunction *)lmalloc(size, space);
     402    ls->type = L_SYS_FUNCTION;
     403    ls->min_args = min_args;
     404    ls->max_args = max_args;
     405    ls->fun_number = fun_number;
     406    return ls;
    387407}
    388408
    389409LSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number)
    390410{
    391   // sys functions should reside in permanant space
    392   LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
    393                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    394   ls->type=L_C_FUNCTION;
    395   ls->min_args=min_args;
    396   ls->max_args=max_args;
    397   ls->fun_number=fun_number;
    398   return ls;
     411    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
     412    ls->type = L_C_FUNCTION;
     413    return ls;
    399414}
    400415
    401416LSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number)
    402417{
    403   // sys functions should reside in permanant space
    404   LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
    405                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    406   ls->type=L_C_BOOL;
    407   ls->min_args=min_args;
    408   ls->max_args=max_args;
    409   ls->fun_number=fun_number;
    410   return ls;
     418    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
     419    ls->type = L_C_BOOL;
     420    return ls;
    411421}
    412422
    413423LSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number)
    414424{
    415   // sys functions should reside in permanant space
    416   LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
    417                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    418   ls->type=L_L_FUNCTION;
    419   ls->min_args=min_args;
    420   ls->max_args=max_args;
    421   ls->fun_number=fun_number;
    422   return ls;
    423 }
    424 
    425 LNumber *new_lisp_node(long num)
    426 {
    427   LNumber *n=(LNumber *)lmalloc(sizeof(LNumber), current_space);
    428   n->type=L_NUMBER;
    429   n->num=num;
    430   return n;
     425    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
     426    ls->type = L_L_FUNCTION;
     427    return ls;
    431428}
    432429
    433430LSymbol *new_lisp_symbol(char *name)
    434431{
    435   LSymbol *s=(LSymbol *)lmalloc(sizeof(LSymbol), current_space);
    436   s->type=L_SYMBOL;
    437   s->name=LString::Create(name);
    438   s->value=l_undefined;
    439   s->function=l_undefined;
     432    size_t size = sizeof(LSymbol);
     433    if (size < sizeof(LRedirect))
     434        size = sizeof(LRedirect);
     435
     436    LSymbol *s = (LSymbol *)lmalloc(size, current_space);
     437    s->type = L_SYMBOL;
     438    s->name = LString::Create(name);
     439    s->value = l_undefined;
     440    s->function = l_undefined;
    440441#ifdef L_PROFILE
    441   s->time_taken=0;
    442 #endif
    443   return s;
     442    s->time_taken = 0;
     443#endif
     444    return s;
    444445}
    445446
    446447LNumber *LNumber::Create(long num)
    447448{
    448     LNumber *s = (LNumber *)lmalloc(sizeof(LNumber), current_space);
    449     s->type = L_NUMBER;
    450     s->num = num;
    451     return s;
     449    size_t size = sizeof(LNumber);
     450    if (size < sizeof(LRedirect))
     451        size = sizeof(LRedirect);
     452
     453    LNumber *n = (LNumber *)lmalloc(size, current_space);
     454    n->type = L_NUMBER;
     455    n->num = num;
     456    return n;
    452457}
    453458
    454459LList *LList::Create()
    455460{
    456     LList *c = (LList *)lmalloc(sizeof(LList), current_space);
     461    size_t size = sizeof(LList);
     462    if (size < sizeof(LRedirect))
     463        size = sizeof(LRedirect);
     464
     465    LList *c = (LList *)lmalloc(size, current_space);
    457466    c->type = L_CONS_CELL;
    458467    c->car = NULL;
     
    503512  else if (item_type(lpointer)!=L_POINTER)
    504513  {
    505     lprint(lpointer);
     514    ((LObject *)lpointer)->Print();
    506515    lbreak(" is not a pointer\n");
    507516    exit(0);
     
    525534    default :
    526535    {
    527       lprint(lnumber);
     536      ((LObject *)lnumber)->Print();
    528537      lbreak(" is not a number\n");
    529538      exit(0);
     
    538547    if (item_type(this) != L_STRING)
    539548    {
    540         lprint(this);
     549        Print();
    541550        lbreak(" is not a string\n");
    542551        exit(0);
     
    575584  if (item_type(c)!=L_CHARACTER)
    576585  {
    577     lprint(c);
     586    ((LObject *)c)->Print();
    578587    lbreak("is not a character\n");
    579588    exit(0);
     
    593602    default :
    594603    {
    595       lprint(c);
     604      ((LObject *)c)->Print();
    596605      lbreak(" is not a number\n");
    597606      exit(0);
     
    626635}
    627636
    628 LObject *LArray::Get(long x)
     637LObject *LArray::Get(int x)
    629638{
    630639#ifdef TYPE_CHECKING
    631640    if (type != L_1D_ARRAY)
    632641    {
    633         lprint(this);
     642        Print();
    634643        lbreak("is not an array\n");
    635644        exit(0);
    636645    }
    637646#endif
    638     if (x >= size || x < 0)
     647    if (x >= (int)len || x < 0)
    639648    {
    640649        lbreak("array reference out of bounds (%d)\n", x);
    641650        exit(0);
    642651    }
    643     return GetData()[x];
     652    return data[x];
    644653}
    645654
     
    820829LSymbol *LSymbol::Find(char const *name)
    821830{
    822     LSymbol *p = lsym_root;
     831    LSymbol *p = root;
    823832    while (p)
    824833    {
     
    833842LSymbol *LSymbol::FindOrCreate(char const *name)
    834843{
    835     LSymbol *p = lsym_root;
    836     LSymbol **parent = &lsym_root;
     844    LSymbol *p = root;
     845    LSymbol **parent = &root;
    837846    while (p)
    838847    {
     
    861870    p->left = p->right = NULL;
    862871    *parent = p;
    863     ltotal_syms++;
     872    count++;
    864873
    865874    current_space = sp;
     
    900909    if (this && item_type(this) != (ltype)L_CONS_CELL)
    901910    {
    902         lprint(this);
     911        Print();
    903912        lbreak(" is not a sequence\n");
    904913        exit(0);
     
    922931  if (l1!=l2)
    923932  {
    924     lprint(list1);
    925     lprint(list2);
     933    ((LObject *)list1)->Print();
     934    ((LObject *)list2)->Print();
    926935    lbreak("... are not the same length (pairlis)\n");
    927936    exit(0);
     
    975984}
    976985
    977 LSymbol *add_c_object(void *symbol, int16_t number)
     986LSymbol *add_c_object(void *symbol, int index)
    978987{
    979988  need_perm_space("add_c_object");
     
    984993    exit(0);
    985994  }
    986   else s->value=new_lisp_object_var(number);
     995  else s->value=LObjectVar::Create(index);
    987996  return NULL;
    988997}
     
    12391248      read_ltoken(s, n);                   // read character name
    12401249      if (!strcmp(n, "newline"))
    1241         ret=new_lisp_character('\n');
     1250        ret = LChar::Create('\n');
    12421251      else if (!strcmp(n, "space"))
    1243         ret=new_lisp_character(' ');
     1252        ret = LChar::Create(' ');
    12441253      else
    1245         ret=new_lisp_character(n[0]);
     1254        ret = LChar::Create(n[0]);
    12461255    }
    12471256    else if (n[1]==0)                           // short hand for function
     
    12951304}
    12961305
    1297 void lprint(void *i)
    1298 {
    1299   print_level++;
    1300   if (!i)
    1301     lprint_string("nil");
    1302   else
    1303   {
    1304     switch ((short)item_type(i))
    1305     {
    1306       case L_CONS_CELL :
    1307       {
    1308                 LList *cs=(LList *)i;
    1309         lprint_string("(");
    1310         for (;cs;cs=(LList *)lcdr(cs))   
     1306void LObject::Print()
     1307{
     1308    char buf[32];
     1309
     1310    print_level++;
     1311
     1312    switch (item_type(this))
     1313    {
     1314    case L_CONS_CELL:
     1315        if (!this)
     1316        {
     1317            lprint_string("nil");
     1318        }
     1319        else
     1320        {
     1321            LList *cs = (LList *)this;
     1322            lprint_string("(");
     1323            for (; cs; cs = (LList *)lcdr(cs))
     1324            {
     1325                if (item_type(cs) == (ltype)L_CONS_CELL)
    13111326                {
    1312                   if (item_type(cs)==(ltype)L_CONS_CELL)
    1313                   {
    1314                         lprint(cs->car);
     1327                    cs->car->Print();
    13151328                    if (cs->cdr)
    1316                       lprint_string(" ");
    1317                   }
    1318                   else
    1319                   {
     1329                        lprint_string(" ");
     1330                }
     1331                else
     1332                {
    13201333                    lprint_string(". ");
    1321                     lprint(cs);
    1322                     cs=NULL;
    1323                   }
     1334                    cs->Print();
     1335                    cs = NULL;
    13241336                }
    1325         lprint_string(")");
    1326       }
    1327       break;
    1328       case L_NUMBER :
    1329       {
    1330                 char num[10];
    1331                 sprintf(num, "%ld", ((LNumber *)i)->num);
    1332         lprint_string(num);
    1333       }
    1334       break;
    1335       case L_SYMBOL :
    1336         lprint_string(((LSymbol *)i)->name->GetString());
    1337       break;
    1338       case L_USER_FUNCTION :
    1339       case L_SYS_FUNCTION :
     1337            }
     1338            lprint_string(")");
     1339        }
     1340        break;
     1341    case L_NUMBER:
     1342        sprintf(buf, "%ld", ((LNumber *)this)->num);
     1343        lprint_string(buf);
     1344        break;
     1345    case L_SYMBOL:
     1346        lprint_string(((LSymbol *)this)->name->GetString());
     1347        break;
     1348    case L_USER_FUNCTION:
     1349    case L_SYS_FUNCTION:
    13401350        lprint_string("err... function?");
    1341       break;
    1342       case L_C_FUNCTION :
     1351        break;
     1352    case L_C_FUNCTION:
    13431353        lprint_string("C function, returns number\n");
    1344       break;
    1345       case L_C_BOOL :
     1354        break;
     1355    case L_C_BOOL:
    13461356        lprint_string("C boolean function\n");
    1347       break;
    1348       case L_L_FUNCTION :
     1357        break;
     1358    case L_L_FUNCTION:
    13491359        lprint_string("External lisp function\n");
    1350             break;
    1351       case L_STRING :
    1352       {
    1353                 if (current_print_file)
    1354                      lprint_string(lstring_value(i));
    1355                 else
    1356              dprintf("\"%s\"", lstring_value(i));
    1357       }
    1358       break;
    1359 
    1360       case L_POINTER :
    1361       {
    1362                 char ptr[10];
    1363                     sprintf(ptr, "%p", lpointer_value(i));
    1364                 lprint_string(ptr);
    1365       }
    1366       break;
    1367       case L_FIXED_POINT :
    1368       {
    1369                 char num[20];
    1370                 sprintf(num, "%g", (lfixed_point_value(i)>>16)+
    1371                           ((lfixed_point_value(i)&0xffff))/(double)0x10000);
    1372                 lprint_string(num);
    1373       } break;
    1374       case L_CHARACTER :
    1375       {
    1376                 if (current_print_file)
    1377                 {
    1378                   uint8_t ch=((LChar *)i)->ch;
    1379                   current_print_file->write(&ch, 1);
    1380                 } else
    1381                 {
    1382                   uint16_t ch=((LChar *)i)->ch;
    1383                   dprintf("#\\");
    1384                   switch (ch)
    1385                   {
    1386                     case '\n' :
    1387                     { dprintf("newline"); break; }
    1388                     case ' ' :
    1389                     { dprintf("space"); break; }
    1390                     default :
    1391                       dprintf("%c", ch);
    1392                   }
    1393                 }
    1394       } break;
    1395       case L_OBJECT_VAR :
    1396       {
    1397                 l_obj_print(((LObjectVar *)i)->number);
    1398       } break;
    1399       case L_1D_ARRAY :
    1400       {
    1401           LArray *a = (LArray *)i;
    1402           LObject **data = a->GetData();
    1403           dprintf("#(");
    1404           for (int j = 0; j < a->size; j++)
    1405           {
    1406               lprint(data[j]);
    1407               if (j != a->size - 1)
    1408                   dprintf(" ");
    1409           }
    1410           dprintf(")");
    1411       } break;
    1412       case L_COLLECTED_OBJECT :
    1413       {
    1414                 lprint_string("GC_refrence->");
    1415                 lprint(((LRedirect *)i)->new_reference);
    1416       } break;
    1417       default :
     1360        break;
     1361    case L_STRING:
     1362        if (current_print_file)
     1363            lprint_string(lstring_value(this));
     1364        else
     1365            dprintf("\"%s\"", lstring_value(this));
     1366        break;
     1367    case L_POINTER:
     1368        sprintf(buf, "%p", lpointer_value(this));
     1369        lprint_string(buf);
     1370        break;
     1371    case L_FIXED_POINT:
     1372        sprintf(buf, "%g", (lfixed_point_value(this) >> 16) +
     1373                ((lfixed_point_value(this) & 0xffff)) / (double)0x10000);
     1374        lprint_string(buf);
     1375        break;
     1376    case L_CHARACTER:
     1377        if (current_print_file)
     1378        {
     1379            uint8_t ch = ((LChar *)this)->ch;
     1380            current_print_file->write(&ch, 1);
     1381        }
     1382        else
     1383        {
     1384            uint16_t ch = ((LChar *)this)->ch;
     1385            dprintf("#\\");
     1386            switch (ch)
     1387            {
     1388            case '\n':
     1389                dprintf("newline"); break;
     1390            case ' ':
     1391                dprintf("space"); break;
     1392            default:
     1393                dprintf("%c", ch); break;
     1394            }
     1395        }
     1396        break;
     1397    case L_OBJECT_VAR:
     1398        l_obj_print(((LObjectVar *)this)->index);
     1399        break;
     1400    case L_1D_ARRAY:
     1401        {
     1402            LArray *a = (LArray *)this;
     1403            LObject **data = a->GetData();
     1404            dprintf("#(");
     1405            for (size_t j = 0; j < a->len; j++)
     1406            {
     1407                data[j]->Print();
     1408                if (j != a->len - 1)
     1409                    dprintf(" ");
     1410            }
     1411            dprintf(")");
     1412        }
     1413        break;
     1414    case L_COLLECTED_OBJECT:
     1415        lprint_string("GC_refrence->");
     1416        ((LRedirect *)this)->ref->Print();
     1417        break;
     1418    default:
    14181419        dprintf("Shouldn't happen\n");
    14191420    }
    1420   }
    1421   print_level--;
    1422   if (!print_level && !current_print_file)
    1423     dprintf("\n");
     1421
     1422    print_level--;
     1423    if (!print_level && !current_print_file)
     1424        dprintf("\n");
    14241425}
    14251426
     
    14321433  if (item_type(sym)!=L_SYMBOL)
    14331434  {
    1434     lprint(sym);
     1435    sym->Print();
    14351436    lbreak("EVAL : is not a function name (not symbol either)");
    14361437    exit(0);
     
    14611462    default :
    14621463    {
    1463       lprint(sym);
     1464      sym->Print();
    14641465      lbreak(" is not a function name");
    14651466      exit(0);   
     
    14741475    if (args<req_min)
    14751476    {
    1476       lprint(arg_list);
    1477       lprint(sym->name);
     1477      ((LObject *)arg_list)->Print();
     1478      sym->name->Print();
    14781479      lbreak("\nToo few parameters to function\n");
    14791480      exit(0);
    14801481    } else if (req_max!=-1 && args>req_max)
    14811482    {
    1482       lprint(arg_list);
    1483       lprint(sym->name);
     1483      ((LObject *)arg_list)->Print();
     1484      sym->name->Print();
    14841485      lbreak("\nToo many parameters to function\n");
    14851486      exit(0);
     
    15601561{
    15611562  bFILE *fp=open_file("preport.out", "wb");
    1562   pro_print(fp, lsym_root);
     1563  pro_print(fp, LSymbol::root);
    15631564  delete fp;
    15641565}
     
    15771578    default :
    15781579    {
    1579       lprint(sym);
     1580      ((LObject *)sym)->Print();
    15801581      lbreak(" is not a function\n");
    15811582      exit(0);
     
    16811682          else
    16821683          {
    1683         lprint(str_eval[i]);
     1684        ((LObject *)str_eval[i])->Print();
    16841685        lbreak(" is not a character\n");       
    16851686        exit(0);
     
    16901691      case L_STRING : len+=strlen(lstring_value(str_eval[i])); break;
    16911692      default :
    1692         lprint(prog_list);
     1693        ((LObject *)prog_list)->Print();
    16931694        lbreak("type not supported\n");
    16941695        exit(0);
     
    17311732  else
    17321733  {
    1733     lprint(prog_list);
     1734    ((LObject *)prog_list)->Print();
    17341735    lbreak("concat operation not supported, try 'string\n");
    17351736    exit(0);
     
    17991800      {
    18001801        ret=eval(CAR(arg_list));  arg_list=CDR(arg_list);
    1801     lprint(ret);
     1802        ((LObject *)ret)->Print();
    18021803      }
    18031804      return ret;
     
    18151816        case L_CONS_CELL : ret = LNumber::Create(((LList *)v)->GetLength()); break;
    18161817        default :
    1817         { lprint(v);
     1818        {
     1819          ((LObject *)v)->Print();
    18181820          lbreak("length : type not supported\n");
    18191821        }
     
    18871889    } while (arg_list);
    18881890
    1889     ret=new_lisp_fixed_point(sum);
     1891    ret = LFixedPoint::Create(sum);
    18901892      } else
    18911893      { sum=1;
     
    19091911    if (item_type(i)!=L_NUMBER)
    19101912    {
    1911       lprint(i);
     1913      ((LObject *)i)->Print();
    19121914      lbreak("/ only defined for numbers, cannot divide ");
    19131915      exit(0);
     
    19681970            case L_OBJECT_VAR :
    19691971            {
    1970               l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->number, set_to);
     1972              l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->index, set_to);
    19711973            } break;
    19721974            default :
     
    19831985            car=eval(CAR(CDR(i)));
    19841986            if (!car || item_type(car)!=L_CONS_CELL)
    1985             { lprint(car); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
     1987            { ((LObject *)car)->Print(); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
    19861988            ((LList *)car)->car = (LObject *)set_to;
    19871989          } else if (car==cdr_symbol)
     
    19891991            car=eval(CAR(CDR(i)));
    19901992            if (!car || item_type(car)!=L_CONS_CELL)
    1991             { lprint(car); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
     1993            { ((LObject *)car)->Print(); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
    19921994            ((LList *)car)->cdr = (LObject *)set_to;
    19931995          } else if (car==aref_symbol)
     
    19992001            if (item_type(a) != L_1D_ARRAY)
    20002002            {
    2001                 lprint(a);
     2003                a->Print();
    20022004                lbreak("is not an array (aref)\n");
    20032005                exit(0);
    20042006            }
    20052007#endif
    2006             long num=lnumber_value(eval(CAR(CDR(CDR(i)))));
     2008            int num = lnumber_value(eval(CAR(CDR(CDR(i)))));
    20072009#ifdef TYPE_CHECKING
    2008             if (num >= a->size || num < 0)
     2010            if (num >= (int)a->len || num < 0)
    20092011            {
    20102012              lbreak("aref : value of bounds (%d)\n", num);
     
    20252027        default :
    20262028        {
    2027           lprint(i);
     2029          ((LObject *)i)->Print();
    20282030          lbreak("setq/setf only defined for symbols and arrays now..\n");
    20292031          exit(0);
     
    20792081    if (item_type(var_name)!=L_SYMBOL)
    20802082    {
    2081       lprint(var_name);
     2083      ((LObject *)var_name)->Print();
    20822084      lbreak("should be a symbol (let)\n");
    20832085      exit(0);
     
    21162118      if (item_type(symbol)!=L_SYMBOL)
    21172119      {
    2118     lprint(symbol);
     2120        symbol->Print();
    21192121    lbreak(" is not a symbol! (DEFUN)\n");
    21202122    exit(0);
     
    21232125      if (item_type(arg_list)!=L_CONS_CELL)
    21242126      {
    2125     lprint(arg_list);
     2127    ((LObject *)arg_list)->Print();
    21262128    lbreak("is not a lambda list (DEFUN)\n");
    21272129    exit(0);
     
    21882190        default :
    21892191        {
    2190           lprint(i);
     2192          ((LObject *)i)->Print();
    21912193          lbreak(" is not character type\n");
    21922194          exit(0);
     
    22002202      if (item_type(i)!=L_NUMBER)
    22012203      {
    2202     lprint(i);
     2204    ((LObject *)i)->Print();
    22032205    lbreak(" is not number type\n");
    22042206    exit(0);
    22052207      }
    2206       ret=new_lisp_character(((LNumber *)i)->num);
     2208      ret = LChar::Create(((LNumber *)i)->num);
    22072209    } break;
    22082210    case SYS_FUNC_COND:
     
    22942296      if (item_type(symb)!=L_SYMBOL)
    22952297      {
    2296     lprint(symb);
     2298    ((LObject *)symb)->Print();
    22972299    lbreak(" is not a symbol (symbol-name)\n");
    22982300    exit(0);
     
    24292431    case SYS_FUNC_COMMA:
    24302432    {
    2431       lprint(arg_list);
     2433      ((LObject *)arg_list)->Print();
    24322434      lbreak("comma is illegal outside of backquote\n");
    24332435      exit(0);
     
    24442446        resize_perm(lnumber_value(eval(CAR(arg_list)))); break;
    24452447    case SYS_FUNC_COS:
    2446         ret=new_lisp_fixed_point(lisp_cos(lnumber_value(eval(CAR(arg_list))))); break;
     2448        ret = LFixedPoint::Create(lisp_cos(lnumber_value(eval(CAR(arg_list))))); break;
    24472449    case SYS_FUNC_SIN:
    2448         ret=new_lisp_fixed_point(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
     2450        ret = LFixedPoint::Create(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
    24492451    case SYS_FUNC_ATAN2:
    24502452    {
     
    24722474#ifdef TYPE_CHECKING
    24732475        if (item_type(s)!=L_SYMBOL)
    2474         { lprint(arg_list);
     2476        {
     2477          ((LObject *)arg_list)->Print();
    24752478          lbreak("expecting (sybmol value) for enum\n");
    24762479          exit(0);
     
    24822485      default :
    24832486      {
    2484         lprint(arg_list);
     2487        ((LObject *)arg_list)->Print();
    24852488        lbreak("expecting symbol or (symbol value) in enum\n");
    24862489        exit(0);
     
    26782681      { lbreak("elt : out of range of string\n"); ret=NULL; }
    26792682      else
    2680         ret=new_lisp_character(st[x]);
     2683        ret = LChar::Create(st[x]);
    26812684    } break;
    26822685    case SYS_FUNC_LISTP:
     
    27562759      else if (x<0)
    27572760      { lbreak("SCHAR: index should not be negative\n"); exit(0); }
    2758       return new_lisp_character(s[x]);
     2761      return LChar::Create(s[x]);
    27592762    } break;
    27602763    case SYS_FUNC_SYMBOLP:
     
    27812784
    27822785      if (item_type(l1)!=L_CONS_CELL)
    2783       { lprint(l1); lbreak("first arg should be a list\n"); }
     2786      { ((LObject *)l1)->Print(); lbreak("first arg should be a list\n"); }
    27842787      do
    27852788      {
     
    28752878  if (item_type(sym)!=L_SYMBOL)
    28762879  {
    2877     lprint(sym);
     2880    ((LObject *)sym)->Print();
    28782881    lbreak("EVAL : is not a function name (not symbol either)");
    28792882    exit(0);
     
    28902893  if (item_type(fun)!=L_USER_FUNCTION)
    28912894  {
    2892     lprint(sym);
     2895    ((LObject *)sym)->Print();
    28932896    lbreak("is not a user defined function\n");
    28942897  }
     
    29282931    {
    29292932      if (!arg_list)
    2930       { lprint(sym); lbreak("too few parameter to function\n"); exit(0); }
     2933      { ((LObject *)sym)->Print(); lbreak("too few parameter to function\n"); exit(0); }
    29312934      l_user_stack.push(eval(CAR(arg_list)));
    29322935      f_arg=CDR(f_arg);
     
    29452948
    29462949  if (f_arg)
    2947   { lprint(sym); lbreak("too many parameter to function\n"); exit(0); }
     2950  { ((LObject *)sym)->Print(); lbreak("too many parameter to function\n"); exit(0); }
    29482951
    29492952
     
    29922995          space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
    29932996          PtrRef::stack.son);
    2994       lprint(prog);
     2997      ((LObject *)prog)->Print();
    29952998
    29962999      dprintf("\n");
     
    30173020                  ret = ((LSymbol *)prog)->GetValue();
    30183021                  if (item_type(ret)==L_OBJECT_VAR)
    3019                     ret=l_obj_get(((LObjectVar *)ret)->number);
     3022                    ret=l_obj_get(((LObjectVar *)ret)->index);
    30203023                }
    30213024      } break;
     
    30373040          space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
    30383041          PtrRef::stack.son);
    3039     lprint(ret);
     3042    ((LObject *)ret)->Print();
    30403043    dprintf("\n");
    30413044  }
     
    30473050
    30483051  return ret;
    3049 }
    3050 
    3051 int total_symbols()
    3052 {
    3053   return ltotal_syms;
    30543052}
    30553053
     
    30903088{
    30913089  unsigned int i;
    3092   lsym_root = NULL;
     3090  LSymbol::root = NULL;
    30933091  total_user_functions = 0;
    30943092
     
    31103108  current_space=TMP_SPACE;
    31113109  dprintf("Lisp : %d symbols defined, %d system functions, %d pre-compiled functions\n",
    3112       total_symbols(), sizeof(sys_funcs) / sizeof(*sys_funcs), total_user_functions);
     3110      LSymbol::count, sizeof(sys_funcs) / sizeof(*sys_funcs), total_user_functions);
    31133111}
    31143112
    31153113void lisp_uninit()
    31163114{
    3117   free(space[0]);
    3118   free(space[1]);
    3119   ldelete_syms(lsym_root);
    3120   lsym_root=NULL;
    3121   ltotal_syms=0;
     3115    free(space[0]);
     3116    free(space[1]);
     3117    ldelete_syms(LSymbol::root);
     3118    LSymbol::root = NULL;
     3119    LSymbol::count = 0;
    31223120}
    31233121
     
    31323130    if (item_type(this) != L_SYMBOL)
    31333131    {
    3134         lprint(this);
     3132        Print();
    31353133        lbreak("is not a symbol\n");
    31363134        exit(0);
     
    31453143    if (item_type(this) != L_SYMBOL)
    31463144    {
    3147         lprint(this);
     3145        Print();
    31483146        lbreak("is not a symbol\n");
    31493147        exit(0);
     
    31613159    if (item_type(this) != L_SYMBOL)
    31623160    {
    3163         lprint(this);
     3161        Print();
    31643162        lbreak("is not a symbol\n");
    31653163        exit(0);
     
    31743172    if (item_type(this) != L_SYMBOL)
    31753173    {
    3176         lprint(this);
     3174        Print();
    31773175        lbreak("is not a symbol\n");
    31783176        exit(0);
     
    31873185    if (item_type(this) != L_SYMBOL)
    31883186    {
    3189         lprint(this);
     3187        Print();
    31903188        lbreak("is not a symbol\n");
    31913189        exit(0);
  • abuse/trunk/src/lisp/lisp.h

    r492 r493  
    4747struct LObject
    4848{
     49    void Print();
     50
    4951    ltype type;
    5052};
     
    5254struct LObjectVar : LObject
    5355{
    54     long number;
     56    static LObjectVar *Create(int index);
     57
     58    int index;
    5559};
    5660
     
    7377struct LRedirect : LObject
    7478{
    75     LObject *new_reference;
     79    LObject *ref;
    7680};
    7781
     
    8488    char *GetString();
    8589
    86     char str[1];
     90private:
     91    char str[1]; /* Can be allocated much larger than 1 */
    8792};
    8893
    8994struct LSymbol : LObject
    9095{
     96    /* Factories */
    9197    static LSymbol *Find(char const *name);
    9298    static LSymbol *FindOrCreate(char const *name);
    9399
     100    /* Methods */
    94101    LString *GetName();
    95102    LObject *GetFunction();
     
    100107    void SetNumber(long num);
    101108
     109    /* Members */
    102110#ifdef L_PROFILE
    103111    float time_taken;
     
    107115    LString *name;
    108116    LSymbol *left, *right; // tree structure
     117
     118    /* Static members */
     119    static LSymbol *root;
     120    static size_t count;
    109121};
    110122
     
    126138struct LArray : LObject
    127139{
    128     static LArray *Create(int size, void *rest);
    129 
     140    /* Factories */
     141    static LArray *Create(size_t len, void *rest);
     142
     143    /* Methods */
    130144    inline LObject **GetData() { return data; }
    131     LObject *Get(long x);
    132 
    133     unsigned short size;
    134     // size * sizeof (void *) follows1
     145    LObject *Get(int x);
     146
     147    /* Members */
     148    size_t len;
    135149
    136150private:
    137     LObject *data[1];
     151    LObject *data[1]; /* Can be allocated much larger than 1 */
    138152};
    139153
    140154struct LChar : LObject
    141155{
    142     int16_t pad;
     156    static LChar *Create(uint16_t ch);
     157
    143158    uint16_t ch;
    144159};
     
    146161struct LPointer : LObject
    147162{
     163    static LPointer *Create(void *addr);
     164
    148165    void *addr;
    149166};
     
    151168struct LFixedPoint : LObject
    152169{
     170    static LFixedPoint *Create(int32_t x);
     171
    153172    int32_t x;
    154173};
     
    170189void *lisp_eq(void *n1, void *n2);
    171190void *lisp_equal(void *n1, void *n2);
    172 void lprint(void *i);
    173191void *eval(void *prog);
    174192void *eval_block(void *list);
     
    181199
    182200void push_onto_list(void *object, void *&list);
    183 LSymbol *add_c_object(void *symbol, int16_t number);
     201LSymbol *add_c_object(void *symbol, int index);
    184202LSymbol *add_c_function(char const *name, short min_args, short max_args, short number);
    185203LSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number);
     
    189207
    190208
    191 LPointer *new_lisp_pointer(void *addr);
    192 LChar *new_lisp_character(uint16_t ch);
    193 LFixedPoint *new_lisp_fixed_point(int32_t x);
    194 LObjectVar *new_lisp_object_var(int16_t number);
    195209LSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number);
    196210LSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number);
     
    209223void lisp_init(long perm_size, long tmp_size);
    210224void lisp_uninit();
    211 extern LSymbol *lsym_root;
    212225
    213226extern uint8_t *space[4], *free_space[4];
  • abuse/trunk/src/lisp/lisp_gc.cpp

    r492 r493  
    8888static LArray *CollectArray(LArray *x)
    8989{
    90     size_t s = x->size;
     90    size_t s = x->len;
    9191    LArray *a = LArray::Create(s, NULL);
    9292    LObject **src = x->GetData();
     
    110110        x = (LList *)CDR(x);
    111111        ((LRedirect *)old_x)->type = L_COLLECTED_OBJECT;
    112         ((LRedirect *)old_x)->new_reference = p;
     112        ((LRedirect *)old_x)->ref = p;
    113113
    114114        p->car = CollectObject(old_car);
     
    163163        break;
    164164      case L_CHARACTER:
    165         ret = new_lisp_character(lcharacter_value(x));
     165        ret = LChar::Create(lcharacter_value(x));
    166166        break;
    167167      case L_C_FUNCTION:
     
    181181        break;
    182182      case L_POINTER:
    183         ret = new_lisp_pointer(lpointer_value(x));
     183        ret = LPointer::Create(lpointer_value(x));
    184184        break;
    185185      case L_1D_ARRAY:
     
    187187        break;
    188188      case L_FIXED_POINT:
    189         ret = new_lisp_fixed_point(lfixed_point_value(x));
     189        ret = LFixedPoint::Create(lfixed_point_value(x));
    190190        break;
    191191      case L_CONS_CELL:
     
    193193        break;
    194194      case L_OBJECT_VAR:
    195         ret = new_lisp_object_var(((LObjectVar *)x)->number);
     195        ret = LObjectVar::Create(((LObjectVar *)x)->index);
    196196        break;
    197197      case L_COLLECTED_OBJECT:
    198         ret = ((LRedirect *)x)->new_reference;
     198        ret = ((LRedirect *)x)->ref;
    199199        break;
    200200      default:
     
    206206    }
    207207    ((LRedirect *)x)->type = L_COLLECTED_OBJECT;
    208     ((LRedirect *)x)->new_reference = ret;
     208    ((LRedirect *)x)->ref = ret;
    209209  }
    210210  else if ((uint8_t *)x < collected_start || (uint8_t *)x >= collected_end)
     
    224224static void collect_symbols(LSymbol *root)
    225225{
    226   if (root)
    227   {
     226    if (!root)
     227        return;
     228
    228229    root->value = CollectObject(root->value);
    229230    root->function = CollectObject(root->function);
     
    231232    collect_symbols(root->left);
    232233    collect_symbols(root->right);
    233   }
    234234}
    235235
     
    276276//dump_memory((char *)lsym_root->name, 128, 196);
    277277//dump_memory((char *)0xb6782025, 32, 48);
    278   collect_symbols(lsym_root);
     278  collect_symbols(LSymbol::root);
    279279  collect_stacks();
    280280
  • abuse/trunk/src/menu.cpp

    r492 r493  
    117117    default :
    118118    {
    119       lprint(arg);
     119      ((LObject *)arg)->Print();
    120120      printf(" is not a valid menu option\n");
    121121      exit(0);
  • abuse/trunk/src/objects.cpp

    r492 r493  
    495495    frm = LList::Create();
    496496    PtrRef r2(frm);
    497     frm->car = new_lisp_pointer(from);
     497    frm->car = LPointer::Create(from);
    498498
    499499    hx = LList::Create();
     
    899899      if (hit_object)
    900900      {
    901     push_onto_list(new_lisp_pointer(hit_object),rlist);
     901    push_onto_list(LPointer::Create(hit_object),rlist);
    902902    push_onto_list(l_object,rlist);
    903903      } else
     
    12471247    if (item_type(r)!=L_NUMBER)
    12481248    {
    1249       lprint(r);
     1249      ((LObject *)r)->Print();
    12501250      lbreak("Object %s did not return a number from its mover function!\n"
    12511251         "It should return a number to indicate its blocked status to the\n"
  • abuse/trunk/src/particle.cpp

    r492 r493  
    6464  if (item_type(sym)!=L_SYMBOL)
    6565  {
    66     lprint(args);
     66    ((LObject *)args)->Print();
    6767    printf("expecting first arg to def-particle to be a symbol!\n");
    6868    exit(0);
     
    8989  {
    9090    delete fp;
    91     lprint(args);
     91    ((LObject *)args)->Print();
    9292    fprintf(stderr,"\nparticle sequence : Unable to open %s for reading\n",fn);
    9393    fprintf(stderr,"total files open=%d\n",total_files_open);
Note: See TracChangeset for help on using the changeset viewer.