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

lisp: implement LObject::Eval.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.