Changeset 482


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

lisp: make all lisp object inherit a common type.

Location:
abuse/trunk/src
Files:
17 edited

Legend:

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

    r481 r482  
    118118    push_onto_list(new_lisp_number(o->aitype()),call_list);
    119119    push_onto_list(new_lisp_pointer(o),call_list);
    120     eval_user_fun((lisp_symbol *)l_fire_object,call_list);
     120    eval_user_fun((LispSymbol *)l_fire_object,call_list);
    121121    o->set_state((character_state)S_weapon_fire);
    122122  }
  • abuse/trunk/src/cache.cpp

    r481 r482  
    386386    push_onto_list(new_lisp_number(type),call_with);
    387387
    388     void *CacheList=eval_function((lisp_symbol *)cache_fun,call_with);
     388    void *CacheList=eval_function((LispSymbol *)cache_fun,call_with);
    389389    p_ref r1(CacheList);
    390390
  • abuse/trunk/src/chars.cpp

    r481 r482  
    202202  /* First see if the variable has been defined for another object
    203203     if so report a conflict if any occur */
    204   lisp_symbol *s=(lisp_symbol *)symbol;
     204  LispSymbol *s=(LispSymbol *)symbol;
    205205  if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
    206206  {
     
    210210  } else if (DEFINEDP(s->value))
    211211  {
    212     int index=((lisp_object_var *)s->value)->number;
     212    int index=((LispObjectVar *)s->value)->number;
    213213    if (index<tiv)
    214214    {
  • abuse/trunk/src/clisp.cpp

    r481 r482  
    576576    exit(0);
    577577      }
    578       return eval_function((lisp_symbol *)ai,NULL);
     578      return eval_function((LispSymbol *)ai,NULL);
    579579    } break;
    580580    case 1 :
     
    704704      void *f=figures[current_object->otype]->get_fun(OFUN_USER_FUN);
    705705      if (!f) return NULL;
    706       return eval_function((lisp_symbol *)f,args);
     706      return eval_function((LispSymbol *)f,args);
    707707    } break;
    708708    case 17 :
     
    753753    case 23 :         // def_character
    754754    {
    755       lisp_symbol *sym=(lisp_symbol *)lcar(args);
     755      LispSymbol *sym=(LispSymbol *)lcar(args);
    756756      if (item_type(sym)!=L_SYMBOL)
    757757      {
     
    13501350    case 133 :  // def_sound
    13511351    {
    1352       lisp_symbol *sym=NULL;
     1352      LispSymbol *sym=NULL;
    13531353      if (CDR(args))
    13541354      {
    1355     sym=(lisp_symbol *)lcar(args);
     1355    sym=(LispSymbol *)lcar(args);
    13561356    if (item_type(sym)!=L_SYMBOL)
    13571357    {
     
    22592259    current_object=v->focus;
    22602260
    2261     eval_function((lisp_symbol *)l_restart_player,NULL);
     2261    eval_function((LispSymbol *)l_restart_player,NULL);
    22622262    v->reset_player();
    22632263    v->focus->set_aistate(0);
  • abuse/trunk/src/compiled.cpp

    r481 r482  
    4545  if (sym)
    4646  {
    47     if (item_type(((lisp_symbol *)sym)->value)!=L_NUMBER)
     47    if (item_type(((LispSymbol *)sym)->value)!=L_NUMBER)
    4848      compile_error=1;
    4949    else
    50       return lnumber_value(((lisp_symbol *)sym)->value);
     50      return lnumber_value(((LispSymbol *)sym)->value);
    5151  } else compile_error=1;
    5252  return 0;
  • abuse/trunk/src/cop.cpp

    r481 r482  
    233233  push_onto_list(new_lisp_number(type),list);
    234234  push_onto_list(new_lisp_pointer(o->get_object(0)),list);
    235   eval_function((lisp_symbol *)l_fire_object,list);
     235  eval_function((LispSymbol *)l_fire_object,list);
    236236  o->lvars[top_just_fired]=1;
    237237  other->lvars[just_fired]=1;
     
    662662
    663663      current_object=top;
    664       void *ret=eval_function((lisp_symbol *)figures[top->otype]->get_fun(OFUN_USER_FUN),args);   
     664      void *ret=eval_function((LispSymbol *)figures[top->otype]->get_fun(OFUN_USER_FUN),args);   
    665665      current_object=o;
    666666      v->add_ammo(v->current_weapon,lnumber_value(ret));   
     
    672672      {
    673673        // call the user function to reset the player
    674     eval_function((lisp_symbol *)l_restart_player,NULL);
     674    eval_function((LispSymbol *)l_restart_player,NULL);
    675675    o->controller()->reset_player();
    676676    o->set_aistate(0);
     
    766766      o->draw_predator();
    767767      } else
    768         eval_function((lisp_symbol *)l_player_draw,ret);
     768        eval_function((LispSymbol *)l_player_draw,ret);
    769769
    770770      o->y=oldy;
     
    829829      case FAST_POWER :
    830830      {
    831     eval_function((lisp_symbol *)l_draw_fast,NULL);
     831    eval_function((LispSymbol *)l_draw_fast,NULL);
    832832    int old_state=o->state;
    833833    switch (o->state)
  • abuse/trunk/src/game.cpp

    r481 r482  
    690690    screen->dirt_off();
    691691    clear_tmp();
    692     eval_function((lisp_symbol *)l_post_render, NULL);
     692    eval_function((LispSymbol *)l_post_render, NULL);
    693693    clear_tmp();
    694694    screen->dirt_on();
     
    23442344    int sp = current_space;
    23452345    current_space = PERM_SPACE;
    2346     eval_function((lisp_symbol *)l_next_song, NULL);
     2346    eval_function((LispSymbol *)l_next_song, NULL);
    23472347    current_space = sp;
    23482348      } */
  • abuse/trunk/src/lcache.cpp

    r481 r482  
    2727    for (;b && item_type(b)==L_CONS_CELL;b=CDR(b))
    2828    {
    29       t+=sizeof(cons_cell);
     29      t+=sizeof(LispList);
    3030    }
    3131    if (b) t+=block_size(b);
     
    3434    ret=t;
    3535    } else if (type== L_NUMBER)
    36     { ret=sizeof(lisp_number); }
     36    { ret=sizeof(LispNumber); }
    3737    else if (type==L_CHARACTER)
    38     { ret=sizeof(lisp_character); }
     38    { ret=sizeof(LispChar); }
    3939    else if (type==L_STRING)
    4040    {
    41       ret=sizeof(lisp_string)+strlen(lstring_value(level))+1;
     41      ret=sizeof(LispString)+strlen(lstring_value(level))+1;
    4242      if (ret<8)
    4343        ret=8;
    4444    }
    4545    else if (type==L_POINTER)
    46     { ret=sizeof(lisp_pointer); }
     46    { ret=sizeof(LispPointer); }
    4747    else ret=0;
    4848  }
     
    108108    case L_STRING :
    109109    { long l=fp->read_uint32();
    110       lisp_string *s=new_lisp_string(l);
     110      LispString *s=new_lisp_string(l);
    111111      fp->read(lstring_value(s),l);
    112112      return s;
     
    121121      {
    122122    long x=abs(t);
    123     cons_cell *last=NULL,*first=NULL;
     123    LispList *last=NULL,*first=NULL;
    124124    while (x)
    125125    {
    126       cons_cell *c=new_cons_cell();
     126      LispList *c=new_cons_cell();
    127127      if (first)
    128128        last->cdr=c;
     
    135135    else last->cdr=NULL;
    136136   
    137     for (last=first,x=0;x<abs(t);x++,last=(cons_cell *)last->cdr)
     137    for (last=first,x=0;x<abs(t);x++,last=(LispList *)last->cdr)
    138138      last->car=load_block(fp);   
    139139    return first;
  • abuse/trunk/src/level.cpp

    r481 r482  
    15111511    p_ref r1(arg_list);
    15121512    push_onto_list(new_lisp_string(n),arg_list);
    1513     eval_function((lisp_symbol *)l_level_loaded,arg_list);
     1513    eval_function((LispSymbol *)l_level_loaded,arg_list);
    15141514
    15151515    current_space=sp;
     
    18381838      current_object=f->focus;
    18391839      void *m=mark_heap(TMP_SPACE);
    1840       eval_function((lisp_symbol *)fun,NULL);
     1840      eval_function((LispSymbol *)fun,NULL);
    18411841      restore_heap(m,TMP_SPACE);
    18421842    }
  • abuse/trunk/src/lisp/lisp.cpp

    r481 r482  
    4141
    4242bFILE *current_print_file=NULL;
    43 lisp_symbol *lsym_root=NULL;
     43LispSymbol *lsym_root=NULL;
    4444long ltotal_syms=0;
    4545
     
    220220}
    221221
    222 lisp_1d_array *new_lisp_1d_array(int size, void *rest)
     222LispArray *new_lisp_1d_array(int size, void *rest)
    223223{
    224224  p_ref r11(rest);
    225   size_t s=sizeof(lisp_1d_array)+size*sizeof(void *);
     225  size_t s=sizeof(LispArray)+size*sizeof(void *);
    226226  if (s<8 + sizeof(intptr_t)) s=8 + sizeof(intptr_t);
    227   void *p=(lisp_1d_array *)lmalloc(s, current_space);
    228   ((lisp_1d_array *)p)->type=L_1D_ARRAY;
    229   ((lisp_1d_array *)p)->size=size;
    230   void **data=(void **)(((lisp_1d_array *)p)+1);
     227  void *p=(LispArray *)lmalloc(s, current_space);
     228  ((LispArray *)p)->type=L_1D_ARRAY;
     229  ((LispArray *)p)->size=size;
     230  void **data=(void **)(((LispArray *)p)+1);
    231231  memset(data, 0, size*sizeof(void *));
    232232  p_ref r1(p);
     
    238238    {
    239239      x=eval(CAR(CDR(rest)));
    240       data=(void **)(((lisp_1d_array *)p)+1);
     240      data=(void **)(((LispArray *)p)+1);
    241241      for (int i=0;i<size;i++, x=CDR(x))
    242242      {
     
    254254    {
    255255      x=eval(CAR(CDR(rest)));
    256       data=(void **)(((lisp_1d_array *)p)+1);
     256      data=(void **)(((LispArray *)p)+1);
    257257      for (int i=0;i<size;i++)
    258258        data[i]=x;
     
    266266  }
    267267
    268   return ((lisp_1d_array *)p);
    269 }
    270 
    271 lisp_fixed_point *new_lisp_fixed_point(int32_t x)
    272 {
    273   lisp_fixed_point *p=(lisp_fixed_point *)lmalloc(sizeof(lisp_fixed_point), current_space);
     268  return ((LispArray *)p);
     269}
     270
     271LispFixedPoint *new_lisp_fixed_point(int32_t x)
     272{
     273  LispFixedPoint *p=(LispFixedPoint *)lmalloc(sizeof(LispFixedPoint), current_space);
    274274  p->type=L_FIXED_POINT;
    275275  p->x=x;
     
    278278
    279279
    280 lisp_object_var *new_lisp_object_var(int16_t number)
    281 {
    282   lisp_object_var *p=(lisp_object_var *)lmalloc(sizeof(lisp_object_var), current_space);
     280LispObjectVar *new_lisp_object_var(int16_t number)
     281{
     282  LispObjectVar *p=(LispObjectVar *)lmalloc(sizeof(LispObjectVar), current_space);
    283283  p->type=L_OBJECT_VAR;
    284284  p->number=number;
     
    287287
    288288
    289 struct lisp_pointer *new_lisp_pointer(void *addr)
     289struct LispPointer *new_lisp_pointer(void *addr)
    290290{
    291291  if (addr==NULL) return NULL;
    292   lisp_pointer *p=(lisp_pointer *)lmalloc(sizeof(lisp_pointer), current_space);
     292  LispPointer *p=(LispPointer *)lmalloc(sizeof(LispPointer), current_space);
    293293  p->type=L_POINTER;
    294294  p->addr=addr;
     
    296296}
    297297
    298 struct lisp_character *new_lisp_character(uint16_t ch)
    299 {
    300   lisp_character *c=(lisp_character *)lmalloc(sizeof(lisp_character), current_space);
     298struct LispChar *new_lisp_character(uint16_t ch)
     299{
     300  LispChar *c=(LispChar *)lmalloc(sizeof(LispChar), current_space);
    301301  c->type=L_CHARACTER;
    302302  c->ch=ch;
     
    304304}
    305305
    306 struct lisp_string *new_lisp_string(char const *string)
    307 {
    308   size_t size=sizeof(lisp_string)+strlen(string)+1;
     306struct LispString *new_lisp_string(char const *string)
     307{
     308  size_t size=sizeof(LispString)+strlen(string)+1;
    309309  if (size<8 + sizeof(intptr_t)) size=8 + sizeof(intptr_t);
    310310
    311   lisp_string *s=(lisp_string *)lmalloc(size, current_space);
     311  LispString *s=(LispString *)lmalloc(size, current_space);
    312312  s->type=L_STRING;
    313   char *sloc=((char *)s)+sizeof(lisp_string);
     313  char *sloc=((char *)s)+sizeof(LispString);
    314314  strcpy(sloc, string);
    315315  return s;
    316316}
    317317
    318 struct lisp_string *new_lisp_string(char const *string, int length)
    319 {
    320   size_t size=sizeof(lisp_string)+length+1;
     318struct LispString *new_lisp_string(char const *string, int length)
     319{
     320  size_t size=sizeof(LispString)+length+1;
    321321  if (size<8 + sizeof(intptr_t)) size=8 + sizeof(intptr_t);
    322   lisp_string *s=(lisp_string *)lmalloc(size, current_space);
     322  LispString *s=(LispString *)lmalloc(size, current_space);
    323323  s->type=L_STRING;
    324   char *sloc=((char *)s)+sizeof(lisp_string);
     324  char *sloc=((char *)s)+sizeof(LispString);
    325325  memcpy(sloc, string, length);
    326326  sloc[length]=0;
     
    328328}
    329329
    330 struct lisp_string *new_lisp_string(int length)
    331 {
    332   size_t size=sizeof(lisp_string)+length;
     330struct LispString *new_lisp_string(int length)
     331{
     332  size_t size=sizeof(LispString)+length;
    333333  if (size<8 + sizeof(intptr_t)) size=8 + sizeof(intptr_t);
    334   lisp_string *s=(lisp_string *)lmalloc(size, current_space);
     334  LispString *s=(LispString *)lmalloc(size, current_space);
    335335  s->type=L_STRING;
    336   char *sloc=((char *)s)+sizeof(lisp_string);
     336  char *sloc=((char *)s)+sizeof(LispString);
    337337  strcpy(sloc, "");
    338338  return s;
     
    340340
    341341#ifdef NO_LIBS
    342 lisp_user_function *new_lisp_user_function(void *arg_list, void *block_list)
     342LispUserFunction *new_lisp_user_function(void *arg_list, void *block_list)
    343343{
    344344  p_ref r1(arg_list), r2(block_list);
    345   lisp_user_function *lu=(lisp_user_function *)lmalloc(sizeof(lisp_user_function), current_space);
     345  LispUserFunction *lu=(LispUserFunction *)lmalloc(sizeof(LispUserFunction), current_space);
    346346  lu->type=L_USER_FUNCTION;
    347347  lu->arg_list=arg_list;
     
    350350}
    351351#else
    352 lisp_user_function *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
     352LispUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
    353353{
    354354  int sp=current_space;
     
    356356    current_space=PERM_SPACE;       // make sure all functions get defined in permanant space
    357357
    358   lisp_user_function *lu=(lisp_user_function *)lmalloc(sizeof(lisp_user_function), current_space);
     358  LispUserFunction *lu=(LispUserFunction *)lmalloc(sizeof(LispUserFunction), current_space);
    359359  lu->type=L_USER_FUNCTION;
    360360  lu->alist=arg_list;
     
    368368
    369369
    370 lisp_sys_function *new_lisp_sys_function(int min_args, int max_args, int fun_number)
     370LispSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number)
    371371{
    372372  // sys functions should reside in permanant space
    373   lisp_sys_function *ls=(lisp_sys_function *)lmalloc(sizeof(lisp_sys_function),
     373  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
    374374                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    375375  ls->type=L_SYS_FUNCTION;
     
    380380}
    381381
    382 lisp_sys_function *new_lisp_c_function(int min_args, int max_args, int fun_number)
     382LispSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number)
    383383{
    384384  // sys functions should reside in permanant space
    385   lisp_sys_function *ls=(lisp_sys_function *)lmalloc(sizeof(lisp_sys_function),
     385  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
    386386                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    387387  ls->type=L_C_FUNCTION;
     
    392392}
    393393
    394 lisp_sys_function *new_lisp_c_bool(int min_args, int max_args, int fun_number)
     394LispSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number)
    395395{
    396396  // sys functions should reside in permanant space
    397   lisp_sys_function *ls=(lisp_sys_function *)lmalloc(sizeof(lisp_sys_function),
     397  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
    398398                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    399399  ls->type=L_C_BOOL;
     
    404404}
    405405
    406 lisp_sys_function *new_user_lisp_function(int min_args, int max_args, int fun_number)
     406LispSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number)
    407407{
    408408  // sys functions should reside in permanant space
    409   lisp_sys_function *ls=(lisp_sys_function *)lmalloc(sizeof(lisp_sys_function),
     409  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
    410410                             current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
    411411  ls->type=L_L_FUNCTION;
     
    416416}
    417417
    418 lisp_number *new_lisp_node(long num)
    419 {
    420   lisp_number *n=(lisp_number *)lmalloc(sizeof(lisp_number), current_space);
     418LispNumber *new_lisp_node(long num)
     419{
     420  LispNumber *n=(LispNumber *)lmalloc(sizeof(LispNumber), current_space);
    421421  n->type=L_NUMBER;
    422422  n->num=num;
     
    424424}
    425425
    426 lisp_symbol *new_lisp_symbol(char *name)
    427 {
    428   lisp_symbol *s=(lisp_symbol *)lmalloc(sizeof(lisp_symbol), current_space);
     426LispSymbol *new_lisp_symbol(char *name)
     427{
     428  LispSymbol *s=(LispSymbol *)lmalloc(sizeof(LispSymbol), current_space);
    429429  s->type=L_SYMBOL;
    430430  s->name=new_lisp_string(name);
     
    437437}
    438438
    439 lisp_number *new_lisp_number(long num)
    440 {
    441   lisp_number *s=(lisp_number *)lmalloc(sizeof(lisp_number), current_space);
     439LispNumber *new_lisp_number(long num)
     440{
     441  LispNumber *s=(LispNumber *)lmalloc(sizeof(LispNumber), current_space);
    442442  s->type=L_NUMBER;
    443443  s->num=num;
     
    446446
    447447
    448 cons_cell *new_cons_cell()
    449 {
    450   cons_cell *c=(cons_cell *)lmalloc(sizeof(cons_cell), current_space);
     448LispList *new_cons_cell()
     449{
     450  LispList *c=(LispList *)lmalloc(sizeof(LispList), current_space);
    451451  c->type=L_CONS_CELL;
    452452  c->car=NULL;
     
    503503  }
    504504#endif
    505   return ((lisp_pointer *)lpointer)->addr;
     505  return ((LispPointer *)lpointer)->addr;
    506506}
    507507
     
    511511  {
    512512    case L_NUMBER :
    513       return ((lisp_number *)lnumber)->num;
     513      return ((LispNumber *)lnumber)->num;
    514514    case L_FIXED_POINT :
    515       return (((lisp_fixed_point *)lnumber)->x)>>16;
     515      return (((LispFixedPoint *)lnumber)->x)>>16;
    516516    case L_STRING :
    517517      return (uint8_t)*lstring_value(lnumber);
     
    538538  }
    539539#endif
    540   return ((char *)lstring)+sizeof(lisp_string);
     540  return ((char *)lstring)+sizeof(LispString);
    541541}
    542542
     
    554554  if (!c) return NULL;
    555555  else if (item_type(c)==(ltype)L_CONS_CELL)
    556     return ((cons_cell *)c)->cdr;
     556    return ((LispList *)c)->cdr;
    557557  else
    558558    return NULL;
     
    563563  if (!c) return NULL;
    564564  else if (item_type(c)==(ltype)L_CONS_CELL)
    565     return ((cons_cell *)c)->car;
     565    return ((LispList *)c)->car;
    566566  else return NULL;
    567567}
     
    577577  }
    578578#endif
    579   return ((lisp_character *)c)->ch;
     579  return ((LispChar *)c)->ch;
    580580}
    581581
     
    585585  {
    586586    case L_NUMBER :
    587       return ((lisp_number *)c)->num<<16; break;
     587      return ((LispNumber *)c)->num<<16; break;
    588588    case L_FIXED_POINT :
    589       return (((lisp_fixed_point *)c)->x); break;
     589      return (((LispFixedPoint *)c)->x); break;
    590590    default :
    591591    {
     
    606606    if (t1!=t2) return NULL;
    607607    else if (t1==L_NUMBER)
    608     { if (((lisp_number *)n1)->num==((lisp_number *)n2)->num)
     608    { if (((LispNumber *)n1)->num==((LispNumber *)n2)->num)
    609609        return true_symbol;
    610610      else return NULL;
    611611    } else if (t1==L_CHARACTER)
    612612    {
    613       if (((lisp_character *)n1)->ch==((lisp_character *)n2)->ch)
     613      if (((LispChar *)n1)->ch==((LispChar *)n2)->ch)
    614614        return true_symbol;
    615615      else return NULL;
     
    633633  }
    634634#endif
    635   if (x>=((lisp_1d_array *)a)->size || x<0)
     635  if (x>=((LispArray *)a)->size || x<0)
    636636  {
    637637    lbreak("array refrence out of bounds (%d)\n", x);
    638638    exit(0);
    639639  }
    640   return ((void **)(((lisp_1d_array *)a)+1))[x];
     640  return ((void **)(((LispArray *)a)+1))[x];
    641641}
    642642
     
    781781
    782782/*
    783 lisp_symbol *find_symbol(char const *name)
    784 {
    785   cons_cell *cs;
    786   for (cs=(cons_cell *)symbol_list;cs;cs=(cons_cell *)CDR(cs))
    787   {
    788     if (!strcmp( ((char *)((lisp_symbol *)cs->car)->name)+sizeof(lisp_string), name))
    789       return (lisp_symbol *)(cs->car);
     783LispSymbol *find_symbol(char const *name)
     784{
     785  LispList *cs;
     786  for (cs=(LispList *)symbol_list;cs;cs=(LispList *)CDR(cs))
     787  {
     788    if (!strcmp( ((char *)((LispSymbol *)cs->car)->name)+sizeof(LispString), name))
     789      return (LispSymbol *)(cs->car);
    790790  }
    791791  return NULL;
     
    793793
    794794
    795 lisp_symbol *make_find_symbol(char const *name)    // find a symbol, if it doesn't exsist it is created
    796 {
    797   lisp_symbol *s=find_symbol(name);
     795LispSymbol *make_find_symbol(char const *name)    // find a symbol, if it doesn't exsist it is created
     796{
     797  LispSymbol *s=find_symbol(name);
    798798  if (s) return s;
    799799  else
     
    802802    if (current_space!=GC_SPACE)
    803803      current_space=PERM_SPACE;       // make sure all symbols get defined in permanant space
    804     cons_cell *cs;
     804    LispList *cs;
    805805    cs=new_cons_cell();
    806806    s=new_lisp_symbol(name);
     
    815815*/
    816816
    817 lisp_symbol *find_symbol(char const *name)
    818 {
    819   lisp_symbol *p=lsym_root;
     817LispSymbol *find_symbol(char const *name)
     818{
     819  LispSymbol *p=lsym_root;
    820820  while (p)
    821821  {
    822     int cmp=strcmp(name, ((char *)p->name)+sizeof(lisp_string));
     822    int cmp=strcmp(name, ((char *)p->name)+sizeof(LispString));
    823823    if (cmp==0) return p;
    824824    else if (cmp<0) p=p->left;
     
    830830
    831831
    832 lisp_symbol *make_find_symbol(char const *name)
    833 {
    834   lisp_symbol *p=lsym_root;
    835   lisp_symbol **parent=&lsym_root;
     832LispSymbol *make_find_symbol(char const *name)
     833{
     834  LispSymbol *p=lsym_root;
     835  LispSymbol **parent=&lsym_root;
    836836  while (p)
    837837  {
    838     int cmp=strcmp(name, ((char *)p->name)+sizeof(lisp_string));
     838    int cmp=strcmp(name, ((char *)p->name)+sizeof(LispString));
    839839    if (cmp==0) return p;
    840840    else if (cmp<0)
     
    853853     current_space=PERM_SPACE;       // make sure all symbols get defined in permanant space
    854854
    855   p=(lisp_symbol *)malloc(sizeof(lisp_symbol));
     855  p=(LispSymbol *)malloc(sizeof(LispSymbol));
    856856  p->type=L_SYMBOL;
    857857  p->name=new_lisp_string(name);
     
    874874
    875875
    876 void ldelete_syms(lisp_symbol *root)
     876void ldelete_syms(LispSymbol *root)
    877877{
    878878  if (root)
     
    894894      if (lisp_eq(CAR(CAR(list)), item))
    895895        return lcar(list);   
    896       list=(cons_cell *)(CDR(list));
     896      list=(LispList *)(CDR(list));
    897897    }
    898898  }
     
    943943      if (!first) first=cur;
    944944      if (last)
    945         ((cons_cell *)last)->cdr=cur;
     945        ((LispList *)last)->cdr=cur;
    946946      last=cur;
    947947   
    948       cons_cell *cell=new_cons_cell();   
     948      LispList *cell=new_cons_cell();   
    949949      tmp=lcar(list1);
    950       ((cons_cell *)cell)->car=tmp;
     950      ((LispList *)cell)->car=tmp;
    951951      tmp=lcar(list2);
    952       ((cons_cell *)cell)->cdr=tmp;
    953       ((cons_cell *)cur)->car=cell;
    954 
    955       list1=((cons_cell *)list1)->cdr;
    956       list2=((cons_cell *)list2)->cdr;
    957     }
    958     ((cons_cell *)cur)->cdr=list3;
     952      ((LispList *)cell)->cdr=tmp;
     953      ((LispList *)cur)->car=cell;
     954
     955      list1=((LispList *)list1)->cdr;
     956      list2=((LispList *)list2)->cdr;
     957    }
     958    ((LispList *)cur)->cdr=list3;
    959959    ret=first;
    960960  } else ret=NULL;
     
    964964void *lookup_symbol_function(void *symbol)
    965965{
    966   return ((lisp_symbol *)symbol)->function;
     966  return ((LispSymbol *)symbol)->function;
    967967}
    968968
    969969void set_symbol_function(void *symbol, void *function)
    970970{
    971   ((lisp_symbol *)symbol)->function=function;
     971  ((LispSymbol *)symbol)->function=function;
    972972}
    973973
     
    975975{
    976976#ifdef TYPE_CHECKING
    977   if (((lisp_symbol *)symbol)->value!=l_undefined)
    978 #endif
    979     return ((lisp_symbol *)symbol)->value;
     977  if (((LispSymbol *)symbol)->value!=l_undefined)
     978#endif
     979    return ((LispSymbol *)symbol)->value;
    980980#ifdef TYPE_CHECKING
    981981  else
     
    991991void set_variable_value(void *symbol, void *value)
    992992{
    993   ((lisp_symbol *) symbol)->value=value;
    994 }
    995 
    996 lisp_symbol *add_sys_function(char const *name, short min_args, short max_args, short number)
     993  ((LispSymbol *) symbol)->value=value;
     994}
     995
     996LispSymbol *add_sys_function(char const *name, short min_args, short max_args, short number)
    997997{
    998998  need_perm_space("add_sys_function");
    999   lisp_symbol *s=make_find_symbol(name);
     999  LispSymbol *s=make_find_symbol(name);
    10001000  if (s->function!=l_undefined)
    10011001  {
     
    10071007}
    10081008
    1009 lisp_symbol *add_c_object(void *symbol, int16_t number)
     1009LispSymbol *add_c_object(void *symbol, int16_t number)
    10101010{
    10111011  need_perm_space("add_c_object");
    1012   lisp_symbol *s=(lisp_symbol *)symbol;
     1012  LispSymbol *s=(LispSymbol *)symbol;
    10131013  if (s->value!=l_undefined)
    10141014  {
     
    10201020}
    10211021
    1022 lisp_symbol *add_c_function(char const *name, short min_args, short max_args, short number)
     1022LispSymbol *add_c_function(char const *name, short min_args, short max_args, short number)
    10231023{
    10241024  total_user_functions++;
    10251025  need_perm_space("add_c_function");
    1026   lisp_symbol *s=make_find_symbol(name);
     1026  LispSymbol *s=make_find_symbol(name);
    10271027  if (s->function!=l_undefined)
    10281028  {
     
    10341034}
    10351035
    1036 lisp_symbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number)
     1036LispSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number)
    10371037{
    10381038  total_user_functions++;
    10391039  need_perm_space("add_c_bool_fun");
    1040   lisp_symbol *s=make_find_symbol(name);
     1040  LispSymbol *s=make_find_symbol(name);
    10411041  if (s->function!=l_undefined)
    10421042  {
     
    10491049
    10501050
    1051 lisp_symbol *add_lisp_function(char const *name, short min_args, short max_args, short number)
     1051LispSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number)
    10521052{
    10531053  total_user_functions++;
    10541054  need_perm_space("add_c_bool_fun");
    1055   lisp_symbol *s=make_find_symbol(name);
     1055  LispSymbol *s=make_find_symbol(name);
    10561056  if (s->function!=l_undefined)
    10571057  {
     
    11381138{
    11391139  p_ref r1(object), r2(list);
    1140   cons_cell *c=new_cons_cell();
     1140  LispList *c=new_cons_cell();
    11411141  c->car=object;
    11421142  c->cdr=list;
     
    11601160    p_ref r1(cs), r2(c2);
    11611161
    1162     ((cons_cell *)cs)->car=quote_symbol;
     1162    ((LispList *)cs)->car=quote_symbol;
    11631163    c2=new_cons_cell();
    11641164    tmp=compile(s);
    1165     ((cons_cell *)c2)->car=tmp;
    1166     ((cons_cell *)c2)->cdr=NULL;
    1167     ((cons_cell *)cs)->cdr=c2;
     1165    ((LispList *)c2)->car=tmp;
     1166    ((LispList *)c2)->cdr=NULL;
     1167    ((LispList *)cs)->cdr=c2;
    11681168    ret=cs;
    11691169  }
     
    11731173    p_ref r1(cs), r2(c2);
    11741174
    1175     ((cons_cell *)cs)->car=backquote_symbol;
     1175    ((LispList *)cs)->car=backquote_symbol;
    11761176    c2=new_cons_cell();
    11771177    tmp=compile(s);
    1178     ((cons_cell *)c2)->car=tmp;
    1179     ((cons_cell *)c2)->cdr=NULL;
    1180     ((cons_cell *)cs)->cdr=c2;
     1178    ((LispList *)c2)->car=tmp;
     1179    ((LispList *)c2)->cdr=NULL;
     1180    ((LispList *)cs)->cdr=c2;
    11811181    ret=cs;
    11821182  }  else if (n[0]==',')              // short hand for comma function
     
    11851185    p_ref r1(cs), r2(c2);
    11861186
    1187     ((cons_cell *)cs)->car=comma_symbol;
     1187    ((LispList *)cs)->car=comma_symbol;
    11881188    c2=new_cons_cell();
    11891189    tmp=compile(s);
    1190     ((cons_cell *)c2)->car=tmp;
    1191     ((cons_cell *)c2)->cdr=NULL;
    1192     ((cons_cell *)cs)->cdr=c2;
     1190    ((LispList *)c2)->car=tmp;
     1191    ((LispList *)c2)->cdr=NULL;
     1192    ((LispList *)cs)->cdr=c2;
    11931193    ret=cs;
    11941194  }
     
    12191219                    read_ltoken(s, n);              // skip the '.'
    12201220                    tmp=compile(s);
    1221                     ((cons_cell *)last)->cdr=tmp;          // link the last cdr to
     1221                    ((LispList *)last)->cdr=tmp;          // link the last cdr to
    12221222                    last=NULL;
    12231223                  }
     
    12311231                  if (!first) first=cur;
    12321232                  tmp=compile(s);   
    1233                   ((cons_cell *)cur)->car=tmp;
     1233                  ((LispList *)cur)->car=tmp;
    12341234                  if (last)
    1235                     ((cons_cell *)last)->cdr=cur;
     1235                    ((LispList *)last)->cdr=cur;
    12361236                  last=cur;
    12371237                }
     
    12441244  else if (isdigit(n[0]) || (n[0]=='-' && isdigit(n[1])))
    12451245  {
    1246     lisp_number *num=new_lisp_number(0);
     1246    LispNumber *num=new_lisp_number(0);
    12471247    sscanf(n, "%ld", &num->num);
    12481248    ret=num;
     
    12821282      p_ref r4(cs), r5(c2);
    12831283      tmp=make_find_symbol("function");
    1284       ((cons_cell *)cs)->car=tmp;
     1284      ((LispList *)cs)->car=tmp;
    12851285      c2=new_cons_cell();
    12861286      tmp=compile(s);
    1287       ((cons_cell *)c2)->car=tmp;
    1288       ((cons_cell *)cs)->cdr=c2;
     1287      ((LispList *)c2)->car=tmp;
     1288      ((LispList *)cs)->cdr=c2;
    12891289      ret=cs;
    12901290    }
     
    13381338      case L_CONS_CELL :
    13391339      {
    1340                 cons_cell *cs=(cons_cell *)i;
     1340                LispList *cs=(LispList *)i;
    13411341        lprint_string("(");
    1342         for (;cs;cs=(cons_cell *)lcdr(cs))   
     1342        for (;cs;cs=(LispList *)lcdr(cs))   
    13431343                {
    13441344                  if (item_type(cs)==(ltype)L_CONS_CELL)
     
    13611361      {
    13621362                char num[10];
    1363                 sprintf(num, "%ld", ((lisp_number *)i)->num);
     1363                sprintf(num, "%ld", ((LispNumber *)i)->num);
    13641364        lprint_string(num);
    13651365      }
    13661366      break;
    13671367      case L_SYMBOL :
    1368         lprint_string((char *)(((lisp_symbol *)i)->name)+sizeof(lisp_string));
     1368        lprint_string((char *)(((LispSymbol *)i)->name)+sizeof(LispString));
    13691369      break;
    13701370      case L_USER_FUNCTION :
     
    14081408                if (current_print_file)
    14091409                {
    1410                   uint8_t ch=((lisp_character *)i)->ch;
     1410                  uint8_t ch=((LispChar *)i)->ch;
    14111411                  current_print_file->write(&ch, 1);
    14121412                } else
    14131413                {
    1414                   uint16_t ch=((lisp_character *)i)->ch;
     1414                  uint16_t ch=((LispChar *)i)->ch;
    14151415                  dprintf("#\\");
    14161416                  switch (ch)
     
    14271427      case L_OBJECT_VAR :
    14281428      {
    1429                 l_obj_print(((lisp_object_var *)i)->number);
     1429                l_obj_print(((LispObjectVar *)i)->number);
    14301430      } break;
    14311431      case L_1D_ARRAY :
    14321432      {
    1433                 lisp_1d_array *a=(lisp_1d_array *)i;
     1433                LispArray *a=(LispArray *)i;
    14341434                void **data=(void **)(a+1);
    14351435                dprintf("#(");
     
    14451445      {
    14461446                lprint_string("GC_refrence->");
    1447                 lprint(((lisp_collected_object *)i)->new_reference);
     1447                lprint(((LispRedirect *)i)->new_reference);
    14481448      } break;
    14491449      default :
     
    14561456}
    14571457
    1458 void *eval_sys_function(lisp_sys_function *fun, void *arg_list);
    1459 
    1460 void *eval_function(lisp_symbol *sym, void *arg_list)
     1458void *eval_sys_function(LispSysFunction *fun, void *arg_list);
     1459
     1460void *eval_function(LispSymbol *sym, void *arg_list)
    14611461{
    14621462#ifdef TYPE_CHECKING
     
    14701470#endif
    14711471
    1472   void *fun=(lisp_sys_function *)(((lisp_symbol *)sym)->function);
     1472  void *fun=(LispSysFunction *)(((LispSymbol *)sym)->function);
    14731473  p_ref ref2( fun  );
    14741474
     
    14841484    case L_L_FUNCTION :
    14851485    {
    1486       req_min=((lisp_sys_function *)fun)->min_args;
    1487       req_max=((lisp_sys_function *)fun)->max_args;
     1486      req_min=((LispSysFunction *)fun)->min_args;
     1487      req_max=((LispSysFunction *)fun)->max_args;
    14881488    } break;
    14891489    case L_USER_FUNCTION :
     
    15311531  {
    15321532    case L_SYS_FUNCTION :
    1533     { ret=eval_sys_function( ((lisp_sys_function *)fun), arg_list); } break;
     1533    { ret=eval_sys_function( ((LispSysFunction *)fun), arg_list); } break;
    15341534    case L_L_FUNCTION :
    1535     { ret=l_caller( ((lisp_sys_function *)fun)->fun_number, arg_list); } break;
     1535    { ret=l_caller( ((LispSysFunction *)fun)->fun_number, arg_list); } break;
    15361536    case L_USER_FUNCTION :
    15371537    {
     
    15471547        if (first) {
    15481548          tmp=new_cons_cell();
    1549           ((cons_cell *)cur)->cdr=tmp;
     1549          ((LispList *)cur)->cdr=tmp;
    15501550          cur=tmp;
    15511551        } else
     
    15531553   
    15541554        void *val=eval(CAR(arg_list));
    1555         ((cons_cell *)cur)->car=val;
     1555        ((LispList *)cur)->car=val;
    15561556        arg_list=lcdr(arg_list);
    15571557      }
    15581558      if(t == L_C_FUNCTION)
    1559         ret=new_lisp_number(c_caller( ((lisp_sys_function *)fun)->fun_number, first));
    1560       else if (c_caller( ((lisp_sys_function *)fun)->fun_number, first))
     1559        ret=new_lisp_number(c_caller( ((LispSysFunction *)fun)->fun_number, first));
     1560      else if (c_caller( ((LispSysFunction *)fun)->fun_number, first))
    15611561        ret=true_symbol;
    15621562      else ret=NULL;
     
    15681568#ifdef L_PROFILE
    15691569  time_marker end;
    1570   ((lisp_symbol *)sym)->time_taken+=end.diff_time(&start);
     1570  ((LispSymbol *)sym)->time_taken+=end.diff_time(&start);
    15711571#endif
    15721572
     
    15751575
    15761576#ifdef L_PROFILE
    1577 void pro_print(bFILE *out, lisp_symbol *p)
     1577void pro_print(bFILE *out, LispSymbol *p)
    15781578{
    15791579  if (p)
     
    15821582    {
    15831583      char st[100];
    1584       sprintf(st, "%20s %f\n", lstring_value(symbol_name(p)), ((lisp_symbol *)p)->time_taken);
     1584      sprintf(st, "%20s %f\n", lstring_value(symbol_name(p)), ((LispSymbol *)p)->time_taken);
    15851585      out->write(st, strlen(st));
    15861586    }
     
    16181618
    16191619  void **arg_on=(void **)malloc(sizeof(void *)*num_args);
    1620   cons_cell *list_on=(cons_cell *)CDR(arg_list);
     1620  LispList *list_on=(LispList *)CDR(arg_list);
    16211621  long old_ptr_son=l_ptr_stack.son;
    16221622
    16231623  for (i=0;i<num_args;i++)
    16241624  {
    1625     arg_on[i]=(cons_cell *)eval(CAR(list_on));
     1625    arg_on[i]=(LispList *)eval(CAR(list_on));
    16261626    l_ptr_stack.push(&arg_on[i]);
    16271627
    1628     list_on=(cons_cell *)CDR(list_on);
     1628    list_on=(LispList *)CDR(list_on);
    16291629    if (!arg_on[i]) stop=1;
    16301630  }
     
    16361636  }
    16371637
    1638   cons_cell *na_list=NULL, *return_list=NULL, *last_return=NULL;
     1638  LispList *na_list=NULL, *return_list=NULL, *last_return=NULL;
    16391639
    16401640  do
     
    16421642    na_list=NULL;          // create a cons list with all of the parameters for the function
    16431643
    1644     cons_cell *first=NULL;                       // save the start of the list
     1644    LispList *first=NULL;                       // save the start of the list
    16451645    for (i=0;!stop &&i<num_args;i++)
    16461646    {
     
    16501650      {
    16511651        na_list->cdr=new_cons_cell();
    1652                 na_list=(cons_cell *)CDR(na_list);
     1652                na_list=(LispList *)CDR(na_list);
    16531653      }
    16541654
     
    16571657      {
    16581658                na_list->car=CAR(arg_on[i]);
    1659                 arg_on[i]=(cons_cell *)CDR(arg_on[i]);
     1659                arg_on[i]=(LispList *)CDR(arg_on[i]);
    16601660      }
    16611661      else stop=1;
     
    16631663    if (!stop)
    16641664    {
    1665       cons_cell *c=new_cons_cell();
    1666       c->car=eval_function((lisp_symbol *)sym, first);
     1665      LispList *c=new_cons_cell();
     1666      c->car=eval_function((LispSymbol *)sym, first);
    16671667      if (return_list)
    16681668        last_return->cdr=c;
     
    17061706      case L_CONS_CELL :
    17071707      {
    1708         cons_cell *char_list=(cons_cell *)str_eval[i];
     1708        LispList *char_list=(LispList *)str_eval[i];
    17091709        while (char_list)
    17101710        {
     
    17171717        exit(0);
    17181718          }
    1719           char_list=(cons_cell *)CDR(char_list);
     1719          char_list=(LispList *)CDR(char_list);
    17201720        }
    17211721      } break;
     
    17291729    }
    17301730      }
    1731       lisp_string *st=new_lisp_string(len+1);
     1731      LispString *st=new_lisp_string(len+1);
    17321732      char *s=lstring_value(st);
    17331733
     
    17391739      case L_CONS_CELL :
    17401740      {
    1741         cons_cell *char_list=(cons_cell *)str_eval[i];
     1741        LispList *char_list=(LispList *)str_eval[i];
    17421742        while (char_list)
    17431743        {
    17441744          if (item_type(CAR(char_list))==L_CHARACTER)
    1745             *(s++)=((lisp_character *)CAR(char_list))->ch;
    1746           char_list=(cons_cell *)CDR(char_list);
     1745            *(s++)=((LispChar *)CAR(char_list))->ch;
     1746          char_list=(LispList *)CDR(char_list);
    17471747        }
    17481748      } break;
     
    17771777  else if (args==NULL)
    17781778    return NULL;
    1779   else if ((lisp_symbol *) (((cons_cell *)args)->car)==comma_symbol)
     1779  else if ((LispSymbol *) (((LispList *)args)->car)==comma_symbol)
    17801780    return eval(CAR(CDR(args)));
    17811781  else
     
    17901790    {
    17911791      tmp=eval(CAR(CDR(args)));
    1792       ((cons_cell *)last)->cdr=tmp;
     1792      ((LispList *)last)->cdr=tmp;
    17931793      args=NULL;
    17941794    }
     
    17971797      cur=new_cons_cell();
    17981798      if (first)
    1799         ((cons_cell *)last)->cdr=cur;
     1799        ((LispList *)last)->cdr=cur;
    18001800      else
    18011801            first=cur;
    18021802      last=cur;
    18031803          tmp=backquote_eval(CAR(args));
    1804           ((cons_cell *)cur)->car=tmp;
     1804          ((LispList *)cur)->car=tmp;
    18051805       args=CDR(args);
    18061806    }
     
    18081808      {
    18091809    tmp=backquote_eval(args);
    1810     ((cons_cell *)last)->cdr=tmp;
     1810    ((LispList *)last)->cdr=tmp;
    18111811    args=NULL;
    18121812      }
     
    18191819
    18201820
    1821 void *eval_sys_function(lisp_sys_function *fun, void *arg_list)
     1821void *eval_sys_function(LispSysFunction *fun, void *arg_list)
    18221822{
    18231823  p_ref ref1(arg_list);
     
    18601860    cur=new_cons_cell();
    18611861    void *val=eval(CAR(arg_list));
    1862     ((cons_cell *) cur)->car=val;
     1862    ((LispList *) cur)->car=val;
    18631863    if (last)
    1864       ((cons_cell *)last)->cdr=cur;
     1864      ((LispList *)last)->cdr=cur;
    18651865    else first=cur;
    18661866    last=cur;
    1867     arg_list=(cons_cell *)CDR(arg_list);
     1867    arg_list=(LispList *)CDR(arg_list);
    18681868      }   
    18691869      ret=first;
     
    18731873      p_ref r1(c);
    18741874      void *val=eval(CAR(arg_list));
    1875       ((cons_cell *)c)->car=val;
     1875      ((LispList *)c)->car=val;
    18761876      val=eval(CAR(CDR(arg_list)));
    1877       ((cons_cell *)c)->cdr=val;
     1877      ((LispList *)c)->cdr=val;
    18781878      ret=c;
    18791879    } break;
     
    19461946    } else if (first)
    19471947    {
    1948       sum=((lisp_number *)i)->num;
     1948      sum=((LispNumber *)i)->num;
    19491949      first=0;
    19501950    }
    1951     else sum/=((lisp_number *)i)->num;
     1951    else sum/=((LispNumber *)i)->num;
    19521952    arg_list=CDR(arg_list);
    19531953      }
     
    19891989        case L_SYMBOL :
    19901990        {
    1991           switch (item_type (((lisp_symbol *)i)->value))
     1991          switch (item_type (((LispSymbol *)i)->value))
    19921992          {
    19931993            case L_NUMBER :
    19941994            {
    1995               if (x==L_NUMBER && ((lisp_symbol *)i)->value!=l_undefined)
    1996               ((lisp_number *)(((lisp_symbol *)i)->value))->num=lnumber_value(set_to);
     1995              if (x==L_NUMBER && ((LispSymbol *)i)->value!=l_undefined)
     1996              ((LispNumber *)(((LispSymbol *)i)->value))->num=lnumber_value(set_to);
    19971997              else
    1998               ((lisp_symbol *)i)->value=set_to;
     1998              ((LispSymbol *)i)->value=set_to;
    19991999            } break;
    20002000            case L_OBJECT_VAR :
    20012001            {
    2002               l_obj_set(((lisp_object_var *)(((lisp_symbol *)i)->value))->number, set_to);
     2002              l_obj_set(((LispObjectVar *)(((LispSymbol *)i)->value))->number, set_to);
    20032003            } break;
    20042004            default :
    2005             ((lisp_symbol *)i)->value=set_to;
     2005            ((LispSymbol *)i)->value=set_to;
    20062006          }
    2007           ret=((lisp_symbol *)i)->value;
     2007          ret=((LispSymbol *)i)->value;
    20082008        } break;
    20092009        case L_CONS_CELL :   // this better be an 'aref'
    20102010        {
    20112011#ifdef TYPE_CHECKING
    2012           void *car=((cons_cell *)i)->car;
     2012          void *car=((LispList *)i)->car;
    20132013          if (car==car_symbol)
    20142014          {
     
    20162016            if (!car || item_type(car)!=L_CONS_CELL)
    20172017            { lprint(car); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
    2018             ((cons_cell *)car)->car=set_to;
     2018            ((LispList *)car)->car=set_to;
    20192019          } else if (car==cdr_symbol)
    20202020          {
     
    20222022            if (!car || item_type(car)!=L_CONS_CELL)
    20232023            { lprint(car); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
    2024             ((cons_cell *)car)->cdr=set_to;
     2024            ((LispList *)car)->cdr=set_to;
    20252025          } else if (car==aref_symbol)
    20262026          {
    20272027#endif
    2028             void *a=(lisp_1d_array *)eval(CAR(CDR(i)));
     2028            void *a=(LispArray *)eval(CAR(CDR(i)));
    20292029            p_ref r1(a);
    20302030#ifdef TYPE_CHECKING
     
    20382038            long num=lnumber_value(eval(CAR(CDR(CDR(i)))));
    20392039#ifdef TYPE_CHECKING
    2040             if (num>=((lisp_1d_array *)a)->size || num<0)
     2040            if (num>=((LispArray *)a)->size || num<0)
    20412041            {
    20422042              lbreak("aref : value of bounds (%d)\n", num);
     
    20442044            }
    20452045#endif
    2046             void **data=(void **)(((lisp_1d_array *)a)+1);
     2046            void **data=(void **)(((LispArray *)a)+1);
    20472047            data[num]=set_to;
    20482048#ifdef TYPE_CHECKING
     
    20712071      void *item=eval(CAR(arg_list));
    20722072      p_ref r1(item);
    2073       void *list=(cons_cell *)eval(CAR(CDR(arg_list)));
     2073      void *list=(LispList *)eval(CAR(CDR(arg_list)));
    20742074      p_ref r2(list);
    2075       ret=assoc(item, (cons_cell *)list);
     2075      ret=assoc(item, (LispList *)list);
    20762076    } break;
    20772077    case SYS_FUNC_NOT:
     
    20832083      void *i1=eval(CAR(arg_list)), *i2=eval(CAR(CDR(arg_list)));
    20842084      p_ref r1(i1);
    2085       cons_cell *cs=new_cons_cell();
     2085      LispList *cs=new_cons_cell();
    20862086      cs->car=i1;
    20872087      cs->cdr=i2;
     
    21182118#endif
    21192119
    2120     l_user_stack.push(((lisp_symbol *)var_name)->value);
     2120    l_user_stack.push(((LispSymbol *)var_name)->value);
    21212121    tmp=eval(CAR(CDR(CAR(var_list))));   
    2122     ((lisp_symbol *)var_name)->value=tmp;
     2122    ((LispSymbol *)var_name)->value=tmp;
    21232123    var_list=CDR(var_list);
    21242124      }
     
    21372137      {
    21382138    void *var_name=CAR(CAR(var_list));
    2139     ((lisp_symbol *)var_name)->value=l_user_stack.sdata[cur_stack++];
     2139    ((LispSymbol *)var_name)->value=l_user_stack.sdata[cur_stack++];
    21402140    var_list=CDR(var_list);
    21412141      }
     
    21662166      intptr_t a=cache.reg_lisp_block(lcar(lcdr(arg_list)));
    21672167      intptr_t b=cache.reg_lisp_block(block_list);
    2168       lisp_user_function *ufun=new_lisp_user_function(a, b);
     2168      LispUserFunction *ufun=new_lisp_user_function(a, b);
    21692169#else
    2170       lisp_user_function *ufun=new_lisp_user_function(lcar(lcdr(arg_list)), block_list);
     2170      LispUserFunction *ufun=new_lisp_user_function(lcar(lcdr(arg_list)), block_list);
    21712171#endif
    21722172      set_symbol_function(symbol, ufun);
     
    22162216      {
    22172217        case L_CHARACTER :
    2218         { ret=new_lisp_number(((lisp_character *)i)->ch); } break;
     2218        { ret=new_lisp_number(((LispChar *)i)->ch); } break;
    22192219        case L_STRING :
    22202220        {  ret=new_lisp_number(*lstring_value(i)); } break;
     
    22372237    exit(0);
    22382238      }
    2239       ret=new_lisp_character(((lisp_number *)i)->num);
     2239      ret=new_lisp_character(((LispNumber *)i)->num);
    22402240    } break;
    22412241    case SYS_FUNC_COND:
     
    22822282    {
    22832283      void *n1=eval(CAR(arg_list));
    2284       ret=eval_function((lisp_symbol *)n1, CDR(arg_list));
     2284      ret=eval_function((LispSymbol *)n1, CDR(arg_list));
    22852285    } break;
    22862286    case SYS_FUNC_GT:
     
    23322332      }
    23332333#endif
    2334       ret=((lisp_symbol *)symb)->name;
     2334      ret=((LispSymbol *)symb)->name;
    23352335    break;
    23362336    case SYS_FUNC_TRACE:
     
    24972497    {
    24982498      case L_SYMBOL :
    2499       { ((lisp_symbol *)sym)->value=new_lisp_number(x); } break;
     2499      { ((LispSymbol *)sym)->value=new_lisp_number(x); } break;
    25002500      case L_CONS_CELL :
    25012501      {
     
    25102510#endif
    25112511        x=lnumber_value(eval(CAR(CDR(sym))));
    2512         ((lisp_symbol *)sym)->value=new_lisp_number(x);
     2512        ((LispSymbol *)sym)->value=new_lisp_number(x);
    25132513      } break;
    25142514      default :
     
    25492549      {   
    25502550    for (void *s=symbol_list;s;s=CDR(s))       
    2551       fprintf(fp, "%8d  %s\n", ((lisp_symbol *)(CAR(s)))->call_counter,
    2552           lstring_value(((lisp_symbol *)(CAR(s)))->name));
     2551      fprintf(fp, "%8d  %s\n", ((LispSymbol *)(CAR(s)))->call_counter,
     2552          lstring_value(((LispSymbol *)(CAR(s)))->name));
    25532553    fclose(fp);
    25542554      }
     
    26772677    {
    26782678      void *v=eval(CAR(arg_list));
    2679       if (item_type(v)!=L_NUMBER || (((lisp_number *)v)->num!=0))
     2679      if (item_type(v)!=L_NUMBER || (((LispNumber *)v)->num!=0))
    26802680        ret=NULL;
    26812681      else ret=true_symbol;
     
    28172817                next=l1;
    28182818                while (next) { l1=next; next=lcdr(next); }
    2819                 ((cons_cell *)l1)->cdr=eval(CAR(arg_list));   
     2819                ((LispList *)l1)->cdr=eval(CAR(arg_list));   
    28202820                arg_list=CDR(arg_list);
    28212821      } while (arg_list);
     
    28522852        lbreak("substr : bad x1 or x2 value");
    28532853
    2854       lisp_string *s=new_lisp_string(x2-x1+2);
     2854      LispString *s=new_lisp_string(x2-x1+2);
    28552855      if (x2-x1)
    28562856        memcpy(lstring_value(s), lstring_value(st)+x1, x2-x1+1);
     
    28752875
    28762876    default :
    2877     { dprintf("Undefined system function number %d\n", ((lisp_sys_function *)fun)->fun_number); }
     2877    { dprintf("Undefined system function number %d\n", ((LispSysFunction *)fun)->fun_number); }
    28782878  }
    28792879  return ret;
     
    28982898
    28992899
    2900 void *eval_user_fun(lisp_symbol *sym, void *arg_list)
     2900void *eval_user_fun(LispSymbol *sym, void *arg_list)
    29012901{
    29022902  void *ret=NULL;
     
    29162916
    29172917
    2918   lisp_user_function *fun=(lisp_user_function *)(((lisp_symbol *)sym)->function);
     2918  LispUserFunction *fun=(LispUserFunction *)(((LispSymbol *)sym)->function);
    29192919
    29202920#ifdef TYPE_CHECKING
     
    29472947  for (;f_arg;f_arg=CDR(f_arg))
    29482948  {
    2949     lisp_symbol *s = (lisp_symbol *)CAR(f_arg);
     2949    LispSymbol *s = (LispSymbol *)CAR(f_arg);
    29502950    l_user_stack.push(s->value);
    29512951  }
     
    29682968    // now store all the values and put them into the symbols
    29692969    for (f_arg=fun_arg_list;f_arg;f_arg=CDR(f_arg))
    2970       ((lisp_symbol *)CAR(f_arg))->value=l_user_stack.sdata[i++];
     2970      ((LispSymbol *)CAR(f_arg))->value=l_user_stack.sdata[i++];
    29712971
    29722972    l_user_stack.son=new_start;
     
    29882988  long cur_stack=stack_start;
    29892989  for (f_arg=fun_arg_list;f_arg;f_arg=CDR(f_arg))
    2990     ((lisp_symbol *)CAR(f_arg))->value=l_user_stack.sdata[cur_stack++];
     2990    ((LispSymbol *)CAR(f_arg))->value=l_user_stack.sdata[cur_stack++];
    29912991
    29922992  l_user_stack.son=stack_start;
     
    29942994#ifdef L_PROFILE
    29952995  time_marker end;
    2996   ((lisp_symbol *)sym)->time_taken+=end.diff_time(&start);
     2996  ((LispSymbol *)sym)->time_taken+=end.diff_time(&start);
    29972997#endif
    29982998
     
    30483048                  ret=lookup_symbol_value(prog);
    30493049                  if (item_type(ret)==L_OBJECT_VAR)
    3050                     ret=l_obj_get(((lisp_object_var *)ret)->number);
     3050                    ret=l_obj_get(((LispObjectVar *)ret)->number);
    30513051                }
    30523052      } break;
    30533053      case L_CONS_CELL :
    30543054      {
    3055         ret=eval_function((lisp_symbol *)CAR(prog), CDR(prog));
     3055        ret=eval_function((LispSymbol *)CAR(prog), CDR(prog));
    30563056      }
    30573057      break;
     
    31603160void *symbol_name(void *symbol)
    31613161{
    3162   return ((lisp_symbol *)symbol)->name;
     3162  return ((LispSymbol *)symbol)->name;
    31633163}
    31643164
     
    31743174  }
    31753175#endif
    3176   if (((lisp_symbol *)symbol)->value!=l_undefined &&
    3177       item_type(((lisp_symbol *)symbol)->value)==L_NUMBER)
    3178     ((lisp_number *)((lisp_symbol *)symbol)->value)->num=num;
     3176  if (((LispSymbol *)symbol)->value!=l_undefined &&
     3177      item_type(((LispSymbol *)symbol)->value)==L_NUMBER)
     3178    ((LispNumber *)((LispSymbol *)symbol)->value)->num=num;
    31793179  else
    3180     ((lisp_symbol *)(symbol))->value=new_lisp_number(num);
    3181 
    3182   return ((lisp_symbol *)(symbol))->value;
     3180    ((LispSymbol *)(symbol))->value=new_lisp_number(num);
     3181
     3182  return ((LispSymbol *)(symbol))->value;
    31833183}
    31843184
     
    31933193  }
    31943194#endif
    3195   ((lisp_symbol *)(symbol))->value=value;
     3195  ((LispSymbol *)(symbol))->value=value;
    31963196  return value;
    31973197}
     
    32073207  }
    32083208#endif
    3209   return ((lisp_symbol *)symbol)->function;
     3209  return ((LispSymbol *)symbol)->function;
    32103210}
    32113211
     
    32203220  }
    32213221#endif
    3222   return ((lisp_symbol *)symbol)->value;
    3223 }
    3224 
    3225 
    3226 
    3227 
    3228 
    3229 
     3222  return ((LispSymbol *)symbol)->value;
     3223}
     3224
     3225
     3226
     3227
     3228
     3229
  • abuse/trunk/src/lisp/lisp.h

    r481 r482  
    4343       L_FIXED_POINT, L_COLLECTED_OBJECT };
    4444
    45 typedef uint64_t ltype;    // make sure structures aren't packed differently on various compiler
     45typedef uint32_t ltype;    // make sure structures aren't packed differently on various compiler
    4646                       // and sure that word, etc are word aligned
    4747
    48 struct lisp_object_var
    49 {
    50   ltype type;
    51   long number;
    52 } ;
    53 
    54 struct cons_cell
    55 {
    56   ltype type;
    57   void *cdr,*car;
    58 } ;
    59 
    60 struct lisp_number
    61 {
    62   ltype type;
    63   long num;
    64 } ;
    65 
    66 struct lisp_collected_object
    67 {
    68   ltype type;
    69   void *new_reference;
    70 } ;
    71 
    72 struct lisp_symbol
    73 {
    74   ltype type;
     48struct LispObject
     49{
     50    ltype type;
     51};
     52
     53struct LispObjectVar : LispObject
     54{
     55    long number;
     56};
     57
     58struct LispList : LispObject
     59{
     60    void *cdr, *car;
     61};
     62
     63struct LispNumber : LispObject
     64{
     65    long num;
     66};
     67
     68struct LispRedirect : LispObject
     69{
     70    void *new_reference;
     71};
     72
     73struct LispSymbol : LispObject
     74{
    7575#ifdef L_PROFILE
    76   float time_taken;
    77 #endif
    78   void *value, *function, *name;
    79   lisp_symbol *left,*right;       // tree structure
    80 } ;
    81 
    82 struct lisp_sys_function
    83 {
    84   ltype type;
    85   short min_args,max_args,
    86         fun_number;
    87 } ;
    88 
    89 struct lisp_user_function
    90 {
    91   ltype type;
     76    float time_taken;
     77#endif
     78    void *value, *function, *name;
     79    LispSymbol *left, *right; // tree structure
     80};
     81
     82struct LispSysFunction : LispObject
     83{
     84    short min_args, max_args;
     85    short fun_number;
     86};
     87
     88struct LispUserFunction : LispObject
     89{
    9290#ifndef NO_LIBS
    93   intptr_t alist,blist;      // id for cached blocks
     91    intptr_t alist, blist;      // id for cached blocks
    9492#else
    95   void *arg_list,*block_list;
    96 #endif
    97 } ;
    98 
    99 struct lisp_1d_array
    100 {
    101   ltype type;
    102   unsigned short size;
    103   // size * sizeof (void *) follows1
    104 } ;
    105 
    106 struct lisp_string
    107 {
    108   ltype type;
    109 } ;
    110 
    111 struct lisp_character
    112 {
    113   ltype type;
    114   int16_t pad;
    115   uint16_t ch;
    116 } ;
    117 
    118 struct lisp_pointer
    119 {
    120   ltype type;
    121   void *addr;
    122 } ;
    123 
    124 
    125 struct lisp_fixed_point
    126 {
    127   ltype type;
    128   int32_t x;
    129 } ;
    130 
    131 static inline void *&CAR(void *x) { return ((cons_cell *)x)->car; }
    132 static inline void *&CDR(void *x) { return ((cons_cell *)x)->cdr; }
     93    void *arg_list, *block_list;
     94#endif
     95};
     96
     97struct LispArray : LispObject
     98{
     99    unsigned short size;
     100    // size * sizeof (void *) follows1
     101};
     102
     103struct LispString : LispObject
     104{
     105};
     106
     107struct LispChar : LispObject
     108{
     109    int16_t pad;
     110    uint16_t ch;
     111};
     112
     113struct LispPointer : LispObject
     114{
     115    void *addr;
     116};
     117
     118
     119struct LispFixedPoint : LispObject
     120{
     121    int32_t x;
     122};
     123
     124static inline void *&CAR(void *x) { return ((LispList *)x)->car; }
     125static inline void *&CDR(void *x) { return ((LispList *)x)->cdr; }
    133126
    134127void perm_space();
     
    147140void *lisp_eq(void *n1, void *n2);
    148141void *lisp_equal(void *n1, void *n2);
    149 lisp_symbol *find_symbol(char const *name);
     142LispSymbol *find_symbol(char const *name);
    150143long list_length(void *i);
    151144void lprint(void *i);
    152145void *eval(void *prog);
    153146void *eval_block(void *list);
    154 void *eval_function(lisp_symbol *sym, void *arg_list);
    155 void *eval_user_fun(lisp_symbol *sym, void *arg_list);
     147void *eval_function(LispSymbol *sym, void *arg_list);
     148void *eval_user_fun(LispSymbol *sym, void *arg_list);
    156149void *compile(char const *&s);
    157150void *symbol_value(void *symbol);
     
    163156void resize_tmp(int new_size);
    164157void resize_perm(int new_size);
    165 lisp_symbol *make_find_symbol(char const *name);
     158LispSymbol *make_find_symbol(char const *name);
    166159
    167160void push_onto_list(void *object, void *&list);
    168 lisp_symbol *add_c_object(void *symbol, int16_t number);
    169 lisp_symbol *add_c_function(char const *name, short min_args, short max_args, short number);
    170 lisp_symbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number);
    171 lisp_symbol *add_lisp_function(char const *name, short min_args, short max_args, short number);
     161LispSymbol *add_c_object(void *symbol, int16_t number);
     162LispSymbol *add_c_function(char const *name, short min_args, short max_args, short number);
     163LispSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number);
     164LispSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number);
    172165int read_ltoken(char *&s, char *buffer);
    173 cons_cell *new_cons_cell();
     166LispList *new_cons_cell();
    174167void print_trace_stack(int max_levels);
    175168
    176169
    177 lisp_number *new_lisp_number(long num);
    178 lisp_pointer *new_lisp_pointer(void *addr);
    179 lisp_character *new_lisp_character(uint16_t ch);
    180 lisp_string *new_lisp_string(char const *string);
    181 lisp_string *new_lisp_string(char const *string, int length);
    182 lisp_string *new_lisp_string(int length);
    183 lisp_fixed_point *new_lisp_fixed_point(int32_t x);
    184 lisp_object_var *new_lisp_object_var(int16_t number);
    185 lisp_1d_array   *new_lisp_1d_array(int size, void *rest);
    186 lisp_sys_function *new_lisp_sys_function(int min_args, int max_args, int fun_number);
    187 lisp_sys_function *new_lisp_c_function(int min_args, int max_args, int fun_number);
    188 lisp_sys_function *new_lisp_c_bool(int min_args, int max_args, int fun_number);
     170LispNumber *new_lisp_number(long num);
     171LispPointer *new_lisp_pointer(void *addr);
     172LispChar *new_lisp_character(uint16_t ch);
     173LispString *new_lisp_string(char const *string);
     174LispString *new_lisp_string(char const *string, int length);
     175LispString *new_lisp_string(int length);
     176LispFixedPoint *new_lisp_fixed_point(int32_t x);
     177LispObjectVar *new_lisp_object_var(int16_t number);
     178LispArray   *new_lisp_1d_array(int size, void *rest);
     179LispSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number);
     180LispSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number);
     181LispSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number);
    189182
    190183#ifdef NO_LIBS
    191 lisp_user_function *new_lisp_user_function(void *arg_list, void *block_list);
     184LispUserFunction *new_lisp_user_function(void *arg_list, void *block_list);
    192185#else
    193 lisp_user_function *new_lisp_user_function(intptr_t arg_list, intptr_t block_list);
    194 #endif
    195 
    196 lisp_sys_function *new_user_lisp_function(int min_args, int max_args, int fun_number);
     186LispUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list);
     187#endif
     188
     189LispSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number);
    197190
    198191int end_of_program(char *s);
     
    200193void lisp_init(long perm_size, long tmp_size);
    201194void lisp_uninit();
    202 extern lisp_symbol *lsym_root;
     195extern LispSymbol *lsym_root;
    203196
    204197extern uint8_t *space[4], *free_space[4];
  • abuse/trunk/src/lisp/lisp_gc.cpp

    r481 r482  
    8686static void *collect_array(void *x)
    8787{
    88   long s = ((lisp_1d_array *)x)->size;
    89   lisp_1d_array *a = new_lisp_1d_array(s, NULL);
     88  long s = ((LispArray *)x)->size;
     89  LispArray *a = new_lisp_1d_array(s, NULL);
    9090  void **src, **dst;
    91   src = (void **)(((lisp_1d_array *)x)+1);
     91  src = (void **)(((LispArray *)x)+1);
    9292  dst = (void **)(a+1);
    9393  for (int i = 0; i<s; i++)
     
    9999inline void *collect_cons_cell(void *x)
    100100{
    101   cons_cell *last = NULL, *first = NULL;
     101  LispList *last = NULL, *first = NULL;
    102102  if (!x) return x;
    103103  for (; x && item_type(x) == L_CONS_CELL; )
    104104  {
    105     cons_cell *p = new_cons_cell();
    106     void *old_car = ((cons_cell *)x)->car;
    107     void *old_cdr = ((cons_cell *)x)->cdr;
     105    LispList *p = new_cons_cell();
     106    void *old_car = ((LispList *)x)->car;
     107    void *old_cdr = ((LispList *)x)->cdr;
    108108    void *old_x = x;
    109109    x = CDR(x);
    110     ((lisp_collected_object *)old_x)->type = L_COLLECTED_OBJECT;
    111     ((lisp_collected_object *)old_x)->new_reference = p;
     110    ((LispRedirect *)old_x)->type = L_COLLECTED_OBJECT;
     111    ((LispRedirect *)old_x)->new_reference = p;
    112112
    113113    p->car = collect_object(old_car);
     
    136136        break;
    137137      case L_NUMBER:
    138         ret = new_lisp_number(((lisp_number *)x)->num);
     138        ret = new_lisp_number(((LispNumber *)x)->num);
    139139        break;
    140140      case L_SYS_FUNCTION:
    141         ret = new_lisp_sys_function(((lisp_sys_function *)x)->min_args,
    142                                     ((lisp_sys_function *)x)->max_args,
    143                                     ((lisp_sys_function *)x)->fun_number);
     141        ret = new_lisp_sys_function(((LispSysFunction *)x)->min_args,
     142                                    ((LispSysFunction *)x)->max_args,
     143                                    ((LispSysFunction *)x)->fun_number);
    144144        break;
    145145      case L_USER_FUNCTION:
    146146#ifndef NO_LIBS
    147         ret = new_lisp_user_function(((lisp_user_function *)x)->alist,
    148                                      ((lisp_user_function *)x)->blist);
     147        ret = new_lisp_user_function(((LispUserFunction *)x)->alist,
     148                                     ((LispUserFunction *)x)->blist);
    149149
    150150#else
    151151        {
    152           void *arg = collect_object(((lisp_user_function *)x)->arg_list);
    153           void *block = collect_object(((lisp_user_function *)x)->block_list);
     152          void *arg = collect_object(((LispUserFunction *)x)->arg_list);
     153          void *block = collect_object(((LispUserFunction *)x)->block_list);
    154154          ret = new_lisp_user_function(arg, block);
    155155        }
     
    163163        break;
    164164      case L_C_FUNCTION:
    165         ret = new_lisp_c_function(((lisp_sys_function *)x)->min_args,
    166                                   ((lisp_sys_function *)x)->max_args,
    167                                   ((lisp_sys_function *)x)->fun_number);
     165        ret = new_lisp_c_function(((LispSysFunction *)x)->min_args,
     166                                  ((LispSysFunction *)x)->max_args,
     167                                  ((LispSysFunction *)x)->fun_number);
    168168        break;
    169169      case L_C_BOOL:
    170         ret = new_lisp_c_bool(((lisp_sys_function *)x)->min_args,
    171                               ((lisp_sys_function *)x)->max_args,
    172                               ((lisp_sys_function *)x)->fun_number);
     170        ret = new_lisp_c_bool(((LispSysFunction *)x)->min_args,
     171                              ((LispSysFunction *)x)->max_args,
     172                              ((LispSysFunction *)x)->fun_number);
    173173        break;
    174174      case L_L_FUNCTION:
    175         ret = new_user_lisp_function(((lisp_sys_function *)x)->min_args,
    176                                      ((lisp_sys_function *)x)->max_args,
    177                                      ((lisp_sys_function *)x)->fun_number);
     175        ret = new_user_lisp_function(((LispSysFunction *)x)->min_args,
     176                                     ((LispSysFunction *)x)->max_args,
     177                                     ((LispSysFunction *)x)->fun_number);
    178178        break;
    179179      case L_POINTER:
     
    187187        break;
    188188      case L_CONS_CELL:
    189         ret = collect_cons_cell((cons_cell *)x);
     189        ret = collect_cons_cell((LispList *)x);
    190190        break;
    191191      case L_OBJECT_VAR:
    192         ret = new_lisp_object_var(((lisp_object_var *)x)->number);
     192        ret = new_lisp_object_var(((LispObjectVar *)x)->number);
    193193        break;
    194194      case L_COLLECTED_OBJECT:
    195         ret = ((lisp_collected_object *)x)->new_reference;
     195        ret = ((LispRedirect *)x)->new_reference;
    196196        break;
    197197      default:
     
    202202        break;
    203203    }
    204     ((lisp_collected_object *)x)->type = L_COLLECTED_OBJECT;
    205     ((lisp_collected_object *)x)->new_reference = ret;
     204    ((LispRedirect *)x)->type = L_COLLECTED_OBJECT;
     205    ((LispRedirect *)x)->new_reference = ret;
    206206  }
    207207  else if ((uint8_t *)x < collected_start || (uint8_t *)x >= collected_end)
     
    210210    {
    211211      for (; x && item_type(x) == L_CONS_CELL; x = CDR(x))
    212         ((cons_cell *)x)->car = collect_object(((cons_cell *)x)->car);
     212        ((LispList *)x)->car = collect_object(((LispList *)x)->car);
    213213      if (x)
    214         ((cons_cell *)x)->cdr = collect_object(((cons_cell *)x)->cdr);
     214        ((LispList *)x)->cdr = collect_object(((LispList *)x)->cdr);
    215215    }
    216216  }
     
    219219}
    220220
    221 static void collect_symbols(lisp_symbol *root)
     221static void collect_symbols(LispSymbol *root)
    222222{
    223223  if (root)
  • abuse/trunk/src/lisp/lisp_opt.cpp

    r481 r482  
    9595{
    9696  l_undefined=make_find_symbol(":UNDEFINED");  // this needs to be defined first
    97   ((lisp_symbol *)l_undefined)->function=NULL;  // collection problems result if we don't do this
    98   ((lisp_symbol *)l_undefined)->value=NULL;
     97  ((LispSymbol *)l_undefined)->function=NULL;  // collection problems result if we don't do this
     98  ((LispSymbol *)l_undefined)->value=NULL;
    9999
    100100
  • abuse/trunk/src/ltree.cpp

    r129 r482  
    1010#include "config.h"
    1111
    12 lisp_symbol *find_symbol(char *name)
     12LispSymbol *find_symbol(char *name)
    1313{
    14   lisp_symbol *p=lsym_root;
     14  LispSymbol *p=lsym_root;
    1515  while (p)
    1616  {
    17     int cmp=strcmp(name,((char *)((lisp_symbol *)cs->car)->name)+sizeof(lisp_string));
     17    int cmp=strcmp(name,((char *)((LispSymbol *)cs->car)->name)+sizeof(LispString));
    1818    if (cmp==0) return p;
    1919    else if (cmp<0) p=p->left;
     
    2525
    2626
    27 lisp_symbol *make_find_symbol(char *name)
     27LispSymbol *make_find_symbol(char *name)
    2828{
    29   lisp_symbol *p=lsym_root;
    30   lisp_symbol **parent=&lsym_root;
     29  LispSymbol *p=lsym_root;
     30  LispSymbol **parent=&lsym_root;
    3131  while (p)
    3232  {
    33     int cmp=strcmp(name,((char *)((lisp_symbol *)cs->car)->name)+sizeof(lisp_string));
     33    int cmp=strcmp(name,((char *)((LispSymbol *)cs->car)->name)+sizeof(LispString));
    3434    if (cmp==0) return p;
    3535    else if (cmp<0)
     
    4545  }
    4646
    47   p=malloc(sizeof(lisp_symbol));
     47  p=malloc(sizeof(LispSymbol));
    4848  p->type=L_SYMBOL;
    4949  p->name=new_lisp_string(name);
  • abuse/trunk/src/objects.cpp

    r481 r482  
    108108    {
    109109      return lvars[figures[otype]->var_index[i]];
    110 /*      lisp_object_var *cobj=(lisp_object_var *)symbol_value(figures[otype]->vars[i]);
     110/*      LispObjectVar *cobj=(LispObjectVar *)symbol_value(figures[otype]->vars[i]);
    111111      character_type *t=figures[otype];
    112112      int number=cobj->number;
     
    265265
    266266    void *m=mark_heap(TMP_SPACE);
    267     eval_function((lisp_symbol *)ns,NULL);
     267    eval_function((LispSymbol *)ns,NULL);
    268268    restore_heap(m,TMP_SPACE);
    269269
     
    279279        current_object = this;
    280280        void *m = mark_heap( TMP_SPACE );
    281         (void)eval_function( (lisp_symbol *)ns, NULL );
     281        (void)eval_function( (LispSymbol *)ns, NULL );
    282282        restore_heap( m, TMP_SPACE );
    283283    }
     
    419419      prof1=new time_marker;
    420420
    421     Cell *ret=(Cell *)eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_AI),NULL);
     421    Cell *ret=(Cell *)eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_AI),NULL);
    422422    if (profiling())
    423423    {
     
    492492    l_ptr_stack.push(&am);
    493493
    494     ((cons_cell *)am)->car=new_lisp_number(amount);
     494    ((LispList *)am)->car=new_lisp_number(amount);
    495495
    496496    frm=new_cons_cell();
    497497    l_ptr_stack.push(&frm);
    498498
    499     ((cons_cell *)frm)->car=new_lisp_pointer(from);
     499    ((LispList *)frm)->car=new_lisp_pointer(from);
    500500
    501501    hx=new_cons_cell();
    502502    l_ptr_stack.push(&hx);
    503503
    504     ((cons_cell *)hx)->car=new_lisp_number(hitx);
     504    ((LispList *)hx)->car=new_lisp_number(hitx);
    505505
    506506    hy=new_cons_cell();
    507507    l_ptr_stack.push(&hy);
    508     ((cons_cell *)hy)->car=new_lisp_number(hity);
     508    ((LispList *)hy)->car=new_lisp_number(hity);
    509509
    510510    px=new_cons_cell();
    511511    l_ptr_stack.push(&px);
    512     ((cons_cell *)px)->car=new_lisp_number(push_xvel);
     512    ((LispList *)px)->car=new_lisp_number(push_xvel);
    513513
    514514    py=new_cons_cell();
    515515    l_ptr_stack.push(&py);
    516     ((cons_cell *)py)->car=new_lisp_number(push_yvel);
    517 
    518 
    519     ((cons_cell *)am)->cdr=frm;
    520     ((cons_cell *)frm)->cdr=hx;
    521     ((cons_cell *)hx)->cdr=hy;
    522     ((cons_cell *)hy)->cdr=px;
    523     ((cons_cell *)px)->cdr=py;
     516    ((LispList *)py)->car=new_lisp_number(push_yvel);
     517
     518
     519    ((LispList *)am)->cdr=frm;
     520    ((LispList *)frm)->cdr=hx;
     521    ((LispList *)hx)->cdr=hy;
     522    ((LispList *)hy)->cdr=px;
     523    ((LispList *)px)->cdr=py;
    524524
    525525    time_marker *prof1=NULL;
     
    527527      prof1=new time_marker;
    528528
    529     eval_user_fun((lisp_symbol *)d,am);
     529    eval_user_fun((LispSymbol *)d,am);
    530530    if (profiling())
    531531    {
     
    642642      prof1=new time_marker;
    643643
    644     eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_DRAW),NULL);
     644    eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_DRAW),NULL);
    645645    if (profiling())
    646646    {
     
    669669      prof1=new time_marker;
    670670
    671     eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_MAP_DRAW),NULL);
     671    eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_MAP_DRAW),NULL);
    672672    if (profiling())
    673673    {
     
    11761176      prof1=new time_marker;
    11771177
    1178     eval_function((lisp_symbol *)figures[type]->get_fun(OFUN_CONSTRUCTOR),NULL);
     1178    eval_function((LispSymbol *)figures[type]->get_fun(OFUN_CONSTRUCTOR),NULL);
    11791179    if (profiling())
    11801180    {
     
    12231223    lcx=new_cons_cell();
    12241224    l_ptr_stack.push(&lcx);
    1225     ((cons_cell *)lcx)->car=new_lisp_number(cx);
     1225    ((LispList *)lcx)->car=new_lisp_number(cx);
    12261226
    12271227    lcy=new_cons_cell();
    12281228    l_ptr_stack.push(&lcy);
    1229     ((cons_cell *)lcy)->car=new_lisp_number(cy);
     1229    ((LispList *)lcy)->car=new_lisp_number(cy);
    12301230
    12311231    lb=new_cons_cell();
    12321232    l_ptr_stack.push(&lb);
    1233     ((cons_cell *)lb)->car=new_lisp_number(button);
    1234 
    1235 
    1236     ((cons_cell *)lcx)->cdr=lcy;
    1237     ((cons_cell *)lcy)->cdr=lb;
     1233    ((LispList *)lb)->car=new_lisp_number(button);
     1234
     1235
     1236    ((LispList *)lcx)->cdr=lcy;
     1237    ((LispList *)lcy)->cdr=lb;
    12381238
    12391239    void *m=mark_heap(TMP_SPACE);
     
    12431243      prof1=new time_marker;
    12441244
    1245     void *r=eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_MOVER),
     1245    void *r=eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_MOVER),
    12461246              (void *)lcx);
    12471247    if (profiling())
     
    16041604        prof1=new time_marker;
    16051605
    1606       eval_user_fun((lisp_symbol *)f,NULL);
     1606      eval_user_fun((LispSymbol *)f,NULL);
    16071607
    16081608      if (profiling())
     
    16471647      prof1=new time_marker;
    16481648
    1649     eval_function((lisp_symbol *)figures[new_type]->get_fun(OFUN_CONSTRUCTOR),NULL);
     1649    eval_function((LispSymbol *)figures[new_type]->get_fun(OFUN_CONSTRUCTOR),NULL);
    16501650    if (profiling())
    16511651    {
  • abuse/trunk/src/particle.cpp

    r481 r482  
    6161int defun_pseq(void *args)
    6262{
    63   lisp_symbol *sym=(lisp_symbol *)lcar(args);
     63  LispSymbol *sym=(LispSymbol *)lcar(args);
    6464  if (item_type(sym)!=L_SYMBOL)
    6565  {
  • abuse/trunk/src/view.cpp

    r481 r482  
    334334/*    if( DEFINEDP( symbol_function( l_get_local_input ) ) )
    335335    {
    336         void *ret = eval_function((lisp_symbol *)l_get_local_input, NULL );
     336        void *ret = eval_function((LispSymbol *)l_get_local_input, NULL );
    337337        sug_x = lnumber_value( CAR( ret ) );
    338338        ret = CDR( ret );
     
    461461      void *list=NULL;
    462462      push_onto_list(new_lisp_string(chat_buf),list);
    463       eval_function((lisp_symbol *)l_chat_input,list);
     463      eval_function((LispSymbol *)l_chat_input,list);
    464464      restore_heap(m,TMP_SPACE);
    465465
     
    883883      game_object *o=current_object;
    884884      current_object=focus;
    885       eval_user_fun((lisp_symbol *)figures[focus->otype]->get_fun(OFUN_CONSTRUCTOR),NULL);
     885      eval_user_fun((LispSymbol *)figures[focus->otype]->get_fun(OFUN_CONSTRUCTOR),NULL);
    886886      current_object=o;
    887887    }
Note: See TracChangeset for help on using the changeset viewer.