Changeset 491


Ignore:
Timestamp:
Apr 17, 2011, 10:28:48 AM (6 years ago)
Author:
sam
Message:

lisp: miscellaneous work on type safety.

Location:
abuse/trunk/src
Files:
15 edited

Legend:

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

    r486 r491  
    111111    int angle=lisp_atan2(firey-playery,playerx-firex);
    112112    void *call_list=NULL;
    113     p_ref r1(call_list);
     113    PtrRef r1(call_list);
    114114    push_onto_list(new_lisp_pointer(b),call_list);
    115115    push_onto_list(LispNumber::Create(angle),call_list);
  • abuse/trunk/src/cache.cpp

    r486 r491  
    387387
    388388    void *CacheList=eval_function((LispSymbol *)cache_fun,call_with);
    389     p_ref r1(CacheList);
     389    PtrRef r1(CacheList);
    390390
    391391    if (CacheList && lcar(CacheList))
  • abuse/trunk/src/chars.cpp

    r486 r491  
    292292character_type::character_type(void *args, void *name)
    293293{
    294   p_ref r2(args);
     294  PtrRef r2(args);
    295295  int i;
    296296  ts=tv=0;
     
    324324    abil[i]=get_ability_default((ability)i);
    325325  void *field=args;
    326   p_ref r7(field);
     326  PtrRef r7(field);
    327327  for (;field;field=CDR(field))
    328328  {
    329329    void *f=CAR(CAR(field));
    330     p_ref r1(f);
     330    PtrRef r1(f);
    331331
    332332    if (f==l_abil)
    333333    {
    334334      void *l=CDR(CAR(field));
    335       p_ref r4(l);
     335      PtrRef r4(l);
    336336      for (i=0;i<TOTAL_ABILITIES;i++)
    337337      {
    338338    Cell *ab=assoc(LispSymbol::FindOrCreate(ability_names[i]),l);
    339     p_ref r5(ab);
     339    PtrRef r5(ab);
    340340    if (!NILP(ab))
    341341      abil[i]=lnumber_value(eval(lcar(lcdr(ab))));
     
    344344    {
    345345      void *l=CDR(CAR(field));
    346       p_ref r4(l);
     346      PtrRef r4(l);
    347347      for (i=0;i<TOTAL_OFUNS;i++)
    348348      {
    349349    Cell *ab=assoc(LispSymbol::FindOrCreate(ofun_names[i]),l);
    350     p_ref r5(ab);
     350    PtrRef r5(ab);
    351351    if (!NILP(ab) && lcar(lcdr(ab)))
    352352    fun_table[i]=lcar(lcdr(ab));
     
    355355    {
    356356      void *l=CDR(CAR(field));
    357       p_ref r4(l);
     357      PtrRef r4(l);
    358358      for (i=0;i<TOTAL_CFLAGS;i++)
    359359      {
    360360    Cell *ab=assoc(LispSymbol::FindOrCreate(cflag_names[i]),l);
    361     p_ref r5(ab);
     361    PtrRef r5(ab);
    362362    if (!NILP(ab) && eval(lcar(lcdr(ab))))
    363363    cflags|=(1<<i);
     
    381381    {
    382382      void *l=CDR(CAR(field));
    383       p_ref r4(l);
     383      PtrRef r4(l);
    384384      char fn[100];
    385385      strcpy(fn,lstring_value(eval(CAR(l)))); l=CDR(l);
     
    398398    {
    399399      void *mf=CDR(CAR(field));
    400       p_ref r4(mf);
     400      PtrRef r4(mf);
    401401      while (!NILP(mf))
    402402      {
     
    423423    {
    424424      void *l=CDR(CAR(field));
    425       p_ref r8(l);
     425      PtrRef r8(l);
    426426      while (l)
    427427      {
  • abuse/trunk/src/clisp.cpp

    r488 r491  
    567567void *l_caller(long number, void *args)
    568568{
    569   p_ref r1(args);
     569  PtrRef r1(args);
    570570  switch (number)
    571571  {
     
    749749
    750750      void *list=eval(CAR(args));
    751       p_ref r1(list);
     751      PtrRef r1(list);
    752752      game_object *find=current_level->find_object_in_angle(current_object->x,
    753753                            current_object->y,
     
    877877
    878878      void *ret=NULL;
    879       p_ref r1(ret);
     879      PtrRef r1(ret);
    880880      push_onto_list(LispNumber::Create(b3),ret);
    881881      push_onto_list(LispNumber::Create(b2),ret);
     
    889889      void *ret=NULL;
    890890      {
    891     p_ref r1(ret);
     891    PtrRef r1(ret);
    892892    push_onto_list(LispNumber::Create((last_demo_mbut&4)==4),ret);
    893893    push_onto_list(LispNumber::Create((last_demo_mbut&2)==2),ret);
     
    907907      void *ret=NULL;
    908908      {
    909     p_ref r1(ret);
     909    PtrRef r1(ret);
    910910    push_onto_list(LispNumber::Create(ry),ret);
    911911    push_onto_list(LispNumber::Create(rx),ret);
     
    922922      void *ret=NULL;
    923923      {
    924     p_ref r1(ret);
     924    PtrRef r1(ret);
    925925    push_onto_list(LispNumber::Create(ry),ret);
    926926    push_onto_list(LispNumber::Create(rx),ret);
     
    950950      char tmp[200];
    951951      {
    952     p_ref r1(fn);
     952    PtrRef r1(fn);
    953953    char *slash=lstring_value(eval(CAR(args)));
    954954    char *filename=lstring_value(fn);
     
    974974      void *fl=NULL,*dl=NULL,*rl=NULL;
    975975      {
    976     p_ref r1(fl),r2(dl);
     976    PtrRef r1(fl),r2(dl);
    977977   
    978978    for (i=tfiles-1;i>=0;i--) { push_onto_list(LispString::Create(files[i]),fl); free(files[i]); }
     
    10051005      long i;
    10061006      void *ret=NULL;
    1007       p_ref r1(ret);
     1007      PtrRef r1(ret);
    10081008
    10091009      if (last>=first)
     
    10331033long c_caller(long number, void *args)
    10341034{
    1035     p_ref r1(args);
     1035    PtrRef r1(args);
    10361036    switch (number)
    10371037    {
     
    13781378    {
    13791379      void *a=args;
    1380       p_ref r1(a);
     1380      PtrRef r1(a);
    13811381      int id=lnumber_value(lcar(a));
    13821382      if (id<0) return 0;
  • abuse/trunk/src/cop.cpp

    r486 r491  
    226226
    227227  void *list=NULL;
    228   p_ref r1(list);
     228  PtrRef r1(list);
    229229  push_onto_list(new_lisp_pointer(target),list);
    230230  push_onto_list(LispNumber::Create(angle),list);
     
    247247{
    248248  game_object *o=current_object;
    249   p_ref r1(args);
     249  PtrRef r1(args);
    250250  void *signal=CAR(args);  args=CDR(args);
    251251  void *ret=NULL;
     
    289289{
    290290  game_object *o=current_object;
    291   p_ref r1(args);
     291  PtrRef r1(args);
    292292  void *signal=CAR(args);  args=CDR(args);
    293293  void *ret=NULL;
     
    316316{
    317317  game_object *o=current_object;
    318   p_ref r1(args);
     318  PtrRef r1(args);
    319319  void *signal=CAR(args);  args=CDR(args);
    320320  void *ret=NULL;
     
    340340{
    341341  game_object *o=current_object;
    342   p_ref r1(args);
     342  PtrRef r1(args);
    343343  void *signal=CAR(args);  args=CDR(args);
    344344  void *ret=NULL;
     
    367367{
    368368  game_object *o=current_object;
    369   p_ref r1(args);
     369  PtrRef r1(args);
    370370  void *signal=CAR(args);  args=CDR(args);
    371371  void *ret=NULL;
     
    655655    {
    656656      void *args=NULL;
    657       p_ref r1(args);
     657      PtrRef r1(args);
    658658      view *v=o->controller();
    659659
     
    753753
    754754      void *ret=NULL;
    755       p_ref r1(ret);
     755      PtrRef r1(ret);
    756756
    757757      push_onto_list(LispNumber::Create(bot->get_tint()),ret);
  • abuse/trunk/src/endgame.cpp

    r484 r491  
    428428
    429429  void *to_be = LispSymbol::FindOrCreate("to_be_continued")->GetValue();
    430   p_ref r1(to_be);
     430  PtrRef r1(to_be);
    431431
    432432  void *mid_plot = LispSymbol::FindOrCreate("plot_middle")->GetValue();
    433   p_ref r2(mid_plot);
     433  PtrRef r2(mid_plot);
    434434
    435435  int dx=(xres+1)/2-im->width()/2,dy=(yres+1)/2-im->height()/2;
     
    486486
    487487  void *end_plot = LispSymbol::FindOrCreate("plot_end")->GetValue();
    488   p_ref r2(end_plot);
     488  PtrRef r2(end_plot);
    489489
    490490
  • abuse/trunk/src/game.cpp

    r490 r491  
    26632663
    26642664    l_user_stack.clean_up();
    2665     l_ptr_stack.clean_up();
     2665    // FIXME: this is now private in PtrRef::stack
     2666    //l_ptr_stack.clean_up();
    26662667
    26672668    sound_uninit();
  • abuse/trunk/src/lcache.cpp

    r490 r491  
    124124    while (x)
    125125    {
    126       LispList *c=new_cons_cell();
     126      LispList *c = LispList::Create();
    127127      if (first)
    128128        last->cdr=c;
  • abuse/trunk/src/level.cpp

    r490 r491  
    15091509
    15101510    void *arg_list=NULL;
    1511     p_ref r1(arg_list);
     1511    PtrRef r1(arg_list);
    15121512    push_onto_list(LispString::Create(n),arg_list);
    15131513    eval_function((LispSymbol *)l_level_loaded,arg_list);
  • abuse/trunk/src/lisp/lisp.cpp

    r490 r491  
    8282{
    8383    dprintf("Main program\n");
    84     if (max_lev==-1) max_lev=l_ptr_stack.son;
    85     else if (max_lev>=l_ptr_stack.son) max_lev=l_ptr_stack.son-1;
     84    if (max_lev==-1) max_lev=PtrRef::stack.son;
     85    else if (max_lev>=PtrRef::stack.son) max_lev=PtrRef::stack.son-1;
    8686
    8787    for (int i=0;i<max_lev;i++)
    8888    {
    8989        dprintf("%d> ", i);
    90         lprint(*l_ptr_stack.sdata[i]);
     90        lprint(*PtrRef::stack.sdata[i]);
    9191    }
    9292}
     
    140140      {
    141141                void *prog=compile(s);
    142                 p_ref r1(prog);
     142                PtrRef r1(prog);
    143143                while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
    144144                lprint(eval(prog));
     
    210210void *eval_block(void *list)
    211211{
    212   p_ref r1(list);
     212  PtrRef r1(list);
    213213  void *ret=NULL;
    214214  while (list)
     
    222222LispArray *LispArray::Create(int size, void *rest)
    223223{
    224   p_ref r11(rest);
     224  PtrRef r11(rest);
    225225  size_t s = sizeof(LispArray)
    226226           + ((size < 1 ? 1 : size) - 1) * sizeof(LispObject *);
     
    230230  LispObject **data = p->GetData();
    231231  memset(data, 0, size * sizeof(LispObject *));
    232   p_ref r1(p);
     232  PtrRef r1(p);
    233233
    234234  if (rest)
     
    349349LispUserFunction *new_lisp_user_function(void *arg_list, void *block_list)
    350350{
    351   p_ref r1(arg_list), r2(block_list);
     351  PtrRef r1(arg_list), r2(block_list);
    352352  LispUserFunction *lu=(LispUserFunction *)lmalloc(sizeof(LispUserFunction), current_space);
    353353  lu->type=L_USER_FUNCTION;
     
    452452}
    453453
    454 
    455 LispList *new_cons_cell()
    456 {
    457   LispList *c=(LispList *)lmalloc(sizeof(LispList), current_space);
    458   c->type=L_CONS_CELL;
    459   c->car=NULL;
    460   c->cdr=NULL;
    461   return c;
    462 }
    463 
     454LispList *LispList::Create()
     455{
     456    LispList *c = (LispList *)lmalloc(sizeof(LispList), current_space);
     457    c->type = L_CONS_CELL;
     458    c->car = NULL;
     459    c->cdr = NULL;
     460    return c;
     461}
    464462
    465463char *lerror(char const *loc, char const *cause)
     
    808806      current_space=PERM_SPACE;       // make sure all symbols get defined in permanant space
    809807    LispList *cs;
    810     cs=new_cons_cell();
     808    cs=LispList::Create();
    811809    s=new_lisp_symbol(name);
    812810    cs->car=s;
     
    931929  if (l1!=0)
    932930  {
    933     void *first=NULL, *last=NULL, *cur=NULL, *tmp;
    934     p_ref r1(first), r2(last), r3(cur);
     931    LispList *first = NULL, *last = NULL, *cur = NULL;
     932    LispObject *tmp;
     933    PtrRef r1(first), r2(last), r3(cur);
    935934    while (list1)
    936935    {
    937       cur=new_cons_cell();
    938       if (!first) first=cur;
     936      cur = LispList::Create();
     937      if (!first)
     938        first = cur;
    939939      if (last)
    940         ((LispList *)last)->cdr=(LispObject *)cur;
    941       last=cur;
    942 
    943       LispList *cell=new_cons_cell();
    944       tmp=lcar(list1);
    945       ((LispList *)cell)->car = (LispObject *)tmp;
    946       tmp=lcar(list2);
    947       ((LispList *)cell)->cdr = (LispObject *)tmp;
    948       ((LispList *)cur)->car = (LispObject *)cell;
    949 
    950       list1=((LispList *)list1)->cdr;
    951       list2=((LispList *)list2)->cdr;
    952     }
    953     ((LispList *)cur)->cdr = (LispObject *)list3;
     940        last->cdr = cur;
     941      last = cur;
     942
     943      LispList *cell = LispList::Create();
     944      tmp = (LispObject *)lcar(list1);
     945      cell->car = tmp;
     946      tmp = (LispObject *)lcar(list2);
     947      cell->cdr = tmp;
     948      cur->car = cell;
     949
     950      list1 = ((LispList *)list1)->cdr;
     951      list2 = ((LispList *)list2)->cdr;
     952    }
     953    cur->cdr = (LispObject *)list3;
    954954    ret=first;
    955955  } else ret=NULL;
     
    11051105void push_onto_list(void *object, void *&list)
    11061106{
    1107   p_ref r1(object), r2(list);
    1108   LispList *c=new_cons_cell();
     1107  PtrRef r1(object), r2(list);
     1108  LispList *c = LispList::Create();
    11091109  c->car = (LispObject *)object;
    11101110  c->cdr = (LispObject *)list;
     
    11251125  else if (n[0]=='\'')                    // short hand for quote function
    11261126  {
    1127     void *cs=new_cons_cell(), *c2=NULL, *tmp;
    1128     p_ref r1(cs), r2(c2);
     1127    void *cs = LispList::Create(), *c2=NULL, *tmp;
     1128    PtrRef r1(cs), r2(c2);
    11291129
    11301130    ((LispList *)cs)->car=quote_symbol;
    1131     c2=new_cons_cell();
     1131    c2 = LispList::Create();
    11321132    tmp=compile(s);
    11331133    ((LispList *)c2)->car = (LispObject *)tmp;
     
    11381138  else if (n[0]=='`')                    // short hand for backquote function
    11391139  {
    1140     void *cs=new_cons_cell(), *c2=NULL, *tmp;
    1141     p_ref r1(cs), r2(c2);
     1140    void *cs = LispList::Create(), *c2=NULL, *tmp;
     1141    PtrRef r1(cs), r2(c2);
    11421142
    11431143    ((LispList *)cs)->car=backquote_symbol;
    1144     c2=new_cons_cell();
     1144    c2 = LispList::Create();
    11451145    tmp=compile(s);
    11461146    ((LispList *)c2)->car = (LispObject *)tmp;
     
    11501150  }  else if (n[0]==',')              // short hand for comma function
    11511151  {
    1152     void *cs=new_cons_cell(), *c2=NULL, *tmp;
    1153     p_ref r1(cs), r2(c2);
     1152    void *cs = LispList::Create(), *c2=NULL, *tmp;
     1153    PtrRef r1(cs), r2(c2);
    11541154
    11551155    ((LispList *)cs)->car=comma_symbol;
    1156     c2=new_cons_cell();
     1156    c2 = LispList::Create();
    11571157    tmp=compile(s);
    11581158    ((LispList *)c2)->car = (LispObject *)tmp;
     
    11641164  {
    11651165    void *first=NULL, *cur=NULL, *last=NULL;
    1166     p_ref r1(first), r2(cur), r3(last);
     1166    PtrRef r1(first), r2(cur), r3(last);
    11671167    int done=0;
    11681168    do
     
    11951195                {       
    11961196                  void *tmp;
    1197                   cur=new_cons_cell();
    1198                   p_ref r1(cur);
     1197                  cur = LispList::Create();
     1198                  PtrRef r1(cur);
    11991199                  if (!first) first=cur;
    12001200                  tmp=compile(s);   
     
    12471247    else if (n[1]==0)                           // short hand for function
    12481248    {
    1249       void *cs=new_cons_cell(), *c2=NULL, *tmp;
    1250       p_ref r4(cs), r5(c2);
     1249      void *cs = LispList::Create(), *c2=NULL, *tmp;
     1250      PtrRef r4(cs), r5(c2);
    12511251      tmp = LispSymbol::FindOrCreate("function");
    12521252      ((LispList *)cs)->car = (LispObject *)tmp;
    1253       c2=new_cons_cell();
     1253      c2 = LispList::Create();
    12541254      tmp=compile(s);
    12551255      ((LispList *)c2)->car = (LispObject *)tmp;
     
    14391439
    14401440  void *fun=(LispSysFunction *)(((LispSymbol *)sym)->function);
    1441   p_ref ref2( fun  );
     1441  PtrRef ref2( fun  );
    14421442
    14431443  // make sure the arguments given to the function are the correct number
     
    14931493
    14941494
    1495   p_ref ref1(arg_list);
     1495  PtrRef ref1(arg_list);
    14961496  void *ret=NULL;
    14971497
     
    15101510    {
    15111511      void *first=NULL, *cur=NULL, *tmp;
    1512       p_ref r1(first), r2(cur);
     1512      PtrRef r1(first), r2(cur);
    15131513      while (arg_list)
    15141514      {
    15151515        if (first) {
    1516           tmp=new_cons_cell();
     1516          tmp = LispList::Create();
    15171517          ((LispList *)cur)->cdr = (LispObject *)tmp;
    15181518          cur=tmp;
    15191519        } else
    1520           cur=first=new_cons_cell();
     1520          cur=first = LispList::Create();
    15211521   
    15221522        void *val=eval(CAR(arg_list));
     
    15671567void *mapcar(void *arg_list)
    15681568{
    1569   p_ref ref1(arg_list);
     1569  PtrRef ref1(arg_list);
    15701570  void *sym=eval(CAR(arg_list));
    15711571  switch ((short)item_type(sym))
     
    15871587  void **arg_on=(void **)malloc(sizeof(void *)*num_args);
    15881588  LispList *list_on=(LispList *)CDR(arg_list);
    1589   long old_ptr_son=l_ptr_stack.son;
     1589  long old_ptr_son=PtrRef::stack.son;
    15901590
    15911591  for (i=0;i<num_args;i++)
    15921592  {
    15931593    arg_on[i]=(LispList *)eval(CAR(list_on));
    1594     l_ptr_stack.push(&arg_on[i]);
     1594    PtrRef::stack.push(&arg_on[i]);
    15951595
    15961596    list_on=(LispList *)CDR(list_on);
     
    16141614    {
    16151615      if (!na_list)
    1616         first=na_list=new_cons_cell();
     1616        first=na_list = LispList::Create();
    16171617      else
    16181618      {
    1619         na_list->cdr = (LispObject *)new_cons_cell();
     1619        na_list->cdr = (LispObject *)LispList::Create();
    16201620                na_list=(LispList *)CDR(na_list);
    16211621      }
     
    16311631    if (!stop)
    16321632    {
    1633       LispList *c=new_cons_cell();
     1633      LispList *c = LispList::Create();
    16341634      c->car = (LispObject *)eval_function((LispSymbol *)sym, first);
    16351635      if (return_list)
     
    16411641  }
    16421642  while (!stop);
    1643   l_ptr_stack.son=old_ptr_son;
     1643  PtrRef::stack.son=old_ptr_son;
    16441644
    16451645  free(arg_on);
     
    16501650{
    16511651  void *el_list=CDR(prog_list);
    1652   p_ref ref1(prog_list), ref2(el_list);
     1652  PtrRef ref1(prog_list), ref2(el_list);
    16531653  void *ret=NULL;
    16541654  void *rtype=eval(CAR(prog_list));
     
    16621662    {
    16631663      void **str_eval=(void **)malloc(elements*sizeof(void *));
    1664       int i, old_ptr_stack_start=l_ptr_stack.son;
     1664      int i, old_ptr_stack_start=PtrRef::stack.son;
    16651665
    16661666      // evalaute all the strings and count their lengths
     
    16681668      {
    16691669        str_eval[i]=eval(CAR(el_list));
    1670     l_ptr_stack.push(&str_eval[i]);
     1670    PtrRef::stack.push(&str_eval[i]);
    16711671
    16721672    switch ((short)item_type(str_eval[i]))
     
    17241724      }
    17251725      free(str_eval);
    1726       l_ptr_stack.son=old_ptr_stack_start;   // restore pointer GC stack
     1726      PtrRef::stack.son=old_ptr_stack_start;   // restore pointer GC stack
    17271727      *s=0;
    17281728      ret=st;
     
    17501750  {
    17511751    void *first=NULL, *last=NULL, *cur=NULL, *tmp;
    1752     p_ref ref1(first), ref2(last), ref3(cur), ref4(args);
     1752    PtrRef ref1(first), ref2(last), ref3(cur), ref4(args);
    17531753    while (args)
    17541754    {
     
    17631763    else
    17641764    {
    1765       cur=new_cons_cell();
     1765      cur = LispList::Create();
    17661766      if (first)
    17671767        ((LispList *)last)->cdr = (LispObject *)cur;
     
    17891789void *eval_sys_function(LispSysFunction *fun, void *arg_list)
    17901790{
    1791   p_ref ref1(arg_list);
     1791  PtrRef ref1(arg_list);
    17921792  void *ret=NULL;
    17931793  switch (fun->fun_number)
     
    18231823    {
    18241824      void *cur=NULL, *last=NULL, *first=NULL;
    1825       p_ref r1(cur), r2(first), r3(last);
     1825      PtrRef r1(cur), r2(first), r3(last);
    18261826      while (arg_list)
    18271827      {
    1828     cur=new_cons_cell();
     1828    cur = LispList::Create();
    18291829    void *val=eval(CAR(arg_list));
    18301830    ((LispList *) cur)->car = (LispObject *)val;
     
    18381838    } break;
    18391839    case SYS_FUNC_CONS:
    1840     { void *c=new_cons_cell();
    1841       p_ref r1(c);
     1840    { void *c = LispList::Create();
     1841      PtrRef r1(c);
    18421842      void *val=eval(CAR(arg_list));
    18431843      ((LispList *)c)->car = (LispObject *)val;
     
    18761876      long sum;
    18771877      void *first=eval(CAR(arg_list));
    1878       p_ref r1(first);
     1878      PtrRef r1(first);
    18791879      if (arg_list && item_type(first)==L_FIXED_POINT)
    18801880      {
     
    19061906      {
    19071907    void *i=eval(CAR(arg_list));
    1908     p_ref r1(i);
     1908    PtrRef r1(i);
    19091909    if (item_type(i)!=L_NUMBER)
    19101910    {
     
    19491949    {
    19501950      void *set_to=eval(CAR(CDR(arg_list))), *i=NULL;
    1951       p_ref r1(set_to), r2(i);
     1951      PtrRef r1(set_to), r2(i);
    19521952      i=CAR(arg_list);
    19531953
     
    19951995#endif
    19961996            LispArray *a = (LispArray *)eval(CAR(CDR(i)));
    1997             p_ref r1(a);
     1997            PtrRef r1(a);
    19981998#ifdef TYPE_CHECKING
    19991999            if (item_type(a) != L_1D_ARRAY)
     
    20372037    {
    20382038      void *item=eval(CAR(arg_list));
    2039       p_ref r1(item);
     2039      PtrRef r1(item);
    20402040      void *list=(LispList *)eval(CAR(CDR(arg_list)));
    2041       p_ref r2(list);
     2041      PtrRef r2(list);
    20422042      ret=assoc(item, (LispList *)list);
    20432043    } break;
     
    20492049    {
    20502050      void *i1=eval(CAR(arg_list)), *i2=eval(CAR(CDR(arg_list)));
    2051       p_ref r1(i1);
    2052       LispList *cs=new_cons_cell();
     2051      PtrRef r1(i1);
     2052      LispList *cs = LispList::Create();
    20532053      cs->car = (LispObject *)i1;
    20542054      cs->cdr = (LispObject *)i2;
     
    20572057
    20582058    case SYS_FUNC_PAIRLIS:
    2059     {   
     2059    {
    20602060      l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    20612061      l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list);
     
    20702070      void *var_list=CAR(arg_list),
    20712071           *block_list=CDR(arg_list);
    2072       p_ref r1(block_list), r2(var_list);
     2072      PtrRef r1(block_list), r2(var_list);
    20732073      long stack_start=l_user_stack.son;
    20742074
     
    21452145    {
    21462146      void *l=arg_list;
    2147       p_ref r1(l);
     2147      PtrRef r1(l);
    21482148      ret=true_symbol;
    21492149      while (l)
     
    21592159    {
    21602160      void *l=arg_list;
    2161       p_ref r1(l);
     2161      PtrRef r1(l);
    21622162      ret=NULL;
    21632163      while (l)
     
    21782178    {
    21792179      void *i=eval(CAR(arg_list));
    2180       p_ref r1(i);
     2180      PtrRef r1(i);
    21812181      ret=NULL;
    21822182      switch (item_type(i))
     
    21972197    {
    21982198      void *i=eval(CAR(arg_list));
    2199       p_ref r1(i);
     2199      PtrRef r1(i);
    22002200      if (item_type(i)!=L_NUMBER)
    22012201      {
     
    22092209    {
    22102210      void *block_list=CAR(arg_list);
    2211       p_ref r1(block_list);
     2211      PtrRef r1(block_list);
    22122212      if (!block_list) ret=NULL;
    22132213      else
     
    22262226      void *selector=eval(CAR(arg_list));
    22272227      void *sel=CDR(arg_list);
    2228       p_ref r1(selector), r2(sel);
     2228      PtrRef r1(selector), r2(sel);
    22292229      while (sel)
    22302230      {
     
    23392339            void *fn = eval( CAR( arg_list ) );
    23402340            char *st = lstring_value( fn );
    2341             p_ref r1( fn );
     2341            PtrRef r1( fn );
    23422342            bFILE *fp;
    23432343            if( fun->fun_number == SYS_FUNC_LOCAL_LOAD )
     
    23912391            #endif
    23922392                void *compiled_form=NULL;
    2393                 p_ref r11(compiled_form);
     2393                PtrRef r11(compiled_form);
    23942394                while (!end_of_program(cs))  // see if there is anything left to compile and run
    23952395                {
     
    24612461      {
    24622462    void *sym=eval(CAR(arg_list));
    2463     p_ref r1(sym);
     2463    PtrRef r1(sym);
    24642464    switch (item_type(sym))
    24652465    {
     
    24692469      {
    24702470        void *s=eval(CAR(sym));
    2471         p_ref r1(s);
     2471        PtrRef r1(s);
    24722472#ifdef TYPE_CHECKING
    24732473        if (item_type(s)!=L_SYMBOL)
     
    25262526      LispSymbol *bind_var = (LispSymbol *)CAR(arg_list);
    25272527      arg_list = CDR(arg_list);
    2528       p_ref r1(bind_var);
     2528      PtrRef r1(bind_var);
    25292529      if (item_type(bind_var)!=L_SYMBOL)
    25302530      { lbreak("expecting for iterator to be a symbol\n"); exit(1); }
     
    25352535
    25362536      void *ilist=eval(CAR(arg_list)); arg_list=CDR(arg_list);
    2537       p_ref r2(ilist);
     2537      PtrRef r2(ilist);
    25382538
    25392539      if (CAR(arg_list)!=do_symbol)
     
    25422542
    25432543      void *block=NULL, *ret=NULL;
    2544       p_ref r3(block);
     2544      PtrRef r3(block);
    25452545      l_user_stack.push(bind_var->GetValue());  // save old symbol value
    25462546      while (ilist)
     
    25582558      bFILE *old_file=current_print_file;
    25592559      void *str1=eval(CAR(arg_list));
    2560       p_ref r1(str1);
     2560      PtrRef r1(str1);
    25612561      void *str2=eval(CAR(CDR(arg_list)));
    25622562
     
    26602660    {
    26612661      void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
    2662       p_ref r1(arg1);       // protect this refrence
     2662      PtrRef r1(arg1);       // protect this refrence
    26632663      char *haystack=lstring_value(eval(CAR(arg_list)));
    26642664      char *needle=lstring_value(arg1);
     
    26722672    {
    26732673      void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
    2674       p_ref r1(arg1);       // protect this refrence
     2674      PtrRef r1(arg1);       // protect this refrence
    26752675      long x=lnumber_value(eval(CAR(arg_list)));
    26762676      char *st=lstring_value(arg1);
     
    26922692    {
    26932693      void *init_var=CAR(arg_list);
    2694       p_ref r1(init_var);
     2694      PtrRef r1(init_var);
    26952695      int i, ustack_start=l_user_stack.son;      // restore stack at end
    26962696      LispSymbol *sym = NULL;
    2697       p_ref r2(sym);
     2697      PtrRef r2(sym);
    26982698
    26992699      // check to make sure iter vars are symbol and push old values
     
    27702770    {
    27712771      void *l1=eval(CAR(arg_list)); arg_list=CDR(arg_list);
    2772       p_ref r1(l1);
     2772      PtrRef r1(l1);
    27732773      void *first=l1, *next;
    2774       p_ref r2(first);
     2774      PtrRef r2(first);
    27752775
    27762776      if (!l1)
     
    28162816      long x2=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list);
    28172817      void *st=eval(CAR(arg_list));
    2818       p_ref r1(st);
     2818      PtrRef r1(st);
    28192819
    28202820      if (x1 < 0 || x1 > x2 || (unsigned)x2 >= strlen(lstring_value(st)))
     
    28312831    {
    28322832      void *r=NULL, *rstart=NULL;
    2833       p_ref r1(r), r2(rstart);
     2833      PtrRef r1(r), r2(rstart);
    28342834      while (arg_list)
    28352835      {
     
    28702870{
    28712871  void *ret=NULL;
    2872   p_ref ref1(ret);
     2872  PtrRef ref1(ret);
    28732873
    28742874#ifdef TYPE_CHECKING
     
    28982898  void *fun_arg_list=cache.lblock(fun->alist);
    28992899  void *block_list=cache.lblock(fun->blist);
    2900   p_ref r9(block_list), r10(fun_arg_list);
     2900  PtrRef r9(block_list), r10(fun_arg_list);
    29012901#else
    29022902  void *fun_arg_list=fun->arg_list;
    29032903  void *block_list=fun->block_list;
    2904   p_ref r9(block_list), r10(fun_arg_list);
     2904  PtrRef r9(block_list), r10(fun_arg_list);
    29052905#endif
    29062906
     
    29122912  // first push all of the old symbol values
    29132913  void *f_arg=fun_arg_list;
    2914   p_ref r18(f_arg);
    2915   p_ref r19(arg_list);
     2914  PtrRef r18(f_arg);
     2915  PtrRef r19(arg_list);
    29162916  for (;f_arg;f_arg=CDR(f_arg))
    29172917  {
     
    29792979
    29802980  void *ret=NULL;
    2981   p_ref ref1(prog);
     2981  PtrRef ref1(prog);
    29822982
    29832983
     
    29912991          space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]),
    29922992          space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
    2993           l_ptr_stack.son);
     2993          PtrRef::stack.son);
    29942994      lprint(prog);
    29952995
     
    30363036          space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]),
    30373037          space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]),
    3038           l_ptr_stack.son);
     3038          PtrRef::stack.son);
    30393039    lprint(ret);
    30403040    dprintf("\n");
  • abuse/trunk/src/lisp/lisp.h

    r490 r491  
    5757struct LispList : LispObject
    5858{
     59    static LispList *Create();
     60
    5961    size_t GetLength();
    6062
     
    7173struct LispRedirect : LispObject
    7274{
    73     void *new_reference;
     75    LispObject *new_reference;
    7476};
    7577
     
    185187LispSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number);
    186188int read_ltoken(char *&s, char *buffer);
    187 LispList *new_cons_cell();
    188189void print_trace_stack(int max_levels);
    189190
  • abuse/trunk/src/lisp/lisp_gc.cpp

    r490 r491  
    1414
    1515#include "lisp.h"
     16#include "lisp_gc.h"
    1617#ifdef NO_LIBS
    1718#include "fakelib.h"
     
    3435grow_stack<void> l_user_stack(150);
    3536// Stack of user pointers
    36 grow_stack<void *> l_ptr_stack(1500);
     37grow_stack<void *> PtrRef::stack(1500);
    3738
    3839size_t reg_ptr_total = 0;
     
    8384}
    8485
    85 static void *collect_object(void *x);
    86 static void *collect_array(void *x)
    87 {
    88     long s = ((LispArray *)x)->size;
     86static LispObject *CollectObject(LispObject *x);
     87
     88static LispArray *CollectArray(LispArray *x)
     89{
     90    size_t s = x->size;
    8991    LispArray *a = LispArray::Create(s, NULL);
    90     LispObject **src = ((LispArray *)x)->GetData();
     92    LispObject **src = x->GetData();
    9193    LispObject **dst = a->GetData();
    92     for (int i = 0; i < s; i++)
    93         dst[i] = (LispObject *)collect_object(src[i]);
     94    for (size_t i = 0; i < s; i++)
     95        dst[i] = CollectObject(src[i]);
    9496
    9597    return a;
    9698}
    9799
    98 inline void *collect_cons_cell(void *x)
    99 {
    100   LispList *last = NULL, *first = NULL;
    101   if (!x) return x;
    102   for (; x && item_type(x) == L_CONS_CELL; )
    103   {
    104     LispList *p = new_cons_cell();
    105     void *old_car = ((LispList *)x)->car;
    106     void *old_cdr = ((LispList *)x)->cdr;
    107     void *old_x = x;
    108     x = CDR(x);
    109     ((LispRedirect *)old_x)->type = L_COLLECTED_OBJECT;
    110     ((LispRedirect *)old_x)->new_reference = p;
    111 
    112     p->car = (LispObject *)collect_object(old_car);
    113     p->cdr = (LispObject *)collect_object(old_cdr);
    114 
    115     if (last) last->cdr = p;
    116     else first = p;
    117     last = p;
    118   }
    119   if (x)
    120     last->cdr = (LispObject *)collect_object(x);
    121   return first;                    // we already set the collection pointers
    122 }
    123 
    124 static void *collect_object(void *x)
    125 {
    126   void *ret = x;
     100inline LispList *CollectList(LispList *x)
     101{
     102    LispList *last = NULL, *first = NULL;
     103
     104    for (; x && item_type(x) == L_CONS_CELL; )
     105    {
     106        LispList *p = LispList::Create();
     107        LispObject *old_car = x->car;
     108        LispObject *old_cdr = x->cdr;
     109        LispObject *old_x = x;
     110        x = (LispList *)CDR(x);
     111        ((LispRedirect *)old_x)->type = L_COLLECTED_OBJECT;
     112        ((LispRedirect *)old_x)->new_reference = p;
     113
     114        p->car = CollectObject(old_car);
     115        p->cdr = CollectObject(old_cdr);
     116
     117        if (last)
     118            last->cdr = p;
     119        else
     120            first = p;
     121        last = p;
     122    }
     123    if (x)
     124        last->cdr = CollectObject(x);
     125    return first; // we already set the collection pointers
     126}
     127
     128static LispObject *CollectObject(LispObject *x)
     129{
     130  LispObject *ret = x;
    127131
    128132  if (((uint8_t *)x) >= cstart && ((uint8_t *)x) < cend)
     
    149153#else
    150154        {
    151           void *arg = collect_object(((LispUserFunction *)x)->arg_list);
    152           void *block = collect_object(((LispUserFunction *)x)->block_list);
     155          LispObject *arg = CollectObject(((LispUserFunction *)x)->arg_list);
     156          LispObject *block = CollectObject(((LispUserFunction *)x)->block_list);
    153157          ret = new_lisp_user_function(arg, block);
    154158        }
     
    180184        break;
    181185      case L_1D_ARRAY:
    182         ret = collect_array(x);
     186        ret = CollectArray((LispArray *)x);
    183187        break;
    184188      case L_FIXED_POINT:
     
    186190        break;
    187191      case L_CONS_CELL:
    188         ret = collect_cons_cell((LispList *)x);
     192        ret = CollectList((LispList *)x);
    189193        break;
    190194      case L_OBJECT_VAR:
     
    209213    {
    210214      for (; x && item_type(x) == L_CONS_CELL; x = CDR(x))
    211         ((LispList *)x)->car = (LispObject *)collect_object(((LispList *)x)->car);
     215        ((LispList *)x)->car = CollectObject(((LispList *)x)->car);
    212216      if (x)
    213         ((LispList *)x)->cdr = (LispObject *)collect_object(((LispList *)x)->cdr);
     217        ((LispList *)x)->cdr = CollectObject(((LispList *)x)->cdr);
    214218    }
    215219  }
     
    222226  if (root)
    223227  {
    224     root->value = (LispObject *)collect_object(root->value);
    225     root->function = (LispObject *)collect_object(root->function);
    226     root->name = (LispString *)collect_object(root->name);
     228    root->value = CollectObject(root->value);
     229    root->function = CollectObject(root->function);
     230    root->name = (LispString *)CollectObject(root->name);
    227231    collect_symbols(root->left);
    228232    collect_symbols(root->right);
     
    236240  void **d = l_user_stack.sdata;
    237241  for (int i = 0; i < t; i++, d++)
    238     *d = collect_object(*d);
    239 
    240   t = l_ptr_stack.son;
    241   void ***d2 = l_ptr_stack.sdata;
     242    *d = CollectObject((LispObject *)*d);
     243
     244  t = PtrRef::stack.son;
     245  void ***d2 = PtrRef::stack.sdata;
    242246  for (int i = 0; i < t; i++, d2++)
    243247  {
    244248    void **ptr = *d2;
    245     *ptr = collect_object(*ptr);
     249    *ptr = CollectObject((LispObject *)*ptr);
    246250  }
    247251
     
    250254  {
    251255    void **ptr = *d2;
    252     *ptr = collect_object(*ptr);
     256    *ptr = CollectObject((LispObject *)*ptr);
    253257  }
    254258}
  • abuse/trunk/src/lisp/lisp_gc.h

    r484 r491  
    1313
    1414extern grow_stack<void> l_user_stack;       // stack user progs can push data and have it GCed
    15 extern grow_stack<void *>l_ptr_stack;      // stack of user pointers, user pointers get remapped on GC
    1615
    1716void collect_space(int which_space); // should be tmp or permenant
     
    2019void unregister_pointer(void *&addr);
    2120
    22 class p_ref {
    23   public :
    24   p_ref(void *&ref) { l_ptr_stack.push(&ref); }
    25   p_ref(LispObject *&ref) { l_ptr_stack.push((void **)&ref); }
    26   p_ref(LispArray *&ref) { l_ptr_stack.push((void **)&ref); }
    27   p_ref(LispSymbol *&ref) { l_ptr_stack.push((void **)&ref); }
    28   ~p_ref() { l_ptr_stack.pop(1); }
    29 } ;
     21// This pointer reference stack lists all pointers to temporary lisp
     22// objects. This allows the pointers to be automatically modified if an
     23// object allocation triggers a garbage collection.
     24class PtrRef
     25{
     26public:
     27    template<typename T> inline PtrRef(T *&ref)
     28    {
     29        stack.push((void **)&ref);
     30    }
    3031
     32    inline ~PtrRef()
     33    {
     34        stack.pop(1);
     35    }
     36
     37    // stack of user pointers, user pointers get remapped on GC
     38    static grow_stack<void *>stack;
     39};
    3140
    3241#endif
     42
  • abuse/trunk/src/lisp/lisp_opt.cpp

    r490 r491  
    3232{
    3333  void *return_val=list;
    34   p_ref r1(list);
     34  PtrRef r1(list);
    3535  if (list)
    3636  {
     
    3838    {
    3939      void *eval1=lcar(lcdr(lcdr(list)));
    40       p_ref r2(eval1);
     40      PtrRef r2(eval1);
    4141      void *eval2=lcar(lcdr(lcdr(lcdr(list))));
    42       p_ref r3(eval2);
     42      PtrRef r3(eval2);
    4343
    4444      void *ret=NULL;
    45       p_ref r1(ret);
     45      PtrRef r4(ret);
    4646      if (lcar(list)==eq_symbol && (lcar(lcdr(list))==zero_symbol))  //  simplify (eq 0 x) -> (eq0 x)
    4747      {
  • abuse/trunk/src/objects.cpp

    r490 r491  
    483483  if (d)
    484484  {
    485     void    *am, *frm, *hx, *hy, *px, *py;
    486     game_object *o=current_object;
    487     current_object=this;
    488 
    489     void *m=mark_heap(TMP_SPACE);
    490 
    491     am=new_cons_cell();
    492     l_ptr_stack.push(&am);
    493 
    494     ((LispList *)am)->car=LispNumber::Create(amount);
    495 
    496     frm=new_cons_cell();
    497     l_ptr_stack.push(&frm);
    498 
    499     ((LispList *)frm)->car=new_lisp_pointer(from);
    500 
    501     hx=new_cons_cell();
    502     l_ptr_stack.push(&hx);
    503 
    504     ((LispList *)hx)->car=LispNumber::Create(hitx);
    505 
    506     hy=new_cons_cell();
    507     l_ptr_stack.push(&hy);
    508     ((LispList *)hy)->car=LispNumber::Create(hity);
    509 
    510     px=new_cons_cell();
    511     l_ptr_stack.push(&px);
    512     ((LispList *)px)->car=LispNumber::Create(push_xvel);
    513 
    514     py=new_cons_cell();
    515     l_ptr_stack.push(&py);
    516     ((LispList *)py)->car=LispNumber::Create(push_yvel);
    517 
    518 
    519     ((LispList *)am)->cdr = (LispObject *)frm;
    520     ((LispList *)frm)->cdr = (LispObject *)hx;
    521     ((LispList *)hx)->cdr = (LispObject *)hy;
    522     ((LispList *)hy)->cdr = (LispObject *)px;
    523     ((LispList *)px)->cdr = (LispObject *)py;
    524 
    525     time_marker *prof1=NULL;
     485    LispList *am, *frm, *hx, *hy, *px, *py;
     486    game_object *o = current_object;
     487    current_object = this;
     488
     489    void *m = mark_heap(TMP_SPACE);
     490
     491    am = LispList::Create();
     492    PtrRef r1(am);
     493    am->car = LispNumber::Create(amount);
     494
     495    frm = LispList::Create();
     496    PtrRef r2(frm);
     497    frm->car = new_lisp_pointer(from);
     498
     499    hx = LispList::Create();
     500    PtrRef r3(hx);
     501    hx->car = LispNumber::Create(hitx);
     502
     503    hy = LispList::Create();
     504    PtrRef r4(hy);
     505    hy->car = LispNumber::Create(hity);
     506
     507    px = LispList::Create();
     508    PtrRef r5(px);
     509    px->car = LispNumber::Create(push_xvel);
     510
     511    py = LispList::Create();
     512    PtrRef r6(py);
     513    py->car = LispNumber::Create(push_yvel);
     514
     515    px->cdr = py;
     516    hy->cdr = px;
     517    hx->cdr = hy;
     518    frm->cdr = hx;
     519    am->cdr = frm;
     520
     521    time_marker *prof1 = NULL;
    526522    if (profiling())
    527       prof1=new time_marker;
    528 
    529     eval_user_fun((LispSymbol *)d,am);
     523      prof1 = new time_marker;
     524
     525    eval_user_fun((LispSymbol *)d, am);
    530526    if (profiling())
    531527    {
    532528      time_marker now;
    533       profile_add_time(this->otype,now.diff_time(prof1));
     529      profile_add_time(this->otype, now.diff_time(prof1));
    534530      delete prof1;
    535531    }
    536532
    537 
    538     l_ptr_stack.pop(6);
    539 
    540     restore_heap(m,TMP_SPACE);
    541 
    542     current_object=o;
     533    restore_heap(m, TMP_SPACE);
     534
     535    current_object = o;
    543536  } else damage_fun(amount,from,hitx,hity,push_xvel,push_yvel);
    544537#ifdef SCADALISP
     
    902895
    903896      void *rlist=NULL;   // return list
    904       p_ref r1(rlist);
     897      PtrRef r1(rlist);
    905898
    906899      if (hit_object)
     
    12141207  if (figures[otype]->get_fun(OFUN_MOVER))      // is a lisp move function defined?
    12151208  {
    1216     void *lcx,*lcy,*lb;
     1209    LispList *lcx, *lcy, *lb;
    12171210
    12181211    game_object *o=current_object;
    12191212    current_object=this;
    12201213
    1221 
    12221214    // make a list of the parameters, and call the lisp function
    1223     lcx=new_cons_cell();
    1224     l_ptr_stack.push(&lcx);
    1225     ((LispList *)lcx)->car=LispNumber::Create(cx);
    1226 
    1227     lcy=new_cons_cell();
    1228     l_ptr_stack.push(&lcy);
    1229     ((LispList *)lcy)->car=LispNumber::Create(cy);
    1230 
    1231     lb=new_cons_cell();
    1232     l_ptr_stack.push(&lb);
    1233     ((LispList *)lb)->car=LispNumber::Create(button);
    1234 
    1235 
    1236     ((LispList *)lcx)->cdr = (LispObject *)lcy;
    1237     ((LispList *)lcy)->cdr = (LispObject *)lb;
    1238 
    1239     void *m=mark_heap(TMP_SPACE);
    1240 
    1241     time_marker *prof1=NULL;
     1215    lcx = LispList::Create();
     1216    PtrRef r1(lcx);
     1217    lcx->car = LispNumber::Create(cx);
     1218
     1219    lcy = LispList::Create();
     1220    PtrRef r2(lcy);
     1221    lcy->car = LispNumber::Create(cy);
     1222
     1223    lb = LispList::Create();
     1224    PtrRef r3(lb);
     1225    lb->car = LispNumber::Create(button);
     1226
     1227    lcx->cdr = lcy;
     1228    lcy->cdr = lb;
     1229
     1230    void *m = mark_heap(TMP_SPACE);
     1231
     1232    time_marker *prof1 = NULL;
    12421233    if (profiling())
    12431234      prof1=new time_marker;
     
    12541245    restore_heap(m,TMP_SPACE);
    12551246
    1256     l_ptr_stack.pop(3);
    12571247    if (item_type(r)!=L_NUMBER)
    12581248    {
    12591249      lprint(r);
    1260       lbreak("Object %s did not return a number from it's mover function!\n"
    1261          "It should return a number to indicate it's blocked status to the\n"
    1262          "ai function.",object_names[otype]);   
    1263     }
    1264     ret|=lnumber_value(r);
    1265     current_object=o;
    1266   }
    1267   else ret|=mover(cx,cy,button);
     1250      lbreak("Object %s did not return a number from its mover function!\n"
     1251         "It should return a number to indicate its blocked status to the\n"
     1252         "ai function.", object_names[otype]);
     1253    }
     1254    ret |= lnumber_value(r);
     1255    current_object = o;
     1256  }
     1257  else ret |= mover(cx, cy, button);
    12681258
    12691259  return ret;
Note: See TracChangeset for help on using the changeset viewer.