Changeset 496


Ignore:
Timestamp:
Apr 17, 2011, 11:56:55 PM (7 years ago)
Author:
Sam Hocevar
Message:

lisp: implement LObject::Eval.

Location:
abuse/trunk/src
Files:
10 edited

Legend:

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

    r494 r496  
    340340    PtrRef r5(ab);
    341341    if (!NILP(ab))
    342       abil[i]=lnumber_value(eval(lcar(lcdr(ab))));
     342      abil[i]=lnumber_value(lcar(lcdr(ab))->Eval());
    343343      }
    344344    } else if (f==l_funs)
     
    361361    Cell *ab=assoc(LSymbol::FindOrCreate(cflag_names[i]),l);
    362362    PtrRef r5(ab);
    363     if (!NILP(ab) && eval(lcar(lcdr(ab))))
     363    if (!NILP(ab) && lcar(lcdr(ab))->Eval())
    364364    cflags|=(1<<i);
    365365      }
     
    373373    } else if (f==l_range)
    374374    {
    375       rangex=lnumber_value(eval(lcar(lcdr(lcar(field)))));
    376       rangey=lnumber_value(eval(lcar(lcdr(lcdr(lcar(field))))));
     375      rangex=lnumber_value(lcar(lcdr(lcar(field)))->Eval());
     376      rangey=lnumber_value(lcar(lcdr(lcdr(lcar(field))))->Eval());
    377377    } else if (f==l_draw_range)
    378378    {
    379       draw_rangex=lnumber_value(eval(lcar(lcdr(lcar(field)))));
    380       draw_rangey=lnumber_value(eval(lcar(lcdr(lcdr(lcar(field))))));
     379      draw_rangex=lnumber_value(lcar(lcdr(lcar(field)))->Eval());
     380      draw_rangey=lnumber_value(lcar(lcdr(lcdr(lcar(field))))->Eval());
    381381    } else if (f==l_states)
    382382    {
     
    384384      PtrRef r4(l);
    385385      char fn[100];
    386       strcpy(fn,lstring_value(eval(CAR(l)))); l=CDR(l);
     386      strcpy(fn,lstring_value(CAR(l)->Eval())); l=CDR(l);
    387387      while (l)
    388388      {
     
    391391      sequence *mem;
    392392      index = add_state(CAR((CAR(l))));
    393       e = eval(CAR(CDR(CAR(l))));
     393      e = CAR(CDR(CAR(l)))->Eval();
    394394      mem = new sequence(fn,e,NULL);
    395395    seq[index]=mem;
     
    402402      while (!NILP(mf))
    403403      {
    404     char *real=lstring_value(eval(lcar(lcar(mf))));
    405     char *fake=lstring_value(eval(lcar(lcdr(lcar(mf)))));
     404    char *real=lstring_value(lcar(lcar(mf))->Eval());
     405    char *fake=lstring_value(lcar(lcdr(lcar(mf)))->Eval());
    406406    if (!isa_var_name(real))
    407407    {
     
    418418    } else if (f==l_logo)
    419419    {
    420       char *fn=lstring_value(eval(CAR(CDR(CAR(field)))));
    421       char *o=lstring_value(eval(CAR(CDR(CDR(CAR(field))))));
     420      char *fn=lstring_value(CAR(CDR(CAR(field)))->Eval());
     421      char *o=lstring_value(CAR(CDR(CDR(CAR(field))))->Eval());
    422422      logo=cache.reg(fn,o,SPEC_IMAGE,1);
    423423    } else if (f==l_vars)
  • abuse/trunk/src/clisp.cpp

    r494 r496  
    573573    case 0 :
    574574    {
    575       current_object->set_aistate(lnumber_value(eval(CAR(args))));
     575      current_object->set_aistate(lnumber_value(CAR(args)->Eval()));
    576576      current_object->set_aistate_time(0);
    577577      void *ai=figures[current_object->otype]->get_fun(OFUN_AI);
     
    587587    {
    588588      game_object *old_cur=current_object;
    589       current_object=(game_object *)lpointer_value(eval(CAR(args)));
     589      current_object=(game_object *)lpointer_value(CAR(args)->Eval());
    590590      void *ret=eval_block(CDR(args));
    591591      current_object=old_cur;
     
    599599      game_object *o;
    600600      if (args)
    601         o=(game_object *)lpointer_value(eval(CAR(args)));
     601        o=(game_object *)lpointer_value(CAR(args)->Eval());
    602602      else o=current_object;
    603603      game_object *hit=current_object->bmove(whit,o);
     
    615615    case 5 : return LPointer::Create(current_level->find_closest(current_object->x,
    616616                                 current_object->y,
    617                                lnumber_value(eval(CAR(args))),
     617                               lnumber_value(CAR(args)->Eval()),
    618618                                       current_object)); break;
    619619    case 6 : return LPointer::Create(current_level->find_xclosest(current_object->x,
    620620                                  current_object->y,
    621                                   lnumber_value(eval(CAR(args))),
     621                                  lnumber_value(CAR(args)->Eval()),
    622622                                  current_object
    623623                                  )); break;
    624624    case 7 :
    625625    {
    626       long n1=lnumber_value(eval(CAR(args)));
    627       long n2=lnumber_value(eval(CAR(CDR(args))));
     626      long n1=lnumber_value(CAR(args)->Eval());
     627      long n2=lnumber_value(CAR(CDR(args))->Eval());
    628628      return LPointer::Create(current_level->find_xrange(current_object->x,
    629629                             current_object->y,
     
    634634    case 8 :
    635635    {
    636       int type=lnumber_value(eval(CAR(args)));          args=CDR(args);
    637       long x=lnumber_value(eval(CAR(args)));      args=CDR(args);
    638       long y=lnumber_value(eval(CAR(args))); args=CDR(args);
     636      int type=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     637      long x=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     638      long y=lnumber_value(CAR(args)->Eval()); args=CDR(args);
    639639      game_object *o;
    640640      if (args)
    641         o=create(type,x,y,0,lnumber_value(eval(CAR(args))));
     641        o=create(type,x,y,0,lnumber_value(CAR(args)->Eval()));
    642642      else
    643643        o=create(type,x,y);
     
    648648    case 22 :
    649649    {
    650       int type=lnumber_value(eval(CAR(args)));          args=CDR(args);
    651       long x=lnumber_value(eval(CAR(args)));      args=CDR(args);
    652       long y=lnumber_value(eval(CAR(args))); args=CDR(args);
     650      int type=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     651      long x=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     652      long y=lnumber_value(CAR(args)->Eval()); args=CDR(args);
    653653      game_object *o;
    654654      if (args)
    655         o=create(type,x,y,0,lnumber_value(eval(CAR(args))));
     655        o=create(type,x,y,0,lnumber_value(CAR(args)->Eval()));
    656656      else
    657657        o=create(type,x,y);
     
    664664    case 10 :
    665665    {
    666       view *v=((game_object *)lpointer_value(eval(CAR(args))))->controller()->next;
     666      view *v=((game_object *)lpointer_value(CAR(args)->Eval()))->controller()->next;
    667667      if (v)
    668668        return LPointer::Create(v->focus);
     
    672672    {
    673673      return LPointer::Create
    674       ((void *)current_object->get_object(lnumber_value(eval(CAR(args)))));
     674      ((void *)current_object->get_object(lnumber_value(CAR(args)->Eval())));
    675675    } break;
    676676    case 12 :
    677677    {
    678678      return LPointer::Create
    679       ((void *)current_object->get_light(lnumber_value(eval(CAR(args)))));
     679      ((void *)current_object->get_light(lnumber_value(CAR(args)->Eval())));
    680680    } break;
    681681    case 13 :
     
    686686      {
    687687    current_object=old_cur->get_object(i);
    688     ret=eval(CAR(args));
     688    ret = CAR(args)->Eval();
    689689      }
    690690      current_object=old_cur;
     
    693693    case 14 :
    694694    {
    695       int t=lnumber_value(eval(CAR(args))); args=lcdr(args);
    696       int x=lnumber_value(eval(CAR(args))); args=lcdr(args);
    697       int y=lnumber_value(eval(CAR(args))); args=lcdr(args);
    698       int r1=lnumber_value(eval(CAR(args))); args=lcdr(args);
    699       int r2=lnumber_value(eval(CAR(args))); args=lcdr(args);
    700       int xs=lnumber_value(eval(CAR(args))); args=lcdr(args);
    701       int ys=lnumber_value(eval(CAR(args)));
     695      int t=lnumber_value(CAR(args)->Eval()); args=lcdr(args);
     696      int x=lnumber_value(CAR(args)->Eval()); args=lcdr(args);
     697      int y=lnumber_value(CAR(args)->Eval()); args=lcdr(args);
     698      int r1=lnumber_value(CAR(args)->Eval()); args=lcdr(args);
     699      int r2=lnumber_value(CAR(args)->Eval()); args=lcdr(args);
     700      int xs=lnumber_value(CAR(args)->Eval()); args=lcdr(args);
     701      int ys=lnumber_value(CAR(args)->Eval());
    702702      return LPointer::Create(add_light_source(t,x,y,r1,r2,xs,ys));
    703703    } break;
     
    714714    case 17 :
    715715    {
    716       long trials=lnumber_value(eval(CAR(args)));
     716      long trials=lnumber_value(CAR(args)->Eval());
    717717      args=CDR(args);
    718718      time_marker start;
     
    720720      {
    721721    clear_tmp();
    722     eval(CAR(args));
     722    CAR(args)->Eval();
    723723      }
    724724      time_marker end;
     
    731731    case 20 :
    732732    {
    733       long x1=lnumber_value(eval(CAR(args))); args=CDR(args);
    734       long y1=lnumber_value(eval(CAR(args))); args=CDR(args);
    735       long x2=lnumber_value(eval(CAR(args))); args=CDR(args);
    736       long y2=lnumber_value(eval(CAR(args))); args=CDR(args);
    737 
    738       void *list=eval(CAR(args));
     733      long x1=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     734      long y1=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     735      long x2=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     736      long y2=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     737
     738      void *list = CAR(args)->Eval();
    739739      game_object *find=current_level->find_object_in_area(current_object->x,
    740740                          current_object->y,
     
    746746    case 21 :
    747747    {
    748       long a1=lnumber_value(eval(CAR(args))); args=CDR(args);
    749       long a2=lnumber_value(eval(CAR(args))); args=CDR(args);
    750 
    751       void *list=eval(CAR(args));
     748      long a1=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     749      long a2=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     750
     751      void *list = CAR(args)->Eval();
    752752      PtrRef r1(list);
    753753      game_object *find=current_level->find_object_in_angle(current_object->x,
     
    787787    case 24 :
    788788    {
    789       int32_t x1=lnumber_value(eval(CAR(args))); args=CDR(args);
    790       int32_t y1=lnumber_value(eval(CAR(args))); args=CDR(args);
    791       int32_t x2=lnumber_value(eval(CAR(args))); args=CDR(args);
    792       int32_t y2=lnumber_value(eval(CAR(args)));
     789      int32_t x1=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     790      int32_t y1=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     791      int32_t x2=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     792      int32_t y2=lnumber_value(CAR(args)->Eval());
    793793      current_level->foreground_intersect(x1,y1,x2,y2);
    794794      void *ret=NULL;
     
    868868    case 46 :
    869869    {
    870       return LString::Create(start_argv[lnumber_value(eval(CAR(args)))]);
     870      return LString::Create(start_argv[lnumber_value(CAR(args)->Eval())]);
    871871    } break;
    872872    case 47 :
     
    901901    case 49 :
    902902    {
    903       int32_t x=lnumber_value(eval(CAR(args))); args=CDR(args);
    904       int32_t y=lnumber_value(eval(CAR(args))); args=CDR(args);
     903      int32_t x=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     904      int32_t y=lnumber_value(CAR(args)->Eval()); args=CDR(args);
    905905
    906906      int32_t rx,ry;
     
    916916    case 50 :
    917917    {
    918       int32_t x=lnumber_value(eval(CAR(args))); args=CDR(args);
    919       int32_t y=lnumber_value(eval(CAR(args))); args=CDR(args);
     918      int32_t x=lnumber_value(CAR(args)->Eval()); args=CDR(args);
     919      int32_t y=lnumber_value(CAR(args)->Eval()); args=CDR(args);
    920920
    921921      int32_t rx,ry;
     
    945945    } break;
    946946    case 55 :
    947     { system(lstring_value(eval(CAR(args)))); } break;
     947    { system(lstring_value(CAR(args)->Eval())); } break;
    948948    case 56 :
    949949    {
    950       void *fn=eval(CAR(args)); args=CDR(args);
     950      void *fn=CAR(args)->Eval(); args=CDR(args);
    951951      char tmp[200];
    952952      {
    953953    PtrRef r1(fn);
    954     char *slash=lstring_value(eval(CAR(args)));
     954    char *slash=lstring_value(CAR(args)->Eval());
    955955    char *filename=lstring_value(fn);
    956956
     
    972972      int tfiles,tdirs,i;
    973973
    974       get_directory(lstring_value(eval(CAR(args))),files,tfiles,dirs,tdirs);
     974      get_directory(lstring_value(CAR(args)->Eval()),files,tfiles,dirs,tdirs);
    975975      void *fl=NULL,*dl=NULL,*rl=NULL;
    976976      {
     
    995995    {
    996996        long x;
    997         sscanf(lstring_value(eval(CAR(args))),"%lx",&x);
     997        sscanf(lstring_value(CAR(args)->Eval()),"%lx",&x);
    998998        return LPointer::Create((void *)(intptr_t)x);
    999999    } break;
     
    10011001    {
    10021002      char name[256],name2[256];
    1003       strcpy(name,lstring_value(eval(CAR(args))));  args=CDR(args);
    1004       long first=lnumber_value(eval(CAR(args)));  args=CDR(args);
    1005       long last=lnumber_value(eval(CAR(args)));
     1003      strcpy(name,lstring_value(CAR(args)->Eval()));  args=CDR(args);
     1004      long first=lnumber_value(CAR(args)->Eval());  args=CDR(args);
     1005      long last=lnumber_value(CAR(args)->Eval());
    10061006      long i;
    10071007      void *ret=NULL;
  • abuse/trunk/src/cop.cpp

    r494 r496  
    256256    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    257257    {
    258       int32_t value=lnumber_value(eval(CAR(args)));
     258      int32_t value=lnumber_value(CAR(args)->Eval());
    259259      if (value)                                   // do we have ammo ?
    260260      {
     
    298298    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    299299    {
    300       int32_t value=lnumber_value(eval(CAR(args)));
     300      int32_t value=lnumber_value(CAR(args)->Eval());
    301301      if (value)                                   // do we have ammo ?
    302302      {
     
    325325    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    326326    {
    327       int32_t value=lnumber_value(eval(CAR(args)));
     327      int32_t value=lnumber_value(CAR(args)->Eval());
    328328      if (value)                                   // do we have ammo ?
    329329      {
     
    349349    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    350350    {
    351       int32_t value=lnumber_value(eval(CAR(args)));
     351      int32_t value=lnumber_value(CAR(args)->Eval());
    352352      if (value)                                   // do we have ammo ?
    353353      {
     
    376376    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    377377    {
    378       int32_t value=lnumber_value(eval(CAR(args)));
     378      int32_t value=lnumber_value(CAR(args)->Eval());
    379379      if (value)                                   // do we have ammo ?
    380380      {
  • abuse/trunk/src/dev.cpp

    r494 r496  
    5656  char const *cs=prog;
    5757  strcpy(prog,"(setq section 'game_section)\n");
    58   eval(compile(cs));
     58  LObject::Compile(cs)->Eval();
    5959  strcpy(prog,"(load \"lisp/english.lsp\")\n");
    6060  cs=prog;
    61   if (!eval(compile(cs)))
     61  if (!LObject::Compile(cs)->Eval())
    6262  {
    6363    printf("unable to open file '%s'\n",lsf);
     
    965965    strcpy(prog,"(compile-file \"edit.lsp\")");
    966966    cs=prog;
    967     void *p=compile(cs);
     967    LObject *p = LObject::Compile(cs);
    968968    l_user_stack.push(p);
    969     eval(p);
     969    p->Eval();
    970970    l_user_stack.pop(1);
    971971    for (int i=0; i<total_pals; i++)
     
    982982  if (command[0]=='(')            // is this a lisp command?
    983983  {
    984     eval(compile(command));
     984    LObject::Compile(command)->Eval();
    985985    return ;
    986986  }
     
    23092309          atoi(mess_win->read(ID_MESS_STR2)));
    23102310      char const *s=name;
    2311       eval(compile(s));
     2311      LObject::Compile(s)->Eval();
    23122312      wm->push_event(new event(ID_CANCEL,NULL));        // close window
    23132313    } break;
  • abuse/trunk/src/game.cpp

    r494 r496  
    12561256
    12571257    int i;
    1258     char *str = lstring_value(eval(LSymbol::FindOrCreate("plot_start")));
     1258    char *str = lstring_value(LSymbol::FindOrCreate("plot_start")->Eval());
    12591259
    12601260    bFILE *fp = open_file("art/smoke.spe", "rb");
     
    23112311                while(*s)
    23122312                {
    2313                     void *prog = compile(s);
     2313                    LObject *prog = LObject::Compile(s);
    23142314                    l_user_stack.push(prog);
    23152315                    while(*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
    2316                     ((LObject *)eval(prog))->Print();
     2316                    prog->Eval()->Print();
    23172317                    l_user_stack.pop(1);
    23182318                }
  • abuse/trunk/src/lisp/lisp.cpp

    r494 r496  
    140140      do
    141141      {
    142                 void *prog=compile(s);
    143                 PtrRef r1(prog);
    144                 while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
    145                 ((LObject *)eval(prog))->Print();
     142        LObject *prog = LObject::Compile(s);
     143        PtrRef r1(prog);
     144        while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n')
     145            s++;
     146        prog->Eval()->Print();
    146147      } while (*s);
    147148    }
     
    215216  while (list)
    216217  {
    217     ret=eval(CAR(list));
    218     list=CDR(list);
     218    ret = CAR(list)->Eval();
     219    list = CDR(list);
    219220  }
    220221  return ret;
     
    237238    if (rest)
    238239    {
    239         void *x = eval(CAR(rest));
     240        LObject *x = CAR(rest)->Eval();
    240241        if (x == colon_initial_contents)
    241242        {
    242             x = eval(CAR(CDR(rest)));
     243            x = CAR(CDR(rest))->Eval();
    243244            data = p->GetData();
    244245            for (size_t i = 0; i < len; i++, x = CDR(x))
     
    261262        else if (x == colon_initial_element)
    262263        {
    263             x = eval(CAR(CDR(rest)));
     264            x = CAR(CDR(rest))->Eval();
    264265            data = p->GetData();
    265266            for (size_t i = 0; i < len; i++)
     
    563564}
    564565
    565 void *lcdr(void *c)
     566LObject *lcdr(void *c)
    566567{
    567568  if (!c) return NULL;
     
    572573}
    573574
    574 void *lcar(void *c)
     575LObject *lcar(void *c)
    575576{
    576577  if (!c) return NULL;
     
    877878}
    878879
    879 void ldelete_syms(LSymbol *root)
    880 {
    881   if (root)
    882   {
    883     ldelete_syms(root->left);
    884     ldelete_syms(root->right);
    885     free(root);
    886   }
     880static void DeleteAllSymbols(LSymbol *root)
     881{
     882    if (root)
     883    {
     884        DeleteAllSymbols(root->left);
     885        DeleteAllSymbols(root->right);
     886        free(root);
     887    }
    887888}
    888889
     
    11241125void *comp_optimize(void *list);
    11251126
    1126 void *compile(char const *&s)
    1127 {
    1128   void *ret=NULL;
    1129   if (!read_ltoken(s, n))
    1130     lerror(NULL, "unexpected end of program");
     1127LObject *LObject::Compile(char const *&code)
     1128{
     1129    LObject *ret = NULL;
     1130
     1131    if (!read_ltoken(code, n))
     1132        lerror(NULL, "unexpected end of program");
     1133
    11311134  if (!strcmp(n, "nil"))
    11321135    return NULL;
     
    11351138  else if (n[0]=='\'')                    // short hand for quote function
    11361139  {
    1137     void *cs = LList::Create(), *c2=NULL, *tmp;
     1140    LObject *cs = LList::Create(), *c2=NULL, *tmp;
    11381141    PtrRef r1(cs), r2(c2);
    11391142
    11401143    ((LList *)cs)->car=quote_symbol;
    11411144    c2 = LList::Create();
    1142     tmp=compile(s);
     1145    tmp=Compile(code);
    11431146    ((LList *)c2)->car = (LObject *)tmp;
    11441147    ((LList *)c2)->cdr=NULL;
     
    11481151  else if (n[0]=='`')                    // short hand for backquote function
    11491152  {
    1150     void *cs = LList::Create(), *c2=NULL, *tmp;
     1153    LObject *cs = LList::Create(), *c2=NULL, *tmp;
    11511154    PtrRef r1(cs), r2(c2);
    11521155
    11531156    ((LList *)cs)->car=backquote_symbol;
    11541157    c2 = LList::Create();
    1155     tmp=compile(s);
     1158    tmp=Compile(code);
    11561159    ((LList *)c2)->car = (LObject *)tmp;
    11571160    ((LList *)c2)->cdr=NULL;
     
    11601163  }  else if (n[0]==',')              // short hand for comma function
    11611164  {
    1162     void *cs = LList::Create(), *c2=NULL, *tmp;
     1165    LObject *cs = LList::Create(), *c2=NULL, *tmp;
    11631166    PtrRef r1(cs), r2(c2);
    11641167
    11651168    ((LList *)cs)->car=comma_symbol;
    11661169    c2 = LList::Create();
    1167     tmp=compile(s);
     1170    tmp=Compile(code);
    11681171    ((LList *)c2)->car = (LObject *)tmp;
    11691172    ((LList *)c2)->cdr=NULL;
     
    11781181    do
    11791182    {
    1180       char const *tmp=s;
     1183      char const *tmp=code;
    11811184      if (!read_ltoken(tmp, n))           // check for the end of the list
    11821185        lerror(NULL, "unexpected end of program");
     
    11841187      {
    11851188                done=1;
    1186                 read_ltoken(s, n);                // read off the ')'
     1189                read_ltoken(code, n);                // read off the ')'
    11871190      }
    11881191      else
     
    11911194                {
    11921195                  if (!first)
    1193                     lerror(s, "token '.' not allowed here\n");
     1196                    lerror(code, "token '.' not allowed here\n");
    11941197                  else
    11951198                  {
    11961199                    void *tmp;
    1197                     read_ltoken(s, n);              // skip the '.'
    1198                     tmp=compile(s);
     1200                    read_ltoken(code, n);              // skip the '.'
     1201                    tmp=Compile(code);
    11991202                    ((LList *)last)->cdr = (LObject *)tmp;          // link the last cdr to
    12001203                    last=NULL;
    12011204                  }
    12021205                } else if (!last && first)
    1203                   lerror(s, "illegal end of dotted list\n");
     1206                  lerror(code, "illegal end of dotted list\n");
    12041207                else
    12051208                {
     
    12081211                  PtrRef r1(cur);
    12091212                  if (!first) first=cur;
    1210                   tmp=compile(s);
     1213                  tmp=Compile(code);
    12111214                  ((LList *)cur)->car = (LObject *)tmp;
    12121215                  if (last)
     
    12161219      }
    12171220    } while (!done);
    1218     ret=comp_optimize(first);
     1221    ret=(LObject *)comp_optimize(first);
    12191222
    12201223  } else if (n[0]==')')
    1221     lerror(s, "mismatched )");
     1224    lerror(code, "mismatched )");
    12221225  else if (isdigit(n[0]) || (n[0]=='-' && isdigit(n[1])))
    12231226  {
     
    12271230  } else if (n[0]=='"')
    12281231  {
    1229     ret = LString::Create(str_token_len(s));
     1232    ret = LString::Create(str_token_len(code));
    12301233    char *start=lstring_value(ret);
    1231     for (; *s && (*s!='"' || s[1]=='"'); s++, start++)
    1232     {
    1233       if (*s=='\\')
    1234       {
    1235                 s++;
    1236                 if (*s=='n') *start='\n';
    1237                 if (*s=='r') *start='\r';
    1238                 if (*s=='t') *start='\t';
    1239                 if (*s=='\\') *start='\\';
    1240       } else *start=*s;
    1241       if (*s=='"') s++;
     1234    for (; *code && (*code!='"' || code[1]=='"'); code++, start++)
     1235    {
     1236      if (*code=='\\')
     1237      {
     1238                code++;
     1239                if (*code=='n') *start='\n';
     1240                if (*code=='r') *start='\r';
     1241                if (*code=='t') *start='\t';
     1242                if (*code=='\\') *start='\\';
     1243      } else *start=*code;
     1244      if (*code=='"') code++;
    12421245    }
    12431246    *start=0;
    1244     s++;
     1247    code++;
    12451248  } else if (n[0]=='#')
    12461249  {
    12471250    if (n[1]=='\\')
    12481251    {
    1249       read_ltoken(s, n);                   // read character name
     1252      read_ltoken(code, n);                   // read character name
    12501253      if (!strcmp(n, "newline"))
    12511254        ret = LChar::Create('\n');
     
    12571260    else if (n[1]==0)                           // short hand for function
    12581261    {
    1259       void *cs = LList::Create(), *c2=NULL, *tmp;
     1262      LObject *cs = LList::Create(), *c2=NULL, *tmp;
    12601263      PtrRef r4(cs), r5(c2);
    12611264      tmp = LSymbol::FindOrCreate("function");
    12621265      ((LList *)cs)->car = (LObject *)tmp;
    12631266      c2 = LList::Create();
    1264       tmp=compile(s);
     1267      tmp=Compile(code);
    12651268      ((LList *)c2)->car = (LObject *)tmp;
    12661269      ((LList *)cs)->cdr = (LObject *)c2;
     
    15221525          cur=first = LList::Create();
    15231526
    1524         void *val=eval(CAR(arg_list));
    1525         ((LList *)cur)->car = (LObject *)val;
     1527        LObject *val = CAR(arg_list)->Eval();
     1528        ((LList *)cur)->car = val;
    15261529        arg_list=lcdr(arg_list);
    15271530      }
     
    15701573{
    15711574  PtrRef ref1(arg_list);
    1572   void *sym=eval(CAR(arg_list));
     1575  LObject *sym = CAR(arg_list)->Eval();
    15731576  switch ((short)item_type(sym))
    15741577  {
     
    15931596  for (i=0; i<num_args; i++)
    15941597  {
    1595     arg_on[i]=(LList *)eval(CAR(list_on));
     1598    arg_on[i] = (LList *)CAR(list_on)->Eval();
    15961599    PtrRef::stack.push(&arg_on[i]);
    15971600
     
    16541657  PtrRef ref1(prog_list), ref2(el_list);
    16551658  void *ret=NULL;
    1656   void *rtype=eval(CAR(prog_list));
     1659  void *rtype = CAR(prog_list)->Eval();
    16571660
    16581661  long len=0;                                // determin the length of the resulting string
     
    16691672      for (i=0; i<elements; i++, el_list=CDR(el_list))
    16701673      {
    1671         str_eval[i]=eval(CAR(el_list));
     1674        str_eval[i] = CAR(el_list)->Eval();
    16721675    PtrRef::stack.push(&str_eval[i]);
    16731676
     
    17481751    return NULL;
    17491752  else if ((LSymbol *) (((LList *)args)->car)==comma_symbol)
    1750     return eval(CAR(CDR(args)));
     1753    return CAR(CDR(args))->Eval();
    17511754  else
    17521755  {
     
    17591762    if (CAR(args)==comma_symbol)               // dot list with a comma?
    17601763    {
    1761       tmp=eval(CAR(CDR(args)));
     1764      tmp = CAR(CDR(args))->Eval();
    17621765      ((LList *)last)->cdr = (LObject *)tmp;
    17631766      args=NULL;
     
    18001803      while (arg_list)
    18011804      {
    1802         ret=eval(CAR(arg_list));  arg_list=CDR(arg_list);
     1805        ret = CAR(arg_list)->Eval();
     1806        arg_list=CDR(arg_list);
    18031807        ((LObject *)ret)->Print();
    18041808      }
     
    18061810    } break;
    18071811    case SYS_FUNC_CAR:
    1808     { ret=lcar(eval(CAR(arg_list))); } break;
     1812    { ret=lcar(CAR(arg_list)->Eval()); } break;
    18091813    case SYS_FUNC_CDR:
    1810     { ret=lcdr(eval(CAR(arg_list))); } break;
     1814    { ret=lcdr(CAR(arg_list)->Eval()); } break;
    18111815    case SYS_FUNC_LENGTH:
    18121816    {
    1813       void *v=eval(CAR(arg_list));
     1817      void *v = CAR(arg_list)->Eval();
    18141818      switch (item_type(v))
    18151819      {
     
    18301834      {
    18311835    cur = LList::Create();
    1832     void *val=eval(CAR(arg_list));
     1836    void *val = CAR(arg_list)->Eval();
    18331837    ((LList *) cur)->car = (LObject *)val;
    18341838    if (last)
     
    18431847    { void *c = LList::Create();
    18441848      PtrRef r1(c);
    1845       void *val=eval(CAR(arg_list));
     1849      void *val = CAR(arg_list)->Eval();
    18461850      ((LList *)c)->car = (LObject *)val;
    1847       val=eval(CAR(CDR(arg_list)));
     1851      val = CAR(CDR(arg_list))->Eval();
    18481852      ((LList *)c)->cdr = (LObject *)val;
    18491853      ret=c;
     
    18541858    case SYS_FUNC_EQ:
    18551859    {
    1856       l_user_stack.push(eval(CAR(arg_list)));
    1857       l_user_stack.push(eval(CAR(CDR(arg_list))));
     1860      l_user_stack.push(CAR(arg_list)->Eval());
     1861      l_user_stack.push(CAR(CDR(arg_list))->Eval());
    18581862      ret=lisp_eq(l_user_stack.pop(1), l_user_stack.pop(1));
    18591863    } break;
    18601864    case SYS_FUNC_EQUAL:
    18611865    {
    1862       l_user_stack.push(eval(CAR(arg_list)));
    1863       l_user_stack.push(eval(CAR(CDR(arg_list))));
     1866      l_user_stack.push(CAR(arg_list)->Eval());
     1867      l_user_stack.push(CAR(CDR(arg_list))->Eval());
    18641868      ret=lisp_equal(l_user_stack.pop(1), l_user_stack.pop(1));
    18651869    } break;
     
    18691873      while (arg_list)
    18701874      {
    1871     sum+=lnumber_value(eval(CAR(arg_list)));
     1875    sum+=lnumber_value(CAR(arg_list)->Eval());
    18721876    arg_list=CDR(arg_list);
    18731877      }
     
    18781882    {
    18791883      long sum;
    1880       void *first=eval(CAR(arg_list));
     1884      void *first = CAR(arg_list)->Eval();
    18811885      PtrRef r1(first);
    18821886      if (arg_list && item_type(first)==L_FIXED_POINT)
     
    18871891      sum=(sum>>8)*(lfixed_point_value(first)>>8);
    18881892      arg_list=CDR(arg_list);
    1889       if (arg_list) first=eval(CAR(arg_list));
     1893      if (arg_list) first = CAR(arg_list)->Eval();
    18901894    } while (arg_list);
    18911895
     
    18951899    do
    18961900    {
    1897       sum*=lnumber_value(eval(CAR(arg_list)));
     1901      sum*=lnumber_value(CAR(arg_list)->Eval());
    18981902      arg_list=CDR(arg_list);
    1899       if (arg_list) first=eval(CAR(arg_list));
     1903      if (arg_list) first =CAR(arg_list)->Eval();
    19001904    } while (arg_list);
    19011905    ret = LNumber::Create(sum);
     
    19081912      while (arg_list)
    19091913      {
    1910     void *i=eval(CAR(arg_list));
     1914    void *i = CAR(arg_list)->Eval();
    19111915    PtrRef r1(i);
    19121916    if (item_type(i)!=L_NUMBER)
     
    19281932    case SYS_FUNC_MINUS:
    19291933    {
    1930       long x=lnumber_value(eval(CAR(arg_list)));         arg_list=CDR(arg_list);
     1934      long x=lnumber_value(CAR(arg_list)->Eval());
     1935      arg_list=CDR(arg_list);
    19311936      while (arg_list)
    19321937      {
    1933     x-=lnumber_value(eval(CAR(arg_list)));
     1938    x-=lnumber_value(CAR(arg_list)->Eval());
    19341939    arg_list=CDR(arg_list);
    19351940      }
     
    19391944    case SYS_FUNC_IF:
    19401945    {
    1941       if (eval(CAR(arg_list)))
    1942       ret=eval(CAR(CDR(arg_list)));
     1946      if (CAR(arg_list)->Eval())
     1947      ret=CAR(CDR(arg_list))->Eval();
    19431948      else
    19441949      { arg_list=CDR(CDR(arg_list));                 // check for a else part
    19451950    if (arg_list)
    1946       ret=eval(CAR(arg_list));
     1951      ret = CAR(arg_list)->Eval();
    19471952    else ret=NULL;
    19481953      }
     
    19511956    case SYS_FUNC_SETF:
    19521957    {
    1953       void *set_to=eval(CAR(CDR(arg_list))), *i=NULL;
     1958      void *set_to = CAR(CDR(arg_list))->Eval(), *i=NULL;
    19541959      PtrRef r1(set_to), r2(i);
    19551960      i=CAR(arg_list);
     
    19841989          if (car==car_symbol)
    19851990          {
    1986             car=eval(CAR(CDR(i)));
     1991            car = CAR(CDR(i))->Eval();
    19871992            if (!car || item_type(car)!=L_CONS_CELL)
    19881993            { ((LObject *)car)->Print(); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
     
    19901995          } else if (car==cdr_symbol)
    19911996          {
    1992             car=eval(CAR(CDR(i)));
     1997            car = CAR(CDR(i))->Eval();
    19931998            if (!car || item_type(car)!=L_CONS_CELL)
    19941999            { ((LObject *)car)->Print(); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
     
    19972002          {
    19982003#endif
    1999             LArray *a = (LArray *)eval(CAR(CDR(i)));
     2004            LArray *a = (LArray *)CAR(CDR(i))->Eval();
    20002005            PtrRef r1(a);
    20012006#ifdef TYPE_CHECKING
     
    20072012            }
    20082013#endif
    2009             int num = lnumber_value(eval(CAR(CDR(CDR(i)))));
     2014            int num = lnumber_value(CAR(CDR(CDR(i)))->Eval());
    20102015#ifdef TYPE_CHECKING
    20112016            if (num >= (int)a->len || num < 0)
     
    20392044    case SYS_FUNC_ASSOC:
    20402045    {
    2041       void *item=eval(CAR(arg_list));
     2046      void *item = CAR(arg_list)->Eval();
    20422047      PtrRef r1(item);
    2043       void *list=(LList *)eval(CAR(CDR(arg_list)));
     2048      void *list=(LList *)CAR(CDR(arg_list))->Eval();
    20442049      PtrRef r2(list);
    20452050      ret=assoc(item, (LList *)list);
     
    20472052    case SYS_FUNC_NOT:
    20482053    case SYS_FUNC_NULL:
    2049     if (eval(CAR(arg_list))==NULL) ret=true_symbol; else ret=NULL;
     2054    if (CAR(arg_list)->Eval()==NULL) ret=true_symbol; else ret=NULL;
    20502055    break;
    20512056    case SYS_FUNC_ACONS:
    20522057    {
    2053       void *i1=eval(CAR(arg_list)), *i2=eval(CAR(CDR(arg_list)));
     2058      void *i1 = CAR(arg_list)->Eval(), *i2 = CAR(CDR(arg_list))->Eval();
    20542059      PtrRef r1(i1);
    20552060      LList *cs = LList::Create();
     
    20612066    case SYS_FUNC_PAIRLIS:
    20622067    {
    2063       l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    2064       l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    2065       void *n3=eval(CAR(arg_list));
     2068      l_user_stack.push(CAR(arg_list)->Eval());
     2069      arg_list=CDR(arg_list);
     2070      l_user_stack.push(CAR(arg_list)->Eval());
     2071      arg_list=CDR(arg_list);
     2072      void *n3 = CAR(arg_list)->Eval();
    20662073      void *n2=l_user_stack.pop(1);
    20672074      void *n1=l_user_stack.pop(1);
     
    20892096
    20902097    l_user_stack.push(((LSymbol *)var_name)->value);
    2091     tmp=eval(CAR(CDR(CAR(var_list))));
     2098    tmp = CAR(CDR(CAR(var_list)))->Eval();
    20922099    ((LSymbol *)var_name)->SetValue((LObject *)tmp);
    20932100    var_list=CDR(var_list);
     
    20982105      while (block_list)
    20992106      {
    2100     ret=eval(CAR(block_list));
     2107    ret = CAR(block_list)->Eval();
    21012108    block_list=CDR(block_list);
    21022109      }
     
    21442151    } break;
    21452152    case SYS_FUNC_ATOM:
    2146     { ret=lisp_atom(eval(CAR(arg_list))); }
     2153    { ret=lisp_atom(CAR(arg_list)->Eval()); }
    21472154    case SYS_FUNC_AND:
    21482155    {
     
    21522159      while (l)
    21532160      {
    2154     if (!eval(CAR(l)))
     2161    if (!CAR(l)->Eval())
    21552162    {
    21562163      ret=NULL;
     
    21662173      while (l)
    21672174      {
    2168     if (eval(CAR(l)))
     2175    if (CAR(l)->Eval())
    21692176    {
    21702177      ret=true_symbol;
     
    21802187    case SYS_FUNC_CHAR_CODE:
    21812188    {
    2182       void *i=eval(CAR(arg_list));
     2189      void *i = CAR(arg_list)->Eval();
    21832190      PtrRef r1(i);
    21842191      ret=NULL;
     
    21992206    case SYS_FUNC_CODE_CHAR:
    22002207    {
    2201       void *i=eval(CAR(arg_list));
     2208      void *i = CAR(arg_list)->Eval();
    22022209      PtrRef r1(i);
    22032210      if (item_type(i)!=L_NUMBER)
     
    22192226        while (block_list)
    22202227    {
    2221       if (eval(lcar(CAR(block_list))))
    2222         ret=eval(CAR(CDR(CAR(block_list))));
     2228      if (lcar(CAR(block_list))->Eval())
     2229        ret = CAR(CDR(CAR(block_list)))->Eval();
    22232230      block_list=CDR(block_list);
    22242231    }
     
    22272234    case SYS_FUNC_SELECT:
    22282235    {
    2229       void *selector=eval(CAR(arg_list));
     2236      void *selector = CAR(arg_list)->Eval();
    22302237      void *sel=CDR(arg_list);
    22312238      PtrRef r1(selector), r2(sel);
    22322239      while (sel)
    22332240      {
    2234     if (lisp_equal(selector, eval(CAR(CAR(sel)))))
     2241    if (lisp_equal(selector, CAR(CAR(sel))->Eval()))
    22352242    {
    22362243      sel=CDR(CAR(sel));
    22372244      while (sel)
    22382245      {
    2239         ret=eval(CAR(sel));
     2246        ret = CAR(sel)->Eval();
    22402247        sel=CDR(sel);
    22412248      }
     
    22452252    } break;
    22462253    case SYS_FUNC_FUNCTION:
    2247       ret = ((LSymbol *)eval(CAR(arg_list)))->GetFunction();
     2254      ret = ((LSymbol *)CAR(arg_list)->Eval())->GetFunction();
    22482255    break;
    22492256    case SYS_FUNC_MAPCAR:
     
    22512258    case SYS_FUNC_FUNCALL:
    22522259    {
    2253       void *n1=eval(CAR(arg_list));
     2260      void *n1 = CAR(arg_list)->Eval();
    22542261      ret=eval_function((LSymbol *)n1, CDR(arg_list));
    22552262    } break;
    22562263    case SYS_FUNC_GT:
    22572264    {
    2258       long n1=lnumber_value(eval(CAR(arg_list)));
    2259       long n2=lnumber_value(eval(CAR(CDR(arg_list))));
     2265      long n1=lnumber_value(CAR(arg_list)->Eval());
     2266      long n2=lnumber_value(CAR(CDR(arg_list))->Eval());
    22602267      if (n1>n2) ret=true_symbol; else ret=NULL;
    22612268    }
     
    22632270    case SYS_FUNC_LT:
    22642271    {
    2265       long n1=lnumber_value(eval(CAR(arg_list)));
    2266       long n2=lnumber_value(eval(CAR(CDR(arg_list))));
     2272      long n1=lnumber_value(CAR(arg_list)->Eval());
     2273      long n2=lnumber_value(CAR(CDR(arg_list))->Eval());
    22672274      if (n1<n2) ret=true_symbol; else ret=NULL;
    22682275    }
     
    22702277    case SYS_FUNC_GE:
    22712278    {
    2272       long n1=lnumber_value(eval(CAR(arg_list)));
    2273       long n2=lnumber_value(eval(CAR(CDR(arg_list))));
     2279      long n1=lnumber_value(CAR(arg_list)->Eval());
     2280      long n2=lnumber_value(CAR(CDR(arg_list))->Eval());
    22742281      if (n1>=n2) ret=true_symbol; else ret=NULL;
    22752282    }
     
    22772284    case SYS_FUNC_LE:
    22782285    {
    2279       long n1=lnumber_value(eval(CAR(arg_list)));
    2280       long n2=lnumber_value(eval(CAR(CDR(arg_list))));
     2286      long n1=lnumber_value(CAR(arg_list)->Eval());
     2287      long n2=lnumber_value(CAR(CDR(arg_list))->Eval());
    22812288      if (n1<=n2) ret=true_symbol; else ret=NULL;
    22822289    }
     
    22932300    case SYS_FUNC_SYMBOL_NAME:
    22942301      void *symb;
    2295       symb=eval(CAR(arg_list));
     2302      symb = CAR(arg_list)->Eval();
    22962303#ifdef TYPE_CHECKING
    22972304      if (item_type(symb)!=L_SYMBOL)
     
    23072314      trace_level++;
    23082315      if (arg_list)
    2309         trace_print_level=lnumber_value(eval(CAR(arg_list)));
     2316        trace_print_level=lnumber_value(CAR(arg_list)->Eval());
    23102317      ret=true_symbol;
    23112318    break;
     
    23202327    {
    23212328      char tmp[50], *tp;
    2322       long num=lnumber_value(eval(CAR(arg_list)));
    2323       long dig=lnumber_value(eval(CAR(CDR(arg_list))));
     2329      long num=lnumber_value(CAR(arg_list)->Eval());
     2330      long dig=lnumber_value(CAR(CDR(arg_list))->Eval());
    23242331      tp=tmp+49;
    23252332      *(tp--)=0;
     
    23402347    case SYS_FUNC_COMPILE_FILE:
    23412348    {
    2342             void *fn = eval( CAR( arg_list ) );
     2349            void *fn = CAR(arg_list)->Eval();
    23432350            char *st = lstring_value( fn );
    23442351            PtrRef r1( fn );
     
    23932400                crc_manager.get_filenumber(st);               // make sure this file gets crc'ed
    23942401            #endif
    2395                 void *compiled_form=NULL;
     2402                LObject *compiled_form = NULL;
    23962403                PtrRef r11(compiled_form);
    23972404                while (!end_of_program(cs))  // see if there is anything left to compile and run
     
    24012408            #endif
    24022409                  void *m=mark_heap(TMP_SPACE);
    2403                   compiled_form=compile(cs);
    2404                   eval(compiled_form);
     2410                  compiled_form=LObject::Compile(cs);
     2411                  compiled_form->Eval();
    24052412                  compiled_form=NULL;
    24062413                  restore_heap(m, TMP_SPACE);
     
    24152422    } break;
    24162423    case SYS_FUNC_ABS:
    2417       ret = LNumber::Create(abs(lnumber_value(eval(CAR(arg_list))))); break;
     2424      ret = LNumber::Create(abs(lnumber_value(CAR(arg_list)->Eval()))); break;
    24182425    case SYS_FUNC_MIN:
    24192426    {
    2420       int x=lnumber_value(eval(CAR(arg_list))), y=lnumber_value(eval(CAR(CDR(arg_list))));
     2427      int x=lnumber_value(CAR(arg_list)->Eval()),
     2428          y=lnumber_value(CAR(CDR(arg_list))->Eval());
    24212429      ret = LNumber::Create(x < y ? x : y);
    24222430    } break;
    24232431    case SYS_FUNC_MAX:
    24242432    {
    2425       int x=lnumber_value(eval(CAR(arg_list))), y=lnumber_value(eval(CAR(CDR(arg_list))));
     2433      int x=lnumber_value(CAR(arg_list)->Eval()),
     2434          y=lnumber_value(CAR(CDR(arg_list))->Eval());
    24262435      ret = LNumber::Create(x > y ? x : y);
    24272436    } break;
     
    24392448    case SYS_FUNC_NTH:
    24402449    {
    2441       long x=lnumber_value(eval(CAR(arg_list)));
    2442       ret=nth(x, eval(CAR(CDR(arg_list))));
     2450      long x=lnumber_value(CAR(arg_list)->Eval());
     2451      ret=nth(x, CAR(CDR(arg_list))->Eval());
    24432452    } break;
    24442453    case SYS_FUNC_RESIZE_TMP:
    2445         resize_tmp(lnumber_value(eval(CAR(arg_list)))); break;
     2454        resize_tmp(lnumber_value(CAR(arg_list)->Eval())); break;
    24462455    case SYS_FUNC_RESIZE_PERM:
    2447         resize_perm(lnumber_value(eval(CAR(arg_list)))); break;
     2456        resize_perm(lnumber_value(CAR(arg_list)->Eval())); break;
    24482457    case SYS_FUNC_COS:
    2449         ret = LFixedPoint::Create(lisp_cos(lnumber_value(eval(CAR(arg_list))))); break;
     2458        ret = LFixedPoint::Create(lisp_cos(lnumber_value(CAR(arg_list)->Eval()))); break;
    24502459    case SYS_FUNC_SIN:
    2451         ret = LFixedPoint::Create(lisp_sin(lnumber_value(eval(CAR(arg_list))))); break;
     2460        ret = LFixedPoint::Create(lisp_sin(lnumber_value(CAR(arg_list)->Eval()))); break;
    24522461    case SYS_FUNC_ATAN2:
    24532462    {
    2454       long y=(lnumber_value(eval(CAR(arg_list))));   arg_list=CDR(arg_list);
    2455       long x=(lnumber_value(eval(CAR(arg_list))));
     2463      long y=(lnumber_value(CAR(arg_list)->Eval()));   arg_list=CDR(arg_list);
     2464      long x=(lnumber_value(CAR(arg_list)->Eval()));
    24562465      ret = LNumber::Create(lisp_atan2(y, x));
    24572466    } break;
     
    24632472      while (arg_list)
    24642473      {
    2465     void *sym=eval(CAR(arg_list));
     2474    void *sym = CAR(arg_list)->Eval();
    24662475    PtrRef r1(sym);
    24672476    switch (item_type(sym))
     
    24712480      case L_CONS_CELL :
    24722481      {
    2473         void *s=eval(CAR(sym));
     2482        void *s = CAR(sym)->Eval();
    24742483        PtrRef r1(s);
    24752484#ifdef TYPE_CHECKING
     
    24812490        }
    24822491#endif
    2483         x=lnumber_value(eval(CAR(CDR(sym))));
     2492        x=lnumber_value(CAR(CDR(sym))->Eval());
    24842493        ((LSymbol *)sym)->value = LNumber::Create(x);
    24852494      } break;
     
    25022511    case SYS_FUNC_EVAL:
    25032512    {
    2504       ret=eval(eval(CAR(arg_list)));
     2513      ret = CAR(arg_list)->Eval()->Eval();
    25052514    } break;
    25062515    case SYS_FUNC_BREAK: lbreak("User break"); break;
    25072516    case SYS_FUNC_MOD:
    25082517    {
    2509       long x=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    2510       long y=lnumber_value(eval(CAR(arg_list)));
     2518      long x=lnumber_value(CAR(arg_list)->Eval()); arg_list=CDR(arg_list);
     2519      long y=lnumber_value(CAR(arg_list)->Eval());
    25112520      if (y==0) { lbreak("mod : division by zero\n"); y=1; }
    25122521      ret = LNumber::Create(x%y);
     
    25142523/*    case SYS_FUNC_WRITE_PROFILE:
    25152524    {
    2516       char *fn=lstring_value(eval(CAR(arg_list)));
     2525      char *fn=lstring_value(CAR(arg_list)->Eval());
    25172526      FILE *fp=fopen(fn, "wb");
    25182527      if (!fp)
     
    25382547      arg_list=CDR(arg_list);
    25392548
    2540       void *ilist=eval(CAR(arg_list)); arg_list=CDR(arg_list);
     2549      void *ilist = CAR(arg_list)->Eval(); arg_list=CDR(arg_list);
    25412550      PtrRef r2(ilist);
    25422551
     
    25522561                bind_var->SetValue((LObject *)CAR(ilist));
    25532562                for (block=arg_list; block; block=CDR(block))
    2554                   ret=eval(CAR(block));
     2563                  ret = CAR(block)->Eval();
    25552564                ilist=CDR(ilist);
    25562565      }
     
    25612570    {
    25622571      bFILE *old_file=current_print_file;
    2563       void *str1=eval(CAR(arg_list));
     2572      void *str1 = CAR(arg_list)->Eval();
    25642573      PtrRef r1(str1);
    2565       void *str2=eval(CAR(CDR(arg_list)));
     2574      void *str2 = CAR(CDR(arg_list))->Eval();
    25662575
    25672576
     
    25732582                while (arg_list)
    25742583                {
    2575                   ret=eval(CAR(arg_list));
     2584                  ret = CAR(arg_list)->Eval();
    25762585                  arg_list=CDR(arg_list);
    25772586                }
     
    25832592    case SYS_FUNC_BIT_AND:
    25842593    {
    2585       long first=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
     2594      long first=lnumber_value(CAR(arg_list)->Eval()); arg_list=CDR(arg_list);
    25862595      while (arg_list)
    25872596      {
    2588         first&=lnumber_value(eval(CAR(arg_list)));
     2597        first&=lnumber_value(CAR(arg_list)->Eval());
    25892598                arg_list=CDR(arg_list);
    25902599      }
     
    25932602    case SYS_FUNC_BIT_OR:
    25942603    {
    2595       long first=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
     2604      long first=lnumber_value(CAR(arg_list)->Eval()); arg_list=CDR(arg_list);
    25962605      while (arg_list)
    25972606      {
    2598         first|=lnumber_value(eval(CAR(arg_list)));
     2607        first|=lnumber_value(CAR(arg_list)->Eval());
    25992608                arg_list=CDR(arg_list);
    26002609      }
     
    26032612    case SYS_FUNC_BIT_XOR:
    26042613    {
    2605       long first=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
     2614      long first=lnumber_value(CAR(arg_list)->Eval()); arg_list=CDR(arg_list);
    26062615      while (arg_list)
    26072616      {
    2608         first^=lnumber_value(eval(CAR(arg_list)));
     2617        first^=lnumber_value(CAR(arg_list)->Eval());
    26092618                arg_list=CDR(arg_list);
    26102619      }
     
    26132622    case SYS_FUNC_MAKE_ARRAY:
    26142623    {
    2615       long l=lnumber_value(eval(CAR(arg_list)));
     2624      long l=lnumber_value(CAR(arg_list)->Eval());
    26162625      if (l>=2<<16 || l<=0)
    26172626      {
     
    26232632    case SYS_FUNC_AREF:
    26242633    {
    2625       long x=lnumber_value(eval(CAR(CDR(arg_list))));
    2626       ret = ((LArray *)eval(CAR(arg_list)))->Get(x);
     2634      long x=lnumber_value(CAR(CDR(arg_list))->Eval());
     2635      ret = ((LArray *)CAR(arg_list)->Eval())->Get(x);
    26272636    } break;
    26282637    case SYS_FUNC_IF_1PROGN:
    26292638    {
    2630       if (eval(CAR(arg_list)))
     2639      if (CAR(arg_list)->Eval())
    26312640        ret=eval_block(CAR(CDR(arg_list)));
    2632       else ret=eval(CAR(CDR(CDR(arg_list))));
     2641      else ret = CAR(CDR(CDR(arg_list)))->Eval();
    26332642
    26342643    } break;
    26352644    case SYS_FUNC_IF_2PROGN:
    26362645    {
    2637       if (eval(CAR(arg_list)))
    2638         ret=eval(CAR(CDR(arg_list)));
     2646      if (CAR(arg_list)->Eval())
     2647        ret = CAR(CDR(arg_list))->Eval();
    26392648      else ret=eval_block(CAR(CDR(CDR(arg_list))));
    26402649
     
    26422651    case SYS_FUNC_IF_12PROGN:
    26432652    {
    2644       if (eval(CAR(arg_list)))
     2653      if (CAR(arg_list)->Eval())
    26452654        ret=eval_block(CAR(CDR(arg_list)));
    26462655      else ret=eval_block(CAR(CDR(CDR(arg_list))));
     
    26492658    case SYS_FUNC_EQ0:
    26502659    {
    2651       void *v=eval(CAR(arg_list));
     2660      void *v = CAR(arg_list)->Eval();
    26522661      if (item_type(v)!=L_NUMBER || (((LNumber *)v)->num!=0))
    26532662        ret=NULL;
     
    26572666    {
    26582667#ifdef L_PROFILE
    2659       char *s=lstring_value(eval(CAR(arg_list)));
     2668      char *s=lstring_value(CAR(arg_list)->Eval());
    26602669      preport(s);
    26612670#endif
     
    26632672    case SYS_FUNC_SEARCH:
    26642673    {
    2665       void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
     2674      void *arg1 = CAR(arg_list)->Eval(); arg_list=CDR(arg_list);
    26662675      PtrRef r1(arg1);       // protect this refrence
    2667       char *haystack=lstring_value(eval(CAR(arg_list)));
     2676      char *haystack=lstring_value(CAR(arg_list)->Eval());
    26682677      char *needle=lstring_value(arg1);
    26692678
     
    26752684    case SYS_FUNC_ELT:
    26762685    {
    2677       void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
     2686      void *arg1 = CAR(arg_list)->Eval(); arg_list=CDR(arg_list);
    26782687      PtrRef r1(arg1);       // protect this refrence
    2679       long x=lnumber_value(eval(CAR(arg_list)));
     2688      long x=lnumber_value(CAR(arg_list)->Eval());
    26802689      char *st=lstring_value(arg1);
    26812690      if (x < 0 || (unsigned)x >= strlen(st))
     
    26862695    case SYS_FUNC_LISTP:
    26872696    {
    2688       return item_type(eval(CAR(arg_list)))==L_CONS_CELL ? true_symbol : NULL;
     2697      return item_type(CAR(arg_list)->Eval())==L_CONS_CELL ? true_symbol : NULL;
    26892698    } break;
    26902699    case SYS_FUNC_NUMBERP:
    26912700    {
    2692       int t=item_type(eval(CAR(arg_list)));
     2701      int t=item_type(CAR(arg_list)->Eval());
    26932702      if (t==L_NUMBER || t==L_FIXED_POINT) return true_symbol; else return NULL;
    26942703    } break;
     
    27132722      // push all of the init forms, so we can set the symbol
    27142723      for (init_var=CAR(arg_list); init_var; init_var=CDR(init_var))
    2715                 l_user_stack.push(eval(CAR(CDR(CAR((init_var))))));
     2724                l_user_stack.push(CAR(CDR(CAR((init_var))))->Eval());
    27162725
    27172726      // now set all the symbols
     
    27252734      do
    27262735      {
    2727                 i=(eval(CAR(CAR(CDR(arg_list))))!=NULL);
     2736                i = CAR(CAR(CDR(arg_list)))->Eval() != NULL;
    27282737                if (!i)
    27292738                {
    27302739                  eval_block(CDR(CDR(arg_list)));
    27312740                  for (init_var=CAR(arg_list); init_var; init_var=CDR(init_var))
    2732                     eval(CAR(CDR(CDR(CAR(init_var)))));
     2741                    CAR(CDR(CDR(CAR(init_var))))->Eval();
    27332742                }
    27342743      } while (!i);
    27352744
    2736       ret=eval(CAR(CDR(CAR(CDR(arg_list)))));
     2745      ret = CAR(CDR(CAR(CDR(arg_list))))->Eval();
    27372746
    27382747      // restore old values for symbols
     
    27532762    case SYS_FUNC_SCHAR:
    27542763    {
    2755       char *s=lstring_value(eval(CAR(arg_list)));      arg_list=CDR(arg_list);
    2756       long x=lnumber_value(eval(CAR(arg_list)));
     2764      char *s=lstring_value(CAR(arg_list)->Eval());
     2765      arg_list=CDR(arg_list);
     2766      long x=lnumber_value(CAR(arg_list)->Eval());
    27572767
    27582768      if ((unsigned)x >= strlen(s))
     
    27632773    } break;
    27642774    case SYS_FUNC_SYMBOLP:
    2765     { if (item_type(eval(CAR(arg_list)))==L_SYMBOL) return true_symbol;
     2775    { if (item_type(CAR(arg_list)->Eval())==L_SYMBOL) return true_symbol;
    27662776      else return NULL; } break;
    27672777    case SYS_FUNC_NUM2STR:
    27682778    {
    27692779      char str[20];
    2770       sprintf(str, "%ld", (long int)lnumber_value(eval(CAR(arg_list))));
     2780      sprintf(str, "%ld", (long int)lnumber_value(CAR(arg_list)->Eval()));
    27712781      ret=LString::Create(str);
    27722782    } break;
    27732783    case SYS_FUNC_NCONC:
    27742784    {
    2775       void *l1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
     2785      void *l1=CAR(arg_list)->Eval(); arg_list=CDR(arg_list);
    27762786      PtrRef r1(l1);
    27772787      void *first=l1, *next;
     
    27802790      if (!l1)
    27812791      {
    2782                 l1=first=eval(CAR(arg_list));
     2792                l1=first=CAR(arg_list)->Eval();
    27832793                arg_list=CDR(arg_list);
    27842794      }
     
    27902800                next=l1;
    27912801                while (next) { l1=next; next=lcdr(next); }
    2792                 ((LList *)l1)->cdr = (LObject *)eval(CAR(arg_list));
     2802                ((LList *)l1)->cdr = CAR(arg_list)->Eval();
    27932803                arg_list=CDR(arg_list);
    27942804      } while (arg_list);
     
    27962806    } break;
    27972807    case SYS_FUNC_FIRST:
    2798     { ret=CAR(eval(CAR(arg_list))); } break;
     2808    { ret=CAR(CAR(arg_list)->Eval()); } break;
    27992809    case SYS_FUNC_SECOND:
    2800     { ret=CAR(CDR(eval(CAR(arg_list)))); } break;
     2810    { ret=CAR(CDR(CAR(arg_list)->Eval())); } break;
    28012811    case SYS_FUNC_THIRD:
    2802     { ret=CAR(CDR(CDR(eval(CAR(arg_list))))); } break;
     2812    { ret=CAR(CDR(CDR(CAR(arg_list)->Eval()))); } break;
    28032813    case SYS_FUNC_FOURTH:
    2804     { ret=CAR(CDR(CDR(CDR(eval(CAR(arg_list)))))); } break;
     2814    { ret=CAR(CDR(CDR(CDR(CAR(arg_list)->Eval())))); } break;
    28052815    case SYS_FUNC_FIFTH:
    2806     { ret=CAR(CDR(CDR(CDR(CDR(eval(CAR(arg_list))))))); } break;
     2816    { ret=CAR(CDR(CDR(CDR(CDR(CAR(arg_list)->Eval()))))); } break;
    28072817    case SYS_FUNC_SIXTH:
    2808     { ret=CAR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list)))))))); } break;
     2818    { ret=CAR(CDR(CDR(CDR(CDR(CDR(CAR(arg_list)->Eval())))))); } break;
    28092819    case SYS_FUNC_SEVENTH:
    2810     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list))))))))); } break;
     2820    { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CAR(arg_list)->Eval()))))))); } break;
    28112821    case SYS_FUNC_EIGHTH:
    2812     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list)))))))))); } break;
     2822    { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CAR(arg_list)->Eval())))))))); } break;
    28132823    case SYS_FUNC_NINTH:
    2814     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list))))))))))); } break;
     2824    { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CAR(arg_list)->Eval()))))))))); } break;
    28152825    case SYS_FUNC_TENTH:
    2816     { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(eval(CAR(arg_list)))))))))))); } break;
     2826    { ret=CAR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CDR(CAR(arg_list)->Eval())))))))))); } break;
    28172827    case SYS_FUNC_SUBSTR:
    28182828    {
    2819       long x1=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    2820       long x2=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    2821       void *st=eval(CAR(arg_list));
     2829      long x1=lnumber_value(CAR(arg_list)->Eval()); arg_list=CDR(arg_list);
     2830      long x2=lnumber_value(CAR(arg_list)->Eval()); arg_list=CDR(arg_list);
     2831      void *st=CAR(arg_list)->Eval();
    28222832      PtrRef r1(st);
    28232833
     
    28382848      while (arg_list)
    28392849      {
    2840         void *q=eval(CAR(arg_list));
     2850        void *q = CAR(arg_list)->Eval();
    28412851        if (!rstart) rstart=q;
    28422852        while (r && CDR(r)) r=CDR(r);
     
    29332943      if (!arg_list)
    29342944      { ((LObject *)sym)->Print(); lbreak("too few parameter to function\n"); exit(0); }
    2935       l_user_stack.push(eval(CAR(arg_list)));
     2945      l_user_stack.push(CAR(arg_list)->Eval());
    29362946      f_arg=CDR(f_arg);
    29372947      arg_list=CDR(arg_list);
     
    29552965  while (block_list)
    29562966  {
    2957     ret=eval(CAR(block_list));
     2967    ret=CAR(block_list)->Eval();
    29582968    block_list=CDR(block_list);
    29592969  }
     
    29742984}
    29752985
    2976 
    2977 
    2978 
    2979 
    2980 void *eval(void *prog)
    2981 {
    2982 
    2983 
    2984   void *ret=NULL;
    2985   PtrRef ref1(prog);
    2986 
    2987 
    2988   int tstart=trace_level;
    2989 
    2990   if (trace_level)
    2991   {
    2992     if (trace_level<=trace_print_level)
    2993     {
    2994       dprintf("%d (%d, %d, %d) TRACE : ", trace_level,
    2995           space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]),
    2996           space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
    2997           PtrRef::stack.son);
    2998       ((LObject *)prog)->Print();
    2999 
    3000       dprintf("\n");
    3001     }
    3002     trace_level++;
    3003   }
    3004   if (prog)
    3005   {
    3006     switch (item_type(prog))
    3007     {
    3008       case L_BAD_CELL :
    3009       { lbreak("error : eval on a bad cell\n"); exit(0); } break;
    3010       case L_CHARACTER :
    3011       case L_STRING :
    3012       case L_NUMBER :
    3013       case L_POINTER :
    3014       case L_FIXED_POINT :
    3015       { ret=prog; } break;
    3016       case L_SYMBOL :
    3017       { if (prog==true_symbol)
    3018                   ret=prog;
    3019         else
    3020                 {
    3021                   ret = ((LSymbol *)prog)->GetValue();
    3022                   if (item_type(ret)==L_OBJECT_VAR)
    3023                     ret=l_obj_get(((LObjectVar *)ret)->index);
    3024                 }
    3025       } break;
    3026       case L_CONS_CELL :
    3027       {
    3028         ret=eval_function((LSymbol *)CAR(prog), CDR(prog));
    3029       }
    3030       break;
    3031       default :
    3032         fprintf(stderr, "shouldn't happen\n");
    3033     }
    3034   }
    3035   if (tstart)
    3036   {
    3037     trace_level--;
    3038     if (trace_level<=trace_print_level)
    3039       dprintf("%d (%d, %d, %d) TRACE ==> ", trace_level,
    3040           space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]),
    3041           space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
    3042           PtrRef::stack.son);
    3043     ((LObject *)ret)->Print();
    3044     dprintf("\n");
    3045   }
     2986LObject *LObject::Eval()
     2987{
     2988    LObject *ret = NULL;
     2989    PtrRef ref1(this);
     2990
     2991    int tstart = trace_level;
     2992
     2993    if (trace_level)
     2994    {
     2995        if (trace_level <= trace_print_level)
     2996        {
     2997            dprintf("%d (%d, %d, %d) TRACE : ", trace_level,
     2998                    get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
     2999                    PtrRef::stack.son);
     3000            Print();
     3001            dprintf("\n");
     3002        }
     3003        trace_level++;
     3004    }
     3005
     3006    if (this)
     3007    {
     3008        switch (item_type(this))
     3009        {
     3010        case L_BAD_CELL:
     3011            lbreak("error: eval on a bad cell\n");
     3012            exit(0);
     3013            break;
     3014        case L_CHARACTER:
     3015        case L_STRING:
     3016        case L_NUMBER:
     3017        case L_POINTER:
     3018        case L_FIXED_POINT:
     3019            ret = this;
     3020            break;
     3021        case L_SYMBOL:
     3022            if (this == true_symbol)
     3023                ret = this;
     3024            else
     3025            {
     3026                ret = ((LSymbol *)this)->GetValue();
     3027                if (item_type(ret) == L_OBJECT_VAR)
     3028                    ret = (LObject *)l_obj_get(((LObjectVar *)ret)->index);
     3029            }
     3030            break;
     3031        case L_CONS_CELL:
     3032            ret = (LObject *)eval_function((LSymbol *)CAR(this), CDR(this));
     3033            break;
     3034        default :
     3035            fprintf(stderr, "shouldn't happen\n");
     3036            break;
     3037        }
     3038    }
     3039
     3040    if (tstart)
     3041    {
     3042        trace_level--;
     3043        if (trace_level <= trace_print_level)
     3044            dprintf("%d (%d, %d, %d) TRACE ==> ", trace_level,
     3045                    get_free_size(PERM_SPACE), get_free_size(TMP_SPACE),
     3046                    PtrRef::stack.son);
     3047        ret->Print();
     3048        dprintf("\n");
     3049    }
    30463050
    30473051/*  l_user_stack.push(ret);
     
    30493053  ret=l_user_stack.pop(1);  */
    30503054
    3051 
    3052   return ret;
     3055    return ret;
    30533056}
    30543057
     
    31163119    free(space[0]);
    31173120    free(space[1]);
    3118     ldelete_syms(LSymbol::root);
     3121    DeleteAllSymbols(LSymbol::root);
    31193122    LSymbol::root = NULL;
    31203123    LSymbol::count = 0;
     
    31233126void clear_tmp()
    31243127{
    3125   free_space[TMP_SPACE]=space[TMP_SPACE];
     3128    free_space[TMP_SPACE] = space[TMP_SPACE];
    31263129}
    31273130
  • abuse/trunk/src/lisp/lisp.h

    r494 r496  
    4848struct LObject
    4949{
     50    /* Factories */
     51    static LObject *Compile(char const *&s);
     52
     53    /* Methods */
     54    LObject *Eval();
    5055    void Print();
    5156
     57    /* Members */
    5258    ltype type;
    5359};
     
    5561struct LObjectVar : LObject
    5662{
     63    /* Factories */
    5764    static LObjectVar *Create(int index);
    5865
     66    /* Members */
    5967    int index;
    6068};
     
    6270struct LList : LObject
    6371{
     72    /* Factories */
    6473    static LList *Create();
    6574
     75    /* Methods */
    6676    size_t GetLength();
    6777
     78    /* Members */
    6879    LObject *cdr, *car;
    6980};
     
    7182struct LNumber : LObject
    7283{
     84    /* Factories */
    7385    static LNumber *Create(long num);
    7486
     87    /* Members */
    7588    long num;
    7689};
     
    7891struct LRedirect : LObject
    7992{
     93    /* Members */
    8094    LObject *ref;
    8195};
     
    8397struct LString : LObject
    8498{
     99    /* Factories */
    85100    static LString *Create(char const *string);
    86101    static LString *Create(char const *string, int length);
    87102    static LString *Create(int length);
    88103
     104    /* Methods */
    89105    char *GetString();
    90106
     107    /* Members */
    91108private:
    92109    char str[1]; /* Can be allocated much larger than 1 */
     
    155172struct LChar : LObject
    156173{
     174    /* Factories */
    157175    static LChar *Create(uint16_t ch);
    158176
     177    /* Members */
    159178    uint16_t ch;
    160179};
     
    162181struct LPointer : LObject
    163182{
     183    /* Factories */
    164184    static LPointer *Create(void *addr);
    165185
     186    /* Members */
    166187    void *addr;
    167188};
     
    169190struct LFixedPoint : LObject
    170191{
     192    /* Factories */
    171193    static LFixedPoint *Create(int32_t x);
    172194
     195    /* Members */
    173196    int32_t x;
    174197};
     
    186209long lfixed_point_value(void *c);
    187210void *lisp_atom(void *i);
    188 void *lcdr(void *c);
    189 void *lcar(void *c);
     211LObject *lcdr(void *c);
     212LObject *lcar(void *c);
    190213void *lisp_eq(void *n1, void *n2);
    191214void *lisp_equal(void *n1, void *n2);
    192 void *eval(void *prog);
    193215void *eval_block(void *list);
    194216void *eval_function(LSymbol *sym, void *arg_list);
    195217void *eval_user_fun(LSymbol *sym, void *arg_list);
    196 void *compile(char const *&s);
    197218void *assoc(void *item, void *list);
    198219void resize_tmp(int new_size);
  • abuse/trunk/src/lisp/lisp_gc.h

    r494 r496  
    3131    }
    3232
     33    template<typename T> inline PtrRef(T * const &ref)
     34    {
     35        stack.push((void **)&ref);
     36    }
     37
    3338    inline ~PtrRef()
    3439    {
  • abuse/trunk/src/loader2.cpp

    r494 r496  
    344344
    345345  cs=prog;
    346   if (!eval(compile(cs)))
     346  if (!LObject::Compile(cs)->Eval())
    347347  {
    348348    printf("unable to open file '%s'\n",lsf);
  • abuse/trunk/src/menu.cpp

    r494 r496  
    385385//    char *prog="((\"art/help.spe\" . \"sell2\")(\"art/help.spe\" . \"sell4\")(\"art/help.spe\" . \"sell3\")(\"art/endgame.spe\" . \"credit\"))";
    386386//    char *prog="((\"art/endgame.spe\" . \"credit\") (\"art/help.spe\" . \"sell6\"))";
    387     char const *prog="((\"art/endgame.spe\" . \"credit\"))";
    388     ss->SetValue((LObject *)compile(prog));
     387    char const *prog = "((\"art/endgame.spe\" . \"credit\"))";
     388    ss->SetValue(LObject::Compile(prog));
    389389    current_space=sp;
    390390  }
Note: See TracChangeset for help on using the changeset viewer.