Ignore:
Timestamp:
Apr 17, 2011, 10:28:44 AM (10 years ago)
Author:
Sam Hocevar
Message:

lisp: implement LispList::GetLength?.

File:
1 edited

Legend:

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

    r489 r490  
    895895}
    896896
    897 long list_length(void *i)
    898 {
    899   long x;
     897size_t LispList::GetLength()
     898{
     899    size_t ret = 0;
    900900
    901901#ifdef TYPE_CHECKING
    902   if (i && item_type(i)!=(ltype)L_CONS_CELL)
    903   {
    904     lprint(i);
    905     lbreak(" is not a sequence\n");
    906     exit(0);
    907   }
    908 #endif
    909 
    910   for(x = 0; i; i = CDR(i))
    911     x++;
    912   return x;
    913 }
    914 
    915    
     902    if (this && item_type(this) != (ltype)L_CONS_CELL)
     903    {
     904        lprint(this);
     905        lbreak(" is not a sequence\n");
     906        exit(0);
     907    }
     908#endif
     909
     910    for (LispObject *p = this; p; p = CDR(p))
     911        ret++;
     912    return ret;
     913}
    916914
    917915void *pairlis(void *list1, void *list2, void *list3)
    918 {   
     916{
    919917  if (item_type(list1)!=(ltype)L_CONS_CELL || item_type(list1)!=item_type(list2))
    920918    return NULL;
    921919
    922920  void *ret=NULL;
    923   long l1=list_length(list1), l2=list_length(list2);
     921  size_t l1 = ((LispList *)list1)->GetLength();
     922  size_t l2 = ((LispList *)list2)->GetLength();
     923
    924924  if (l1!=l2)
    925   {   
     925  {
    926926    lprint(list1);
    927927    lprint(list2);
     
    938938      if (!first) first=cur;
    939939      if (last)
    940         ((LispList *)last)->cdr=cur;
     940        ((LispList *)last)->cdr=(LispObject *)cur;
    941941      last=cur;
    942    
    943       LispList *cell=new_cons_cell();   
     942
     943      LispList *cell=new_cons_cell();
    944944      tmp=lcar(list1);
    945       ((LispList *)cell)->car=tmp;
     945      ((LispList *)cell)->car = (LispObject *)tmp;
    946946      tmp=lcar(list2);
    947       ((LispList *)cell)->cdr=tmp;
    948       ((LispList *)cur)->car=cell;
     947      ((LispList *)cell)->cdr = (LispObject *)tmp;
     948      ((LispList *)cur)->car = (LispObject *)cell;
    949949
    950950      list1=((LispList *)list1)->cdr;
    951951      list2=((LispList *)list2)->cdr;
    952952    }
    953     ((LispList *)cur)->cdr=list3;
     953    ((LispList *)cur)->cdr = (LispObject *)list3;
    954954    ret=first;
    955955  } else ret=NULL;
     
    11071107  p_ref r1(object), r2(list);
    11081108  LispList *c=new_cons_cell();
    1109   c->car=object;
    1110   c->cdr=list;
     1109  c->car = (LispObject *)object;
     1110  c->cdr = (LispObject *)list;
    11111111  list=c;
    11121112}
     
    11311131    c2=new_cons_cell();
    11321132    tmp=compile(s);
    1133     ((LispList *)c2)->car=tmp;
     1133    ((LispList *)c2)->car = (LispObject *)tmp;
    11341134    ((LispList *)c2)->cdr=NULL;
    1135     ((LispList *)cs)->cdr=c2;
     1135    ((LispList *)cs)->cdr = (LispObject *)c2;
    11361136    ret=cs;
    11371137  }
     
    11441144    c2=new_cons_cell();
    11451145    tmp=compile(s);
    1146     ((LispList *)c2)->car=tmp;
     1146    ((LispList *)c2)->car = (LispObject *)tmp;
    11471147    ((LispList *)c2)->cdr=NULL;
    1148     ((LispList *)cs)->cdr=c2;
     1148    ((LispList *)cs)->cdr = (LispObject *)c2;
    11491149    ret=cs;
    11501150  }  else if (n[0]==',')              // short hand for comma function
     
    11561156    c2=new_cons_cell();
    11571157    tmp=compile(s);
    1158     ((LispList *)c2)->car=tmp;
     1158    ((LispList *)c2)->car = (LispObject *)tmp;
    11591159    ((LispList *)c2)->cdr=NULL;
    1160     ((LispList *)cs)->cdr=c2;
     1160    ((LispList *)cs)->cdr = (LispObject *)c2;
    11611161    ret=cs;
    11621162  }
     
    11871187                    read_ltoken(s, n);              // skip the '.'
    11881188                    tmp=compile(s);
    1189                     ((LispList *)last)->cdr=tmp;          // link the last cdr to
     1189                    ((LispList *)last)->cdr = (LispObject *)tmp;          // link the last cdr to
    11901190                    last=NULL;
    11911191                  }
     
    11991199                  if (!first) first=cur;
    12001200                  tmp=compile(s);   
    1201                   ((LispList *)cur)->car=tmp;
     1201                  ((LispList *)cur)->car = (LispObject *)tmp;
    12021202                  if (last)
    1203                     ((LispList *)last)->cdr=cur;
     1203                    ((LispList *)last)->cdr = (LispObject *)cur;
    12041204                  last=cur;
    12051205                }
     
    12501250      p_ref r4(cs), r5(c2);
    12511251      tmp = LispSymbol::FindOrCreate("function");
    1252       ((LispList *)cs)->car=tmp;
     1252      ((LispList *)cs)->car = (LispObject *)tmp;
    12531253      c2=new_cons_cell();
    12541254      tmp=compile(s);
    1255       ((LispList *)c2)->car=tmp;
    1256       ((LispList *)cs)->cdr=c2;
     1255      ((LispList *)c2)->car = (LispObject *)tmp;
     1256      ((LispList *)cs)->cdr = (LispObject *)c2;
    12571257      ret=cs;
    12581258    }
     
    15151515        if (first) {
    15161516          tmp=new_cons_cell();
    1517           ((LispList *)cur)->cdr=tmp;
     1517          ((LispList *)cur)->cdr = (LispObject *)tmp;
    15181518          cur=tmp;
    15191519        } else
     
    15211521   
    15221522        void *val=eval(CAR(arg_list));
    1523         ((LispList *)cur)->car=val;
     1523        ((LispList *)cur)->car = (LispObject *)val;
    15241524        arg_list=lcdr(arg_list);
    15251525      }
     
    15821582    }
    15831583  }
    1584   int num_args=list_length(CDR(arg_list)), i, stop=0;
     1584  int i, stop = 0, num_args = ((LispList *)CDR(arg_list))->GetLength();
    15851585  if (!num_args) return 0;
    15861586
     
    16171617      else
    16181618      {
    1619         na_list->cdr=new_cons_cell();
     1619        na_list->cdr = (LispObject *)new_cons_cell();
    16201620                na_list=(LispList *)CDR(na_list);
    16211621      }
     
    16241624      if (arg_on[i])
    16251625      {
    1626                 na_list->car=CAR(arg_on[i]);
     1626                na_list->car = (LispObject *)CAR(arg_on[i]);
    16271627                arg_on[i]=(LispList *)CDR(arg_on[i]);
    16281628      }
     
    16321632    {
    16331633      LispList *c=new_cons_cell();
    1634       c->car=eval_function((LispSymbol *)sym, first);
     1634      c->car = (LispObject *)eval_function((LispSymbol *)sym, first);
    16351635      if (return_list)
    16361636        last_return->cdr=c;
     
    16571657  if (rtype==string_symbol)
    16581658  {
    1659     int elements=list_length(el_list);      // see how many things we need to concat
     1659    int elements = ((LispList *)el_list)->GetLength(); // see how many things we need to concat
    16601660    if (!elements) ret = LispString::Create("");
    16611661    else
     
    17581758    {
    17591759      tmp=eval(CAR(CDR(args)));
    1760       ((LispList *)last)->cdr=tmp;
     1760      ((LispList *)last)->cdr = (LispObject *)tmp;
    17611761      args=NULL;
    17621762    }
     
    17651765      cur=new_cons_cell();
    17661766      if (first)
    1767         ((LispList *)last)->cdr=cur;
     1767        ((LispList *)last)->cdr = (LispObject *)cur;
    17681768      else
    17691769            first=cur;
    17701770      last=cur;
    17711771          tmp=backquote_eval(CAR(args));
    1772           ((LispList *)cur)->car=tmp;
     1772          ((LispList *)cur)->car = (LispObject *)tmp;
    17731773       args=CDR(args);
    17741774    }
     
    17761776      {
    17771777    tmp=backquote_eval(args);
    1778     ((LispList *)last)->cdr=tmp;
     1778    ((LispList *)last)->cdr = (LispObject *)tmp;
    17791779    args=NULL;
    17801780      }
     
    18131813      {
    18141814        case L_STRING : ret = LispNumber::Create(strlen(lstring_value(v))); break;
    1815         case L_CONS_CELL : ret = LispNumber::Create(list_length(v)); break;
     1815        case L_CONS_CELL : ret = LispNumber::Create(((LispList *)v)->GetLength()); break;
    18161816        default :
    18171817        { lprint(v);
     
    18281828    cur=new_cons_cell();
    18291829    void *val=eval(CAR(arg_list));
    1830     ((LispList *) cur)->car=val;
     1830    ((LispList *) cur)->car = (LispObject *)val;
    18311831    if (last)
    1832       ((LispList *)last)->cdr=cur;
     1832      ((LispList *)last)->cdr = (LispObject *)cur;
    18331833    else first=cur;
    18341834    last=cur;
     
    18411841      p_ref r1(c);
    18421842      void *val=eval(CAR(arg_list));
    1843       ((LispList *)c)->car=val;
     1843      ((LispList *)c)->car = (LispObject *)val;
    18441844      val=eval(CAR(CDR(arg_list)));
    1845       ((LispList *)c)->cdr=val;
     1845      ((LispList *)c)->cdr = (LispObject *)val;
    18461846      ret=c;
    18471847    } break;
     
    19841984            if (!car || item_type(car)!=L_CONS_CELL)
    19851985            { lprint(car); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
    1986             ((LispList *)car)->car=set_to;
     1986            ((LispList *)car)->car = (LispObject *)set_to;
    19871987          } else if (car==cdr_symbol)
    19881988          {
     
    19901990            if (!car || item_type(car)!=L_CONS_CELL)
    19911991            { lprint(car); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
    1992             ((LispList *)car)->cdr=set_to;
     1992            ((LispList *)car)->cdr = (LispObject *)set_to;
    19931993          } else if (car==aref_symbol)
    19941994          {
     
    20512051      p_ref r1(i1);
    20522052      LispList *cs=new_cons_cell();
    2053       cs->car=i1;
    2054       cs->cdr=i2;
     2053      cs->car = (LispObject *)i1;
     2054      cs->cdr = (LispObject *)i2;
    20552055      ret=cs;
    20562056    } break;
     
    27862786                next=l1;
    27872787                while (next) { l1=next; next=lcdr(next); }
    2788                 ((LispList *)l1)->cdr=eval(CAR(arg_list));   
     2788                ((LispList *)l1)->cdr = (LispObject *)eval(CAR(arg_list));
    27892789                arg_list=CDR(arg_list);
    27902790      } while (arg_list);
     
    28372837        if (!rstart) rstart=q;
    28382838        while (r && CDR(r)) r=CDR(r);
    2839         CDR(r)=q;   
     2839        CDR(r) = (LispObject *)q;
    28402840        arg_list=CDR(arg_list);
    28412841      }
Note: See TracChangeset for help on using the changeset viewer.