Changeset 491
- Timestamp:
- Apr 17, 2011, 10:28:48 AM (11 years ago)
- Location:
- abuse/trunk/src
- Files:
-
- 15 edited
Legend:
- Unmodified
- Added
- Removed
-
abuse/trunk/src/ant.cpp
r486 r491 111 111 int angle=lisp_atan2(firey-playery,playerx-firex); 112 112 void *call_list=NULL; 113 p_ref r1(call_list);113 PtrRef r1(call_list); 114 114 push_onto_list(new_lisp_pointer(b),call_list); 115 115 push_onto_list(LispNumber::Create(angle),call_list); -
abuse/trunk/src/cache.cpp
r486 r491 387 387 388 388 void *CacheList=eval_function((LispSymbol *)cache_fun,call_with); 389 p_ref r1(CacheList);389 PtrRef r1(CacheList); 390 390 391 391 if (CacheList && lcar(CacheList)) -
abuse/trunk/src/chars.cpp
r486 r491 292 292 character_type::character_type(void *args, void *name) 293 293 { 294 p_ref r2(args);294 PtrRef r2(args); 295 295 int i; 296 296 ts=tv=0; … … 324 324 abil[i]=get_ability_default((ability)i); 325 325 void *field=args; 326 p_ref r7(field);326 PtrRef r7(field); 327 327 for (;field;field=CDR(field)) 328 328 { 329 329 void *f=CAR(CAR(field)); 330 p_ref r1(f);330 PtrRef r1(f); 331 331 332 332 if (f==l_abil) 333 333 { 334 334 void *l=CDR(CAR(field)); 335 p_ref r4(l);335 PtrRef r4(l); 336 336 for (i=0;i<TOTAL_ABILITIES;i++) 337 337 { 338 338 Cell *ab=assoc(LispSymbol::FindOrCreate(ability_names[i]),l); 339 p_ref r5(ab);339 PtrRef r5(ab); 340 340 if (!NILP(ab)) 341 341 abil[i]=lnumber_value(eval(lcar(lcdr(ab)))); … … 344 344 { 345 345 void *l=CDR(CAR(field)); 346 p_ref r4(l);346 PtrRef r4(l); 347 347 for (i=0;i<TOTAL_OFUNS;i++) 348 348 { 349 349 Cell *ab=assoc(LispSymbol::FindOrCreate(ofun_names[i]),l); 350 p_ref r5(ab);350 PtrRef r5(ab); 351 351 if (!NILP(ab) && lcar(lcdr(ab))) 352 352 fun_table[i]=lcar(lcdr(ab)); … … 355 355 { 356 356 void *l=CDR(CAR(field)); 357 p_ref r4(l);357 PtrRef r4(l); 358 358 for (i=0;i<TOTAL_CFLAGS;i++) 359 359 { 360 360 Cell *ab=assoc(LispSymbol::FindOrCreate(cflag_names[i]),l); 361 p_ref r5(ab);361 PtrRef r5(ab); 362 362 if (!NILP(ab) && eval(lcar(lcdr(ab)))) 363 363 cflags|=(1<<i); … … 381 381 { 382 382 void *l=CDR(CAR(field)); 383 p_ref r4(l);383 PtrRef r4(l); 384 384 char fn[100]; 385 385 strcpy(fn,lstring_value(eval(CAR(l)))); l=CDR(l); … … 398 398 { 399 399 void *mf=CDR(CAR(field)); 400 p_ref r4(mf);400 PtrRef r4(mf); 401 401 while (!NILP(mf)) 402 402 { … … 423 423 { 424 424 void *l=CDR(CAR(field)); 425 p_ref r8(l);425 PtrRef r8(l); 426 426 while (l) 427 427 { -
abuse/trunk/src/clisp.cpp
r488 r491 567 567 void *l_caller(long number, void *args) 568 568 { 569 p_ref r1(args);569 PtrRef r1(args); 570 570 switch (number) 571 571 { … … 749 749 750 750 void *list=eval(CAR(args)); 751 p_ref r1(list);751 PtrRef r1(list); 752 752 game_object *find=current_level->find_object_in_angle(current_object->x, 753 753 current_object->y, … … 877 877 878 878 void *ret=NULL; 879 p_ref r1(ret);879 PtrRef r1(ret); 880 880 push_onto_list(LispNumber::Create(b3),ret); 881 881 push_onto_list(LispNumber::Create(b2),ret); … … 889 889 void *ret=NULL; 890 890 { 891 p_ref r1(ret);891 PtrRef r1(ret); 892 892 push_onto_list(LispNumber::Create((last_demo_mbut&4)==4),ret); 893 893 push_onto_list(LispNumber::Create((last_demo_mbut&2)==2),ret); … … 907 907 void *ret=NULL; 908 908 { 909 p_ref r1(ret);909 PtrRef r1(ret); 910 910 push_onto_list(LispNumber::Create(ry),ret); 911 911 push_onto_list(LispNumber::Create(rx),ret); … … 922 922 void *ret=NULL; 923 923 { 924 p_ref r1(ret);924 PtrRef r1(ret); 925 925 push_onto_list(LispNumber::Create(ry),ret); 926 926 push_onto_list(LispNumber::Create(rx),ret); … … 950 950 char tmp[200]; 951 951 { 952 p_ref r1(fn);952 PtrRef r1(fn); 953 953 char *slash=lstring_value(eval(CAR(args))); 954 954 char *filename=lstring_value(fn); … … 974 974 void *fl=NULL,*dl=NULL,*rl=NULL; 975 975 { 976 p_ref r1(fl),r2(dl);976 PtrRef r1(fl),r2(dl); 977 977 978 978 for (i=tfiles-1;i>=0;i--) { push_onto_list(LispString::Create(files[i]),fl); free(files[i]); } … … 1005 1005 long i; 1006 1006 void *ret=NULL; 1007 p_ref r1(ret);1007 PtrRef r1(ret); 1008 1008 1009 1009 if (last>=first) … … 1033 1033 long c_caller(long number, void *args) 1034 1034 { 1035 p_ref r1(args);1035 PtrRef r1(args); 1036 1036 switch (number) 1037 1037 { … … 1378 1378 { 1379 1379 void *a=args; 1380 p_ref r1(a);1380 PtrRef r1(a); 1381 1381 int id=lnumber_value(lcar(a)); 1382 1382 if (id<0) return 0; -
abuse/trunk/src/cop.cpp
r486 r491 226 226 227 227 void *list=NULL; 228 p_ref r1(list);228 PtrRef r1(list); 229 229 push_onto_list(new_lisp_pointer(target),list); 230 230 push_onto_list(LispNumber::Create(angle),list); … … 247 247 { 248 248 game_object *o=current_object; 249 p_ref r1(args);249 PtrRef r1(args); 250 250 void *signal=CAR(args); args=CDR(args); 251 251 void *ret=NULL; … … 289 289 { 290 290 game_object *o=current_object; 291 p_ref r1(args);291 PtrRef r1(args); 292 292 void *signal=CAR(args); args=CDR(args); 293 293 void *ret=NULL; … … 316 316 { 317 317 game_object *o=current_object; 318 p_ref r1(args);318 PtrRef r1(args); 319 319 void *signal=CAR(args); args=CDR(args); 320 320 void *ret=NULL; … … 340 340 { 341 341 game_object *o=current_object; 342 p_ref r1(args);342 PtrRef r1(args); 343 343 void *signal=CAR(args); args=CDR(args); 344 344 void *ret=NULL; … … 367 367 { 368 368 game_object *o=current_object; 369 p_ref r1(args);369 PtrRef r1(args); 370 370 void *signal=CAR(args); args=CDR(args); 371 371 void *ret=NULL; … … 655 655 { 656 656 void *args=NULL; 657 p_ref r1(args);657 PtrRef r1(args); 658 658 view *v=o->controller(); 659 659 … … 753 753 754 754 void *ret=NULL; 755 p_ref r1(ret);755 PtrRef r1(ret); 756 756 757 757 push_onto_list(LispNumber::Create(bot->get_tint()),ret); -
abuse/trunk/src/endgame.cpp
r484 r491 428 428 429 429 void *to_be = LispSymbol::FindOrCreate("to_be_continued")->GetValue(); 430 p_ref r1(to_be);430 PtrRef r1(to_be); 431 431 432 432 void *mid_plot = LispSymbol::FindOrCreate("plot_middle")->GetValue(); 433 p_ref r2(mid_plot);433 PtrRef r2(mid_plot); 434 434 435 435 int dx=(xres+1)/2-im->width()/2,dy=(yres+1)/2-im->height()/2; … … 486 486 487 487 void *end_plot = LispSymbol::FindOrCreate("plot_end")->GetValue(); 488 p_ref r2(end_plot);488 PtrRef r2(end_plot); 489 489 490 490 -
abuse/trunk/src/game.cpp
r490 r491 2663 2663 2664 2664 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(); 2666 2667 2667 2668 sound_uninit(); -
abuse/trunk/src/lcache.cpp
r490 r491 124 124 while (x) 125 125 { 126 LispList *c =new_cons_cell();126 LispList *c = LispList::Create(); 127 127 if (first) 128 128 last->cdr=c; -
abuse/trunk/src/level.cpp
r490 r491 1509 1509 1510 1510 void *arg_list=NULL; 1511 p_ref r1(arg_list);1511 PtrRef r1(arg_list); 1512 1512 push_onto_list(LispString::Create(n),arg_list); 1513 1513 eval_function((LispSymbol *)l_level_loaded,arg_list); -
abuse/trunk/src/lisp/lisp.cpp
r490 r491 82 82 { 83 83 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; 86 86 87 87 for (int i=0;i<max_lev;i++) 88 88 { 89 89 dprintf("%d> ", i); 90 lprint(* l_ptr_stack.sdata[i]);90 lprint(*PtrRef::stack.sdata[i]); 91 91 } 92 92 } … … 140 140 { 141 141 void *prog=compile(s); 142 p_ref r1(prog);142 PtrRef r1(prog); 143 143 while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++; 144 144 lprint(eval(prog)); … … 210 210 void *eval_block(void *list) 211 211 { 212 p_ref r1(list);212 PtrRef r1(list); 213 213 void *ret=NULL; 214 214 while (list) … … 222 222 LispArray *LispArray::Create(int size, void *rest) 223 223 { 224 p_ref r11(rest);224 PtrRef r11(rest); 225 225 size_t s = sizeof(LispArray) 226 226 + ((size < 1 ? 1 : size) - 1) * sizeof(LispObject *); … … 230 230 LispObject **data = p->GetData(); 231 231 memset(data, 0, size * sizeof(LispObject *)); 232 p_ref r1(p);232 PtrRef r1(p); 233 233 234 234 if (rest) … … 349 349 LispUserFunction *new_lisp_user_function(void *arg_list, void *block_list) 350 350 { 351 p_ref r1(arg_list), r2(block_list);351 PtrRef r1(arg_list), r2(block_list); 352 352 LispUserFunction *lu=(LispUserFunction *)lmalloc(sizeof(LispUserFunction), current_space); 353 353 lu->type=L_USER_FUNCTION; … … 452 452 } 453 453 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 454 LispList *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 } 464 462 465 463 char *lerror(char const *loc, char const *cause) … … 808 806 current_space=PERM_SPACE; // make sure all symbols get defined in permanant space 809 807 LispList *cs; 810 cs= new_cons_cell();808 cs=LispList::Create(); 811 809 s=new_lisp_symbol(name); 812 810 cs->car=s; … … 931 929 if (l1!=0) 932 930 { 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); 935 934 while (list1) 936 935 { 937 cur=new_cons_cell(); 938 if (!first) first=cur; 936 cur = LispList::Create(); 937 if (!first) 938 first = cur; 939 939 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; 954 954 ret=first; 955 955 } else ret=NULL; … … 1105 1105 void push_onto_list(void *object, void *&list) 1106 1106 { 1107 p_ref r1(object), r2(list);1108 LispList *c =new_cons_cell();1107 PtrRef r1(object), r2(list); 1108 LispList *c = LispList::Create(); 1109 1109 c->car = (LispObject *)object; 1110 1110 c->cdr = (LispObject *)list; … … 1125 1125 else if (n[0]=='\'') // short hand for quote function 1126 1126 { 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); 1129 1129 1130 1130 ((LispList *)cs)->car=quote_symbol; 1131 c2 =new_cons_cell();1131 c2 = LispList::Create(); 1132 1132 tmp=compile(s); 1133 1133 ((LispList *)c2)->car = (LispObject *)tmp; … … 1138 1138 else if (n[0]=='`') // short hand for backquote function 1139 1139 { 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); 1142 1142 1143 1143 ((LispList *)cs)->car=backquote_symbol; 1144 c2 =new_cons_cell();1144 c2 = LispList::Create(); 1145 1145 tmp=compile(s); 1146 1146 ((LispList *)c2)->car = (LispObject *)tmp; … … 1150 1150 } else if (n[0]==',') // short hand for comma function 1151 1151 { 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); 1154 1154 1155 1155 ((LispList *)cs)->car=comma_symbol; 1156 c2 =new_cons_cell();1156 c2 = LispList::Create(); 1157 1157 tmp=compile(s); 1158 1158 ((LispList *)c2)->car = (LispObject *)tmp; … … 1164 1164 { 1165 1165 void *first=NULL, *cur=NULL, *last=NULL; 1166 p_ref r1(first), r2(cur), r3(last);1166 PtrRef r1(first), r2(cur), r3(last); 1167 1167 int done=0; 1168 1168 do … … 1195 1195 { 1196 1196 void *tmp; 1197 cur =new_cons_cell();1198 p_ref r1(cur);1197 cur = LispList::Create(); 1198 PtrRef r1(cur); 1199 1199 if (!first) first=cur; 1200 1200 tmp=compile(s); … … 1247 1247 else if (n[1]==0) // short hand for function 1248 1248 { 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); 1251 1251 tmp = LispSymbol::FindOrCreate("function"); 1252 1252 ((LispList *)cs)->car = (LispObject *)tmp; 1253 c2 =new_cons_cell();1253 c2 = LispList::Create(); 1254 1254 tmp=compile(s); 1255 1255 ((LispList *)c2)->car = (LispObject *)tmp; … … 1439 1439 1440 1440 void *fun=(LispSysFunction *)(((LispSymbol *)sym)->function); 1441 p_ref ref2( fun );1441 PtrRef ref2( fun ); 1442 1442 1443 1443 // make sure the arguments given to the function are the correct number … … 1493 1493 1494 1494 1495 p_ref ref1(arg_list);1495 PtrRef ref1(arg_list); 1496 1496 void *ret=NULL; 1497 1497 … … 1510 1510 { 1511 1511 void *first=NULL, *cur=NULL, *tmp; 1512 p_ref r1(first), r2(cur);1512 PtrRef r1(first), r2(cur); 1513 1513 while (arg_list) 1514 1514 { 1515 1515 if (first) { 1516 tmp =new_cons_cell();1516 tmp = LispList::Create(); 1517 1517 ((LispList *)cur)->cdr = (LispObject *)tmp; 1518 1518 cur=tmp; 1519 1519 } else 1520 cur=first =new_cons_cell();1520 cur=first = LispList::Create(); 1521 1521 1522 1522 void *val=eval(CAR(arg_list)); … … 1567 1567 void *mapcar(void *arg_list) 1568 1568 { 1569 p_ref ref1(arg_list);1569 PtrRef ref1(arg_list); 1570 1570 void *sym=eval(CAR(arg_list)); 1571 1571 switch ((short)item_type(sym)) … … 1587 1587 void **arg_on=(void **)malloc(sizeof(void *)*num_args); 1588 1588 LispList *list_on=(LispList *)CDR(arg_list); 1589 long old_ptr_son= l_ptr_stack.son;1589 long old_ptr_son=PtrRef::stack.son; 1590 1590 1591 1591 for (i=0;i<num_args;i++) 1592 1592 { 1593 1593 arg_on[i]=(LispList *)eval(CAR(list_on)); 1594 l_ptr_stack.push(&arg_on[i]);1594 PtrRef::stack.push(&arg_on[i]); 1595 1595 1596 1596 list_on=(LispList *)CDR(list_on); … … 1614 1614 { 1615 1615 if (!na_list) 1616 first=na_list =new_cons_cell();1616 first=na_list = LispList::Create(); 1617 1617 else 1618 1618 { 1619 na_list->cdr = (LispObject *) new_cons_cell();1619 na_list->cdr = (LispObject *)LispList::Create(); 1620 1620 na_list=(LispList *)CDR(na_list); 1621 1621 } … … 1631 1631 if (!stop) 1632 1632 { 1633 LispList *c =new_cons_cell();1633 LispList *c = LispList::Create(); 1634 1634 c->car = (LispObject *)eval_function((LispSymbol *)sym, first); 1635 1635 if (return_list) … … 1641 1641 } 1642 1642 while (!stop); 1643 l_ptr_stack.son=old_ptr_son;1643 PtrRef::stack.son=old_ptr_son; 1644 1644 1645 1645 free(arg_on); … … 1650 1650 { 1651 1651 void *el_list=CDR(prog_list); 1652 p_ref ref1(prog_list), ref2(el_list);1652 PtrRef ref1(prog_list), ref2(el_list); 1653 1653 void *ret=NULL; 1654 1654 void *rtype=eval(CAR(prog_list)); … … 1662 1662 { 1663 1663 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; 1665 1665 1666 1666 // evalaute all the strings and count their lengths … … 1668 1668 { 1669 1669 str_eval[i]=eval(CAR(el_list)); 1670 l_ptr_stack.push(&str_eval[i]);1670 PtrRef::stack.push(&str_eval[i]); 1671 1671 1672 1672 switch ((short)item_type(str_eval[i])) … … 1724 1724 } 1725 1725 free(str_eval); 1726 l_ptr_stack.son=old_ptr_stack_start; // restore pointer GC stack1726 PtrRef::stack.son=old_ptr_stack_start; // restore pointer GC stack 1727 1727 *s=0; 1728 1728 ret=st; … … 1750 1750 { 1751 1751 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); 1753 1753 while (args) 1754 1754 { … … 1763 1763 else 1764 1764 { 1765 cur =new_cons_cell();1765 cur = LispList::Create(); 1766 1766 if (first) 1767 1767 ((LispList *)last)->cdr = (LispObject *)cur; … … 1789 1789 void *eval_sys_function(LispSysFunction *fun, void *arg_list) 1790 1790 { 1791 p_ref ref1(arg_list);1791 PtrRef ref1(arg_list); 1792 1792 void *ret=NULL; 1793 1793 switch (fun->fun_number) … … 1823 1823 { 1824 1824 void *cur=NULL, *last=NULL, *first=NULL; 1825 p_ref r1(cur), r2(first), r3(last);1825 PtrRef r1(cur), r2(first), r3(last); 1826 1826 while (arg_list) 1827 1827 { 1828 cur =new_cons_cell();1828 cur = LispList::Create(); 1829 1829 void *val=eval(CAR(arg_list)); 1830 1830 ((LispList *) cur)->car = (LispObject *)val; … … 1838 1838 } break; 1839 1839 case SYS_FUNC_CONS: 1840 { void *c =new_cons_cell();1841 p_ref r1(c);1840 { void *c = LispList::Create(); 1841 PtrRef r1(c); 1842 1842 void *val=eval(CAR(arg_list)); 1843 1843 ((LispList *)c)->car = (LispObject *)val; … … 1876 1876 long sum; 1877 1877 void *first=eval(CAR(arg_list)); 1878 p_ref r1(first);1878 PtrRef r1(first); 1879 1879 if (arg_list && item_type(first)==L_FIXED_POINT) 1880 1880 { … … 1906 1906 { 1907 1907 void *i=eval(CAR(arg_list)); 1908 p_ref r1(i);1908 PtrRef r1(i); 1909 1909 if (item_type(i)!=L_NUMBER) 1910 1910 { … … 1949 1949 { 1950 1950 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); 1952 1952 i=CAR(arg_list); 1953 1953 … … 1995 1995 #endif 1996 1996 LispArray *a = (LispArray *)eval(CAR(CDR(i))); 1997 p_ref r1(a);1997 PtrRef r1(a); 1998 1998 #ifdef TYPE_CHECKING 1999 1999 if (item_type(a) != L_1D_ARRAY) … … 2037 2037 { 2038 2038 void *item=eval(CAR(arg_list)); 2039 p_ref r1(item);2039 PtrRef r1(item); 2040 2040 void *list=(LispList *)eval(CAR(CDR(arg_list))); 2041 p_ref r2(list);2041 PtrRef r2(list); 2042 2042 ret=assoc(item, (LispList *)list); 2043 2043 } break; … … 2049 2049 { 2050 2050 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(); 2053 2053 cs->car = (LispObject *)i1; 2054 2054 cs->cdr = (LispObject *)i2; … … 2057 2057 2058 2058 case SYS_FUNC_PAIRLIS: 2059 { 2059 { 2060 2060 l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list); 2061 2061 l_user_stack.push(eval(CAR(arg_list))); arg_list=CDR(arg_list); … … 2070 2070 void *var_list=CAR(arg_list), 2071 2071 *block_list=CDR(arg_list); 2072 p_ref r1(block_list), r2(var_list);2072 PtrRef r1(block_list), r2(var_list); 2073 2073 long stack_start=l_user_stack.son; 2074 2074 … … 2145 2145 { 2146 2146 void *l=arg_list; 2147 p_ref r1(l);2147 PtrRef r1(l); 2148 2148 ret=true_symbol; 2149 2149 while (l) … … 2159 2159 { 2160 2160 void *l=arg_list; 2161 p_ref r1(l);2161 PtrRef r1(l); 2162 2162 ret=NULL; 2163 2163 while (l) … … 2178 2178 { 2179 2179 void *i=eval(CAR(arg_list)); 2180 p_ref r1(i);2180 PtrRef r1(i); 2181 2181 ret=NULL; 2182 2182 switch (item_type(i)) … … 2197 2197 { 2198 2198 void *i=eval(CAR(arg_list)); 2199 p_ref r1(i);2199 PtrRef r1(i); 2200 2200 if (item_type(i)!=L_NUMBER) 2201 2201 { … … 2209 2209 { 2210 2210 void *block_list=CAR(arg_list); 2211 p_ref r1(block_list);2211 PtrRef r1(block_list); 2212 2212 if (!block_list) ret=NULL; 2213 2213 else … … 2226 2226 void *selector=eval(CAR(arg_list)); 2227 2227 void *sel=CDR(arg_list); 2228 p_ref r1(selector), r2(sel);2228 PtrRef r1(selector), r2(sel); 2229 2229 while (sel) 2230 2230 { … … 2339 2339 void *fn = eval( CAR( arg_list ) ); 2340 2340 char *st = lstring_value( fn ); 2341 p_ref r1( fn );2341 PtrRef r1( fn ); 2342 2342 bFILE *fp; 2343 2343 if( fun->fun_number == SYS_FUNC_LOCAL_LOAD ) … … 2391 2391 #endif 2392 2392 void *compiled_form=NULL; 2393 p_ref r11(compiled_form);2393 PtrRef r11(compiled_form); 2394 2394 while (!end_of_program(cs)) // see if there is anything left to compile and run 2395 2395 { … … 2461 2461 { 2462 2462 void *sym=eval(CAR(arg_list)); 2463 p_ref r1(sym);2463 PtrRef r1(sym); 2464 2464 switch (item_type(sym)) 2465 2465 { … … 2469 2469 { 2470 2470 void *s=eval(CAR(sym)); 2471 p_ref r1(s);2471 PtrRef r1(s); 2472 2472 #ifdef TYPE_CHECKING 2473 2473 if (item_type(s)!=L_SYMBOL) … … 2526 2526 LispSymbol *bind_var = (LispSymbol *)CAR(arg_list); 2527 2527 arg_list = CDR(arg_list); 2528 p_ref r1(bind_var);2528 PtrRef r1(bind_var); 2529 2529 if (item_type(bind_var)!=L_SYMBOL) 2530 2530 { lbreak("expecting for iterator to be a symbol\n"); exit(1); } … … 2535 2535 2536 2536 void *ilist=eval(CAR(arg_list)); arg_list=CDR(arg_list); 2537 p_ref r2(ilist);2537 PtrRef r2(ilist); 2538 2538 2539 2539 if (CAR(arg_list)!=do_symbol) … … 2542 2542 2543 2543 void *block=NULL, *ret=NULL; 2544 p_ref r3(block);2544 PtrRef r3(block); 2545 2545 l_user_stack.push(bind_var->GetValue()); // save old symbol value 2546 2546 while (ilist) … … 2558 2558 bFILE *old_file=current_print_file; 2559 2559 void *str1=eval(CAR(arg_list)); 2560 p_ref r1(str1);2560 PtrRef r1(str1); 2561 2561 void *str2=eval(CAR(CDR(arg_list))); 2562 2562 … … 2660 2660 { 2661 2661 void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list); 2662 p_ref r1(arg1); // protect this refrence2662 PtrRef r1(arg1); // protect this refrence 2663 2663 char *haystack=lstring_value(eval(CAR(arg_list))); 2664 2664 char *needle=lstring_value(arg1); … … 2672 2672 { 2673 2673 void *arg1=eval(CAR(arg_list)); arg_list=CDR(arg_list); 2674 p_ref r1(arg1); // protect this refrence2674 PtrRef r1(arg1); // protect this refrence 2675 2675 long x=lnumber_value(eval(CAR(arg_list))); 2676 2676 char *st=lstring_value(arg1); … … 2692 2692 { 2693 2693 void *init_var=CAR(arg_list); 2694 p_ref r1(init_var);2694 PtrRef r1(init_var); 2695 2695 int i, ustack_start=l_user_stack.son; // restore stack at end 2696 2696 LispSymbol *sym = NULL; 2697 p_ref r2(sym);2697 PtrRef r2(sym); 2698 2698 2699 2699 // check to make sure iter vars are symbol and push old values … … 2770 2770 { 2771 2771 void *l1=eval(CAR(arg_list)); arg_list=CDR(arg_list); 2772 p_ref r1(l1);2772 PtrRef r1(l1); 2773 2773 void *first=l1, *next; 2774 p_ref r2(first);2774 PtrRef r2(first); 2775 2775 2776 2776 if (!l1) … … 2816 2816 long x2=lnumber_value(eval(CAR(arg_list))); arg_list=CDR(arg_list); 2817 2817 void *st=eval(CAR(arg_list)); 2818 p_ref r1(st);2818 PtrRef r1(st); 2819 2819 2820 2820 if (x1 < 0 || x1 > x2 || (unsigned)x2 >= strlen(lstring_value(st))) … … 2831 2831 { 2832 2832 void *r=NULL, *rstart=NULL; 2833 p_ref r1(r), r2(rstart);2833 PtrRef r1(r), r2(rstart); 2834 2834 while (arg_list) 2835 2835 { … … 2870 2870 { 2871 2871 void *ret=NULL; 2872 p_ref ref1(ret);2872 PtrRef ref1(ret); 2873 2873 2874 2874 #ifdef TYPE_CHECKING … … 2898 2898 void *fun_arg_list=cache.lblock(fun->alist); 2899 2899 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); 2901 2901 #else 2902 2902 void *fun_arg_list=fun->arg_list; 2903 2903 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); 2905 2905 #endif 2906 2906 … … 2912 2912 // first push all of the old symbol values 2913 2913 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); 2916 2916 for (;f_arg;f_arg=CDR(f_arg)) 2917 2917 { … … 2979 2979 2980 2980 void *ret=NULL; 2981 p_ref ref1(prog);2981 PtrRef ref1(prog); 2982 2982 2983 2983 … … 2991 2991 space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]), 2992 2992 space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]), 2993 l_ptr_stack.son);2993 PtrRef::stack.son); 2994 2994 lprint(prog); 2995 2995 … … 3036 3036 space_size[PERM_SPACE]-((char *)free_space[PERM_SPACE]-(char *)space[PERM_SPACE]), 3037 3037 space_size[TMP_SPACE]-((char *)free_space[TMP_SPACE]-(char *)space[TMP_SPACE]), 3038 l_ptr_stack.son);3038 PtrRef::stack.son); 3039 3039 lprint(ret); 3040 3040 dprintf("\n"); -
abuse/trunk/src/lisp/lisp.h
r490 r491 57 57 struct LispList : LispObject 58 58 { 59 static LispList *Create(); 60 59 61 size_t GetLength(); 60 62 … … 71 73 struct LispRedirect : LispObject 72 74 { 73 void*new_reference;75 LispObject *new_reference; 74 76 }; 75 77 … … 185 187 LispSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number); 186 188 int read_ltoken(char *&s, char *buffer); 187 LispList *new_cons_cell();188 189 void print_trace_stack(int max_levels); 189 190 -
abuse/trunk/src/lisp/lisp_gc.cpp
r490 r491 14 14 15 15 #include "lisp.h" 16 #include "lisp_gc.h" 16 17 #ifdef NO_LIBS 17 18 #include "fakelib.h" … … 34 35 grow_stack<void> l_user_stack(150); 35 36 // Stack of user pointers 36 grow_stack<void *> l_ptr_stack(1500);37 grow_stack<void *> PtrRef::stack(1500); 37 38 38 39 size_t reg_ptr_total = 0; … … 83 84 } 84 85 85 static void *collect_object(void *x); 86 static void *collect_array(void *x) 87 { 88 long s = ((LispArray *)x)->size; 86 static LispObject *CollectObject(LispObject *x); 87 88 static LispArray *CollectArray(LispArray *x) 89 { 90 size_t s = x->size; 89 91 LispArray *a = LispArray::Create(s, NULL); 90 LispObject **src = ((LispArray *)x)->GetData();92 LispObject **src = x->GetData(); 91 93 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]); 94 96 95 97 return a; 96 98 } 97 99 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; 100 inline 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 128 static LispObject *CollectObject(LispObject *x) 129 { 130 LispObject *ret = x; 127 131 128 132 if (((uint8_t *)x) >= cstart && ((uint8_t *)x) < cend) … … 149 153 #else 150 154 { 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); 153 157 ret = new_lisp_user_function(arg, block); 154 158 } … … 180 184 break; 181 185 case L_1D_ARRAY: 182 ret = collect_array(x);186 ret = CollectArray((LispArray *)x); 183 187 break; 184 188 case L_FIXED_POINT: … … 186 190 break; 187 191 case L_CONS_CELL: 188 ret = collect_cons_cell((LispList *)x);192 ret = CollectList((LispList *)x); 189 193 break; 190 194 case L_OBJECT_VAR: … … 209 213 { 210 214 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); 212 216 if (x) 213 ((LispList *)x)->cdr = (LispObject *)collect_object(((LispList *)x)->cdr);217 ((LispList *)x)->cdr = CollectObject(((LispList *)x)->cdr); 214 218 } 215 219 } … … 222 226 if (root) 223 227 { 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); 227 231 collect_symbols(root->left); 228 232 collect_symbols(root->right); … … 236 240 void **d = l_user_stack.sdata; 237 241 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; 242 246 for (int i = 0; i < t; i++, d2++) 243 247 { 244 248 void **ptr = *d2; 245 *ptr = collect_object(*ptr);249 *ptr = CollectObject((LispObject *)*ptr); 246 250 } 247 251 … … 250 254 { 251 255 void **ptr = *d2; 252 *ptr = collect_object(*ptr);256 *ptr = CollectObject((LispObject *)*ptr); 253 257 } 254 258 } -
abuse/trunk/src/lisp/lisp_gc.h
r484 r491 13 13 14 14 extern 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 GC16 15 17 16 void collect_space(int which_space); // should be tmp or permenant … … 20 19 void unregister_pointer(void *&addr); 21 20 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. 24 class PtrRef 25 { 26 public: 27 template<typename T> inline PtrRef(T *&ref) 28 { 29 stack.push((void **)&ref); 30 } 30 31 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 }; 31 40 32 41 #endif 42 -
abuse/trunk/src/lisp/lisp_opt.cpp
r490 r491 32 32 { 33 33 void *return_val=list; 34 p_ref r1(list);34 PtrRef r1(list); 35 35 if (list) 36 36 { … … 38 38 { 39 39 void *eval1=lcar(lcdr(lcdr(list))); 40 p_ref r2(eval1);40 PtrRef r2(eval1); 41 41 void *eval2=lcar(lcdr(lcdr(lcdr(list)))); 42 p_ref r3(eval2);42 PtrRef r3(eval2); 43 43 44 44 void *ret=NULL; 45 p_ref r1(ret);45 PtrRef r4(ret); 46 46 if (lcar(list)==eq_symbol && (lcar(lcdr(list))==zero_symbol)) // simplify (eq 0 x) -> (eq0 x) 47 47 { -
abuse/trunk/src/objects.cpp
r490 r491 483 483 if (d) 484 484 { 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; 526 522 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); 530 526 if (profiling()) 531 527 { 532 528 time_marker now; 533 profile_add_time(this->otype, now.diff_time(prof1));529 profile_add_time(this->otype, now.diff_time(prof1)); 534 530 delete prof1; 535 531 } 536 532 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; 543 536 } else damage_fun(amount,from,hitx,hity,push_xvel,push_yvel); 544 537 #ifdef SCADALISP … … 902 895 903 896 void *rlist=NULL; // return list 904 p_ref r1(rlist);897 PtrRef r1(rlist); 905 898 906 899 if (hit_object) … … 1214 1207 if (figures[otype]->get_fun(OFUN_MOVER)) // is a lisp move function defined? 1215 1208 { 1216 void *lcx,*lcy,*lb;1209 LispList *lcx, *lcy, *lb; 1217 1210 1218 1211 game_object *o=current_object; 1219 1212 current_object=this; 1220 1213 1221 1222 1214 // 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; 1242 1233 if (profiling()) 1243 1234 prof1=new time_marker; … … 1254 1245 restore_heap(m,TMP_SPACE); 1255 1246 1256 l_ptr_stack.pop(3);1257 1247 if (item_type(r)!=L_NUMBER) 1258 1248 { 1259 1249 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); 1268 1258 1269 1259 return ret;
Note: See TracChangeset
for help on using the changeset viewer.