Changeset 636


Ignore:
Timestamp:
May 11, 2011, 1:26:15 AM (7 years ago)
Author:
Sam Hocevar
Message:

lisp: merge the Lisp and LispGC classes and improve coding style.

Location:
abuse/trunk/src
Files:
9 edited

Legend:

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

    r635 r636  
    208208     if so report a conflict if any occur */
    209209  LSymbol *s=(LSymbol *)symbol;
    210   if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
     210  if (DEFINEDP(s->m_value) && (item_type(s->m_value)!=L_OBJECT_VAR))
    211211  {
    212212    ((LObject *)symbol)->Print();
    213213    lbreak("symbol already has a value, cannot instantiate an object varible");
    214214    exit(0);
    215   } else if (DEFINEDP(s->value))
    216   {
    217     int index=((LObjectVar *)s->value)->index;
     215  } else if (DEFINEDP(s->m_value))
     216  {
     217    int index = ((LObjectVar *)s->m_value)->m_index;
    218218    if (index<tiv)
    219219    {
     
    337337    if (f==l_abil)
    338338    {
    339       void *l=CDR(CAR(field));
     339      LObject *l = CDR(CAR(field));
    340340      PtrRef r4(l);
    341341      for (i=0; i<TOTAL_ABILITIES; i++)
    342342      {
    343     Cell *ab=assoc(LSymbol::FindOrCreate(ability_names[i]),l);
     343    Cell *ab = LSymbol::FindOrCreate(ability_names[i])->Assoc(l);
    344344    PtrRef r5(ab);
    345345    if (!NILP(ab))
     
    348348    } else if (f==l_funs)
    349349    {
    350       void *l=CDR(CAR(field));
     350      LObject *l = CDR(CAR(field));
    351351      PtrRef r4(l);
    352352      for (i=0; i<TOTAL_OFUNS; i++)
    353353      {
    354     Cell *ab=assoc(LSymbol::FindOrCreate(ofun_names[i]),l);
     354    Cell *ab = LSymbol::FindOrCreate(ofun_names[i])->Assoc(l);
    355355    PtrRef r5(ab);
    356356    if (!NILP(ab) && lcar(lcdr(ab)))
     
    359359    } else if (f==l_flags)
    360360    {
    361       void *l=CDR(CAR(field));
     361      LObject *l = CDR(CAR(field));
    362362      PtrRef r4(l);
    363363      for (i=0; i<TOTAL_CFLAGS; i++)
    364364      {
    365     Cell *ab=assoc(LSymbol::FindOrCreate(cflag_names[i]),l);
     365
     366    Cell *ab = LSymbol::FindOrCreate(cflag_names[i])->Assoc(l);
    366367    PtrRef r5(ab);
    367368    if (!NILP(ab) && lcar(lcdr(ab))->Eval())
     
    456457
    457458
    458   Cell *mrph=assoc(l_morph,desc);     // check for morph info
     459  Cell *mrph = l_morph->Assoc(desc);     // check for morph info
    459460  morph_power=0;
    460461  if (!NILP(mrph))
     
    465466  } else morph_mask=-1;
    466467
    467   Cell *sa=assoc(l_state_art,desc);
     468  Cell *sa = l_state_art->Assoc(desc);
    468469  if (NILP(sa))
    469470  {
     
    484485  }
    485486
    486   Cell *range=assoc(l_range,desc);
     487  Cell *range = l_range->Assoc(desc);
    487488  if (!NILP(range))
    488489  {
     
    498499
    499500
    500   Cell *mf=assoc(l_fields,desc);
     501  Cell *mf = l_fields->Assoc(desc);
    501502  if (!NILP(mf))
    502503  {
     
    512513      if (find<0)
    513514      {
    514     lprint(assoc(l_fields,desc));
     515    lprint(l_fields->Assoc(desc));
    515516    printf("fields : no such var name \"%s\"\n",name);
    516517    printf("current possiblities are : \n");
     
    529530
    530531
    531   Cell *lg=assoc(l_logo,desc);
     532  Cell *lg = l_logo->Assoc(desc);
    532533  if (NILP(lg))
    533534  {
  • abuse/trunk/src/compiled.cpp

    r555 r636  
    4848  if (sym)
    4949  {
    50     if (item_type(((LSymbol *)sym)->value)!=L_NUMBER)
     50    if (item_type(((LSymbol *)sym)->m_value)!=L_NUMBER)
    5151      compile_error=1;
    5252    else
    53       return lnumber_value(((LSymbol *)sym)->value);
     53      return lnumber_value(((LSymbol *)sym)->m_value);
    5454  } else compile_error=1;
    5555  return 0;
  • abuse/trunk/src/lcache.cpp

    r555 r636  
    8484        break;
    8585    case L_CHARACTER:
    86         fp->write_uint16(lcharacter_value(level));
     86        fp->write_uint16(((LChar *)level)->GetValue());
    8787        break;
    8888    case L_STRING:
     
    126126                LList *c = LList::Create();
    127127                if (first)
    128                     last->cdr = c;
     128                    last->m_cdr = c;
    129129                else
    130130                    first = c;
    131131                last = c;
    132132            }
    133             last->cdr = (t < 0) ? (LObject *)load_block(fp) : NULL;
     133            last->m_cdr = (t < 0) ? (LObject *)load_block(fp) : NULL;
    134134
    135135            last = first;
    136             for (size_t count = abs(t); count--; last = (LList *)last->cdr)
    137                 last->car = load_block(fp);
     136            for (size_t count = abs(t); count--; last = (LList *)last->m_cdr)
     137                last->m_car = load_block(fp);
    138138            return first;
    139139        }
  • abuse/trunk/src/lisp/lisp.cpp

    r635 r636  
    191191    {
    192192        if (this == &LSpace::Perm || this == &LSpace::Tmp)
    193             LispGC::CollectSpace(this, 0);
     193            Lisp::CollectSpace(this, 0);
    194194
    195195        if (size > GetFree())
    196             LispGC::CollectSpace(this, 1);
     196            Lisp::CollectSpace(this, 1);
    197197
    198198        if (size > GetFree())
     
    228228
    229229    LArray *p = (LArray *)LSpace::Current->Alloc(size);
    230     p->type = L_1D_ARRAY;
    231     p->len = len;
     230    p->m_type = L_1D_ARRAY;
     231    p->m_len = len;
    232232    LObject **data = p->GetData();
    233233    memset(data, 0, len * sizeof(LObject *));
     
    281281
    282282    LFixedPoint *p = (LFixedPoint *)LSpace::Current->Alloc(size);
    283     p->type = L_FIXED_POINT;
    284     p->x = x;
     283    p->m_type = L_FIXED_POINT;
     284    p->m_fixed = x;
    285285    return p;
    286286}
     
    291291
    292292    LObjectVar *p = (LObjectVar *)LSpace::Current->Alloc(size);
    293     p->type = L_OBJECT_VAR;
    294     p->index = index;
     293    p->m_type = L_OBJECT_VAR;
     294    p->m_index = index;
    295295    return p;
    296296}
     
    303303
    304304    LPointer *p = (LPointer *)LSpace::Current->Alloc(size);
    305     p->type = L_POINTER;
    306     p->addr = addr;
     305    p->m_type = L_POINTER;
     306    p->m_addr = addr;
    307307    return p;
    308308}
     
    313313
    314314    LChar *c = (LChar *)LSpace::Current->Alloc(size);
    315     c->type = L_CHARACTER;
    316     c->ch = ch;
     315    c->m_type = L_CHARACTER;
     316    c->m_ch = ch;
    317317    return c;
    318318}
     
    321321{
    322322    LString *s = Create(strlen(string) + 1);
    323     strcpy(s->str, string);
     323    strcpy(s->m_str, string);
    324324    return s;
    325325}
     
    328328{
    329329    LString *s = Create(length + 1);
    330     memcpy(s->str, string, length);
    331     s->str[length] = 0;
     330    memcpy(s->m_str, string, length);
     331    s->m_str[length] = 0;
    332332    return s;
    333333}
     
    338338
    339339    LString *s = (LString *)LSpace::Current->Alloc(size);
    340     s->type = L_STRING;
    341     s->str[0] = '\0';
     340    s->m_type = L_STRING;
     341    s->m_str[0] = '\0';
    342342    return s;
    343343}
     
    350350
    351351    LUserFunction *lu = (LUserFunction *)LSpace::Current->Alloc(size);
    352     lu->type = L_USER_FUNCTION;
     352    lu->m_type = L_USER_FUNCTION;
    353353    lu->arg_list = arg_list;
    354354    lu->block_list = block_list;
     
    364364                     ? (LSysFunction *)LSpace::Gc.Alloc(size)
    365365                     : (LSysFunction *)LSpace::Perm.Alloc(size);
    366     ls->type = L_SYS_FUNCTION;
     366    ls->m_type = L_SYS_FUNCTION;
    367367    ls->min_args = min_args;
    368368    ls->max_args = max_args;
     
    374374{
    375375    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
    376     ls->type = L_C_FUNCTION;
     376    ls->m_type = L_C_FUNCTION;
    377377    return ls;
    378378}
     
    381381{
    382382    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
    383     ls->type = L_C_BOOL;
     383    ls->m_type = L_C_BOOL;
    384384    return ls;
    385385}
     
    388388{
    389389    LSysFunction *ls = new_lisp_sys_function(min_args, max_args, fun_number);
    390     ls->type = L_L_FUNCTION;
     390    ls->m_type = L_L_FUNCTION;
    391391    return ls;
    392392}
     
    399399    PtrRef ref(s);
    400400
    401     s->type = L_SYMBOL;
    402     s->name = LString::Create(name);
    403     s->value = l_undefined;
    404     s->function = l_undefined;
     401    s->m_type = L_SYMBOL;
     402    s->m_name = LString::Create(name);
     403    s->m_value = l_undefined;
     404    s->m_function = l_undefined;
    405405#ifdef L_PROFILE
    406406    s->time_taken = 0;
     
    414414
    415415    LNumber *n = (LNumber *)LSpace::Current->Alloc(size);
    416     n->type = L_NUMBER;
    417     n->num = num;
     416    n->m_type = L_NUMBER;
     417    n->m_num = num;
    418418    return n;
    419419}
     
    424424
    425425    LList *c = (LList *)LSpace::Current->Alloc(size);
    426     c->type = L_CONS_CELL;
    427     c->car = NULL;
    428     c->cdr = NULL;
     426    c->m_type = L_CONS_CELL;
     427    c->m_car = NULL;
     428    c->m_cdr = NULL;
    429429    return c;
    430430}
     
    477477  }
    478478#endif
    479   return ((LPointer *)lpointer)->addr;
     479  return ((LPointer *)lpointer)->m_addr;
    480480}
    481481
    482482int32_t lnumber_value(void *lnumber)
    483483{
    484   switch (item_type(lnumber))
    485   {
    486     case L_NUMBER :
    487       return ((LNumber *)lnumber)->num;
    488     case L_FIXED_POINT :
    489       return (((LFixedPoint *)lnumber)->x)>>16;
    490     case L_STRING :
    491       return (uint8_t)*lstring_value(lnumber);
    492     case L_CHARACTER :
    493       return lcharacter_value(lnumber);
    494     default :
    495     {
    496       ((LObject *)lnumber)->Print();
    497       lbreak(" is not a number\n");
    498       exit(0);
    499     }
    500   }
    501   return 0;
     484    switch (item_type(lnumber))
     485    {
     486    case L_NUMBER:
     487        return ((LNumber *)lnumber)->m_num;
     488    case L_FIXED_POINT:
     489        return ((LFixedPoint *)lnumber)->m_fixed >> 16;
     490    case L_STRING:
     491        return (uint8_t)*lstring_value(lnumber);
     492    case L_CHARACTER:
     493        return ((LChar *)lnumber)->m_ch;
     494    default:
     495        ((LObject *)lnumber)->Print();
     496        lbreak(" is not a number\n");
     497        exit(0);
     498    }
     499    return 0;
    502500}
    503501
     
    512510    }
    513511#endif
    514     return str;
     512    return m_str;
    515513}
    516514
     
    526524  if (!c) return NULL;
    527525  else if (item_type(c)==(ltype)L_CONS_CELL)
    528     return ((LList *)c)->cdr;
     526    return ((LList *)c)->m_cdr;
    529527  else
    530528    return NULL;
     
    535533  if (!c) return NULL;
    536534  else if (item_type(c)==(ltype)L_CONS_CELL)
    537     return ((LList *)c)->car;
     535    return ((LList *)c)->m_car;
    538536  else return NULL;
    539537}
    540538
    541 uint16_t lcharacter_value(void *c)
     539uint16_t LChar::GetValue()
    542540{
    543541#ifdef TYPE_CHECKING
    544   if (item_type(c)!=L_CHARACTER)
    545   {
    546     ((LObject *)c)->Print();
    547     lbreak("is not a character\n");
    548     exit(0);
    549   }
    550 #endif
    551   return ((LChar *)c)->ch;
     542    if (item_type(this) != L_CHARACTER)
     543    {
     544        Print();
     545        lbreak("is not a character\n");
     546        exit(0);
     547    }
     548#endif
     549    return m_ch;
    552550}
    553551
     
    557555  {
    558556    case L_NUMBER :
    559       return ((LNumber *)c)->num<<16; break;
     557      return ((LNumber *)c)->m_num<<16; break;
    560558    case L_FIXED_POINT :
    561       return (((LFixedPoint *)c)->x); break;
     559      return (((LFixedPoint *)c)->m_fixed); break;
    562560    default :
    563561    {
     
    578576    if (t1!=t2) return NULL;
    579577    else if (t1==L_NUMBER)
    580     { if (((LNumber *)n1)->num==((LNumber *)n2)->num)
     578    { if (((LNumber *)n1)->m_num==((LNumber *)n2)->m_num)
    581579        return true_symbol;
    582580      else return NULL;
    583581    } else if (t1==L_CHARACTER)
    584582    {
    585       if (((LChar *)n1)->ch==((LChar *)n2)->ch)
     583      if (((LChar *)n1)->m_ch==((LChar *)n2)->m_ch)
    586584        return true_symbol;
    587585      else return NULL;
     
    598596{
    599597#ifdef TYPE_CHECKING
    600     if (type != L_1D_ARRAY)
     598    if (m_type != L_1D_ARRAY)
    601599    {
    602600        Print();
     
    605603    }
    606604#endif
    607     if (x >= (int)len || x < 0)
     605    if (x >= (int)m_len || x < 0)
    608606    {
    609607        lbreak("array reference out of bounds (%d)\n", x);
    610608        exit(0);
    611609    }
    612     return data[x];
     610    return m_data[x];
    613611}
    614612
     
    758756  for (cs=(LList *)symbol_list; cs; cs=(LList *)CDR(cs))
    759757  {
    760     if (!strcmp( ((char *)((LSymbol *)cs->car)->name)+sizeof(LString), name))
    761       return (LSymbol *)(cs->car);
     758    if (!strcmp( ((char *)((LSymbol *)cs->m_car)->m_name)+sizeof(LString), name))
     759      return (LSymbol *)(cs->m_car);
    762760  }
    763761  return NULL;
     
    777775    cs=LList::Create();
    778776    s=new_lisp_symbol(name);
    779     cs->car=s;
    780     cs->cdr=symbol_list;
     777    cs->m_car=s;
     778    cs->m_cdr=symbol_list;
    781779    symbol_list=cs;
    782780    LSpace::Current = sp;
     
    792790    while (p)
    793791    {
    794         int cmp = strcmp(name, p->name->GetString());
     792        int cmp = strcmp(name, p->m_name->GetString());
    795793        if (cmp == 0)
    796794            return p;
    797         p = (cmp < 0) ? p->left : p->right;
     795        p = (cmp < 0) ? p->m_left : p->m_right;
    798796    }
    799797    return NULL;
     
    806804    while (p)
    807805    {
    808         int cmp = strcmp(name, p->name->GetString());
     806        int cmp = strcmp(name, p->m_name->GetString());
    809807        if (cmp == 0)
    810808            return p;
    811         parent = (cmp < 0) ? &p->left : &p->right;
     809        parent = (cmp < 0) ? &p->m_left : &p->m_right;
    812810        p = *parent;
    813811    }
     
    818816        LSpace::Current = &LSpace::Perm;
    819817
     818    // These permanent objects cannot be GCed, so malloc() them
    820819    p = (LSymbol *)malloc(sizeof(LSymbol));
    821     p->type = L_SYMBOL;
    822     p->name = LString::Create(name);
     820    p->m_type = L_SYMBOL;
     821    p->m_name = LString::Create(name);
    823822
    824823    // If constant, set the value to ourself
    825     p->value = (name[0] == ':') ? p : l_undefined;
    826     p->function = l_undefined;
     824    p->m_value = (name[0] == ':') ? p : l_undefined;
     825    p->m_function = l_undefined;
    827826#ifdef L_PROFILE
    828827    p->time_taken = 0;
    829828#endif
    830     p->left = p->right = NULL;
     829    p->m_left = p->m_right = NULL;
    831830    *parent = p;
    832831    count++;
     
    840839    if (root)
    841840    {
    842         DeleteAllSymbols(root->left);
    843         DeleteAllSymbols(root->right);
     841        DeleteAllSymbols(root->m_left);
     842        DeleteAllSymbols(root->m_right);
    844843        free(root);
    845844    }
    846845}
    847846
    848 void *assoc(void *item, void *list)
    849 {
    850   if (item_type(list)!=(ltype)L_CONS_CELL)
     847LObject *LObject::Assoc(LObject *item)
     848{
     849    if (item_type(this) != L_CONS_CELL)
     850        return NULL;
     851
     852    LObject *list = this;
     853    while (list)
     854    {
     855        if (lisp_eq(CAR(CAR(list)), item))
     856            return lcar(list);
     857        list = CDR(list);
     858    }
     859
    851860    return NULL;
    852   else
    853   {
    854     while (list)
    855     {
    856       if (lisp_eq(CAR(CAR(list)), item))
    857         return lcar(list);
    858       list=(LList *)(CDR(list));
    859     }
    860   }
    861   return NULL;
    862861}
    863862
     
    907906        first = cur;
    908907      if (last)
    909         last->cdr = cur;
     908        last->m_cdr = cur;
    910909      last = cur;
    911910
    912911      LList *cell = LList::Create();
    913912      tmp = (LObject *)lcar(list1);
    914       cell->car = tmp;
     913      cell->m_car = tmp;
    915914      tmp = (LObject *)lcar(list2);
    916       cell->cdr = tmp;
    917       cur->car = cell;
    918 
    919       list1 = ((LList *)list1)->cdr;
    920       list2 = ((LList *)list2)->cdr;
    921     }
    922     cur->cdr = (LObject *)list3;
     915      cell->m_cdr = tmp;
     916      cur->m_car = cell;
     917
     918      list1 = ((LList *)list1)->m_cdr;
     919      list2 = ((LList *)list2)->m_cdr;
     920    }
     921    cur->m_cdr = (LObject *)list3;
    923922    ret=first;
    924923  } else ret=NULL;
     
    926925}
    927926
    928 void LSymbol::SetFunction(LObject *fun)
    929 {
    930     function = fun;
     927void LSymbol::SetFunction(LObject *function)
     928{
     929    m_function = function;
    931930}
    932931
     
    935934  need_perm_space("add_sys_function");
    936935  LSymbol *s = LSymbol::FindOrCreate(name);
    937   if (s->function!=l_undefined)
     936  if (s->m_function!=l_undefined)
    938937  {
    939938    lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
    940939    exit(0);
    941940  }
    942   else s->function=new_lisp_sys_function(min_args, max_args, number);
     941  else s->m_function=new_lisp_sys_function(min_args, max_args, number);
    943942  return s;
    944943}
     
    948947  need_perm_space("add_c_object");
    949948  LSymbol *s=(LSymbol *)symbol;
    950   if (s->value!=l_undefined)
     949  if (s->m_value!=l_undefined)
    951950  {
    952951    lbreak("add_c_object -> symbol %s already has a value\n", lstring_value(s->GetName()));
    953952    exit(0);
    954953  }
    955   else s->value=LObjectVar::Create(index);
     954  else s->m_value=LObjectVar::Create(index);
    956955  return NULL;
    957956}
     
    962961  need_perm_space("add_c_function");
    963962  LSymbol *s = LSymbol::FindOrCreate(name);
    964   if (s->function!=l_undefined)
     963  if (s->m_function!=l_undefined)
    965964  {
    966965    lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
    967966    exit(0);
    968967  }
    969   else s->function=new_lisp_c_function(min_args, max_args, number);
     968  else s->m_function=new_lisp_c_function(min_args, max_args, number);
    970969  return s;
    971970}
     
    976975  need_perm_space("add_c_bool_fun");
    977976  LSymbol *s = LSymbol::FindOrCreate(name);
    978   if (s->function!=l_undefined)
     977  if (s->m_function!=l_undefined)
    979978  {
    980979    lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
    981980    exit(0);
    982981  }
    983   else s->function=new_lisp_c_bool(min_args, max_args, number);
     982  else s->m_function=new_lisp_c_bool(min_args, max_args, number);
    984983  return s;
    985984}
     
    991990  need_perm_space("add_c_bool_fun");
    992991  LSymbol *s = LSymbol::FindOrCreate(name);
    993   if (s->function!=l_undefined)
     992  if (s->m_function!=l_undefined)
    994993  {
    995994    lbreak("add_sys_fucntion -> symbol %s already has a function\n", name);
    996995    exit(0);
    997996  }
    998   else s->function=new_user_lisp_function(min_args, max_args, number);
     997  else s->m_function=new_user_lisp_function(min_args, max_args, number);
    999998  return s;
    1000999}
     
    10761075  PtrRef r1(object), r2(list);
    10771076  LList *c = LList::Create();
    1078   c->car = (LObject *)object;
    1079   c->cdr = (LObject *)list;
     1077  c->m_car = (LObject *)object;
     1078  c->m_cdr = (LObject *)list;
    10801079  list=c;
    10811080}
     
    10991098    PtrRef r1(cs), r2(c2);
    11001099
    1101     ((LList *)cs)->car=quote_symbol;
     1100    ((LList *)cs)->m_car=quote_symbol;
    11021101    c2 = LList::Create();
    11031102    tmp=Compile(code);
    1104     ((LList *)c2)->car = (LObject *)tmp;
    1105     ((LList *)c2)->cdr=NULL;
    1106     ((LList *)cs)->cdr = (LObject *)c2;
     1103    ((LList *)c2)->m_car = (LObject *)tmp;
     1104    ((LList *)c2)->m_cdr=NULL;
     1105    ((LList *)cs)->m_cdr = (LObject *)c2;
    11071106    ret=cs;
    11081107  }
     
    11121111    PtrRef r1(cs), r2(c2);
    11131112
    1114     ((LList *)cs)->car=backquote_symbol;
     1113    ((LList *)cs)->m_car=backquote_symbol;
    11151114    c2 = LList::Create();
    11161115    tmp=Compile(code);
    1117     ((LList *)c2)->car = (LObject *)tmp;
    1118     ((LList *)c2)->cdr=NULL;
    1119     ((LList *)cs)->cdr = (LObject *)c2;
     1116    ((LList *)c2)->m_car = (LObject *)tmp;
     1117    ((LList *)c2)->m_cdr=NULL;
     1118    ((LList *)cs)->m_cdr = (LObject *)c2;
    11201119    ret=cs;
    11211120  }  else if (n[0]==',')              // short hand for comma function
     
    11241123    PtrRef r1(cs), r2(c2);
    11251124
    1126     ((LList *)cs)->car=comma_symbol;
     1125    ((LList *)cs)->m_car=comma_symbol;
    11271126    c2 = LList::Create();
    11281127    tmp=Compile(code);
    1129     ((LList *)c2)->car = (LObject *)tmp;
    1130     ((LList *)c2)->cdr=NULL;
    1131     ((LList *)cs)->cdr = (LObject *)c2;
     1128    ((LList *)c2)->m_car = (LObject *)tmp;
     1129    ((LList *)c2)->m_cdr=NULL;
     1130    ((LList *)cs)->m_cdr = (LObject *)c2;
    11321131    ret=cs;
    11331132  }
     
    11581157                    read_ltoken(code, n);              // skip the '.'
    11591158                    tmp=Compile(code);
    1160                     ((LList *)last)->cdr = (LObject *)tmp;          // link the last cdr to
     1159                    ((LList *)last)->m_cdr = (LObject *)tmp;          // link the last cdr to
    11611160                    last=NULL;
    11621161                  }
     
    11701169                  if (!first) first=cur;
    11711170                  tmp=Compile(code);
    1172                   ((LList *)cur)->car = (LObject *)tmp;
     1171                  ((LList *)cur)->m_car = (LObject *)tmp;
    11731172                  if (last)
    1174                     ((LList *)last)->cdr = (LObject *)cur;
     1173                    ((LList *)last)->m_cdr = (LObject *)cur;
    11751174                  last=cur;
    11761175                }
     
    11841183  {
    11851184    LNumber *num = LNumber::Create(0);
    1186     sscanf(n, "%ld", &num->num);
     1185    sscanf(n, "%ld", &num->m_num);
    11871186    ret=num;
    11881187  } else if (n[0]=='"')
     
    12211220      PtrRef r4(cs), r5(c2);
    12221221      tmp = LSymbol::FindOrCreate("function");
    1223       ((LList *)cs)->car = (LObject *)tmp;
     1222      ((LList *)cs)->m_car = (LObject *)tmp;
    12241223      c2 = LList::Create();
    12251224      tmp=Compile(code);
    1226       ((LList *)c2)->car = (LObject *)tmp;
    1227       ((LList *)cs)->cdr = (LObject *)c2;
     1225      ((LList *)c2)->m_car = (LObject *)tmp;
     1226      ((LList *)cs)->m_cdr = (LObject *)c2;
    12281227      ret=cs;
    12291228    }
     
    12871286                if (item_type(cs) == (ltype)L_CONS_CELL)
    12881287                {
    1289                     cs->car->Print();
    1290                     if (cs->cdr)
     1288                    cs->m_car->Print();
     1289                    if (cs->m_cdr)
    12911290                        lprint_string(" ");
    12921291                }
     
    13021301        break;
    13031302    case L_NUMBER:
    1304         sprintf(buf, "%ld", ((LNumber *)this)->num);
     1303        sprintf(buf, "%ld", ((LNumber *)this)->m_num);
    13051304        lprint_string(buf);
    13061305        break;
    13071306    case L_SYMBOL:
    1308         lprint_string(((LSymbol *)this)->name->GetString());
     1307        lprint_string(((LSymbol *)this)->m_name->GetString());
    13091308        break;
    13101309    case L_USER_FUNCTION:
     
    13391338        if (current_print_file)
    13401339        {
    1341             uint8_t ch = ((LChar *)this)->ch;
     1340            uint8_t ch = ((LChar *)this)->m_ch;
    13421341            current_print_file->write(&ch, 1);
    13431342        }
    13441343        else
    13451344        {
    1346             uint16_t ch = ((LChar *)this)->ch;
     1345            uint16_t ch = ((LChar *)this)->m_ch;
    13471346            dprintf("#\\");
    13481347            switch (ch)
     
    13581357        break;
    13591358    case L_OBJECT_VAR:
    1360         l_obj_print(((LObjectVar *)this)->index);
     1359        l_obj_print(((LObjectVar *)this)->m_index);
    13611360        break;
    13621361    case L_1D_ARRAY:
     
    13651364            LObject **data = a->GetData();
    13661365            dprintf("#(");
    1367             for (size_t j = 0; j < a->len; j++)
     1366            for (size_t j = 0; j < a->m_len; j++)
    13681367            {
    13691368                data[j]->Print();
    1370                 if (j != a->len - 1)
     1369                if (j != a->m_len - 1)
    13711370                    dprintf(" ");
    13721371            }
     
    13761375    case L_COLLECTED_OBJECT:
    13771376        lprint_string("GC_reference->");
    1378         ((LRedirect *)this)->ref->Print();
     1377        ((LRedirect *)this)->m_ref->Print();
    13791378        break;
    13801379    default:
     
    14001399#endif
    14011400
    1402     LObject *fun = function;
     1401    LObject *fun = m_function;
    14031402    PtrRef ref2(fun);
    14041403    PtrRef ref3(arg_list);
     
    14351434        {
    14361435            ((LObject *)arg_list)->Print();
    1437             name->Print();
     1436            m_name->Print();
    14381437            lbreak("\nToo few parameters to function\n");
    14391438            exit(0);
     
    14421441        {
    14431442            ((LObject *)arg_list)->Print();
    1444             name->Print();
     1443            m_name->Print();
    14451444            lbreak("\nToo many parameters to function\n");
    14461445            exit(0);
     
    14741473            LList *tmp = LList::Create();
    14751474            if (first)
    1476                 cur->cdr = tmp;
     1475                cur->m_cdr = tmp;
    14771476            else
    14781477                first = tmp;
     
    14801479
    14811480            LObject *val = CAR(arg_list)->Eval();
    1482             ((LList *)cur)->car = val;
     1481            ((LList *)cur)->m_car = val;
    14831482            arg_list = lcdr(arg_list);
    14841483        }
     
    15081507  if (p)
    15091508  {
    1510     pro_print(out, p->right);
     1509    pro_print(out, p->m_right);
    15111510    {
    15121511      char st[100];
     
    15141513      out->write(st, strlen(st));
    15151514    }
    1516     pro_print(out, p->left);
     1515    pro_print(out, p->m_left);
    15171516  }
    15181517}
     
    15781577      else
    15791578      {
    1580         na_list->cdr = (LObject *)LList::Create();
     1579        na_list->m_cdr = (LObject *)LList::Create();
    15811580                na_list=(LList *)CDR(na_list);
    15821581      }
     
    15851584      if (arg_on[i])
    15861585      {
    1587                 na_list->car = (LObject *)CAR(arg_on[i]);
     1586                na_list->m_car = (LObject *)CAR(arg_on[i]);
    15881587                arg_on[i]=(LList *)CDR(arg_on[i]);
    15891588      }
     
    15931592    {
    15941593      LList *c = LList::Create();
    1595       c->car = ((LSymbol *)sym)->EvalFunction(first);
     1594      c->m_car = ((LSymbol *)sym)->EvalFunction(first);
    15961595      if (return_list)
    1597         last_return->cdr=c;
     1596        last_return->m_cdr=c;
    15981597      else
    15991598        return_list=c;
     
    16721671        {
    16731672          if (item_type(CAR(char_list))==L_CHARACTER)
    1674             *(s++)=((LChar *)CAR(char_list))->ch;
     1673            *(s++)=((LChar *)CAR(char_list))->m_ch;
    16751674          char_list=(LList *)CDR(char_list);
    16761675        }
     
    17061705  else if (args==NULL)
    17071706    return NULL;
    1708   else if ((LSymbol *) (((LList *)args)->car)==comma_symbol)
     1707  else if ((LSymbol *) (((LList *)args)->m_car)==comma_symbol)
    17091708    return CAR(CDR(args))->Eval();
    17101709  else
     
    17191718    {
    17201719      tmp = CAR(CDR(args))->Eval();
    1721       ((LList *)last)->cdr = (LObject *)tmp;
     1720      ((LList *)last)->m_cdr = (LObject *)tmp;
    17221721      args=NULL;
    17231722    }
     
    17261725      cur = LList::Create();
    17271726      if (first)
    1728         ((LList *)last)->cdr = (LObject *)cur;
     1727        ((LList *)last)->m_cdr = (LObject *)cur;
    17291728      else
    17301729            first=cur;
    17311730      last=cur;
    17321731          tmp=backquote_eval(CAR(args));
    1733           ((LList *)cur)->car = (LObject *)tmp;
     1732          ((LList *)cur)->m_car = (LObject *)tmp;
    17341733       args=CDR(args);
    17351734    }
     
    17371736      {
    17381737    tmp=backquote_eval(args);
    1739     ((LList *)last)->cdr = (LObject *)tmp;
     1738    ((LList *)last)->m_cdr = (LObject *)tmp;
    17401739    args=NULL;
    17411740      }
     
    17961795            cur = LList::Create();
    17971796            LObject *val = CAR(arg_list)->Eval();
    1798             cur->car = val;
     1797            cur->m_car = val;
    17991798            if (last)
    1800                 last->cdr = cur;
     1799                last->m_cdr = cur;
    18011800            else
    18021801                first = cur;
     
    18121811        PtrRef r1(c);
    18131812        LObject *val = CAR(arg_list)->Eval();
    1814         c->car = val;
     1813        c->m_car = val;
    18151814        val = CAR(CDR(arg_list))->Eval();
    1816         c->cdr = val;
     1815        c->m_cdr = val;
    18171816        ret = c;
    18181817        break;
     
    18871886            else if (first)
    18881887            {
    1889                 quot = ((LNumber *)i)->num;
     1888                quot = ((LNumber *)i)->m_num;
    18901889                first = 0;
    18911890            }
    18921891            else
    1893                 quot /= ((LNumber *)i)->num;
     1892                quot /= ((LNumber *)i)->m_num;
    18941893            arg_list = (LList *)CDR(arg_list);
    18951894        }
     
    19321931        {
    19331932        case L_SYMBOL:
    1934             switch (item_type(((LSymbol *)i)->value))
     1933            switch (item_type(((LSymbol *)i)->m_value))
    19351934            {
    19361935            case L_NUMBER:
    1937                 if (x == L_NUMBER && ((LSymbol *)i)->value != l_undefined)
     1936                if (x == L_NUMBER && ((LSymbol *)i)->m_value != l_undefined)
    19381937                    ((LSymbol *)i)->SetNumber(lnumber_value(set_to));
    19391938                else
     
    19411940                break;
    19421941            case L_OBJECT_VAR:
    1943                 l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->index, set_to);
     1942                l_obj_set(((LObjectVar *)(((LSymbol *)i)->m_value))->m_index, set_to);
    19441943                break;
    19451944            default:
    19461945                ((LSymbol *)i)->SetValue((LObject *)set_to);
    19471946            }
    1948             ret = ((LSymbol *)i)->value;
     1947            ret = ((LSymbol *)i)->m_value;
    19491948            break;
    19501949        case L_CONS_CELL:   // this better be an 'aref'
    19511950        {
    19521951#ifdef TYPE_CHECKING
    1953             LObject *car = ((LList *)i)->car;
     1952            LObject *car = ((LList *)i)->m_car;
    19541953            if (car == car_symbol)
    19551954            {
     
    19611960                    exit(0);
    19621961                }
    1963                 ((LList *)car)->car = set_to;
     1962                ((LList *)car)->m_car = set_to;
    19641963            }
    19651964            else if (car == cdr_symbol)
     
    19721971                    exit(0);
    19731972                }
    1974                 ((LList *)car)->cdr = set_to;
     1973                ((LList *)car)->m_cdr = set_to;
    19751974            }
    19761975            else if (car != aref_symbol)
     
    19941993                int num = lnumber_value(CAR(CDR(CDR(i)))->Eval());
    19951994#ifdef TYPE_CHECKING
    1996                 if (num >= (int)a->len || num < 0)
     1995                if (num >= (int)a->m_len || num < 0)
    19971996                {
    19981997                    lbreak("aref : value of bounds (%d)\n", num);
     
    20242023        LList *list = (LList *)CAR(CDR(arg_list))->Eval();
    20252024        PtrRef r2(list);
    2026         ret = (LObject *)assoc(item, list);
     2025        ret = list->Assoc(item);
    20272026        break;
    20282027    }
     
    20412040        PtrRef r2(i2);
    20422041        LList *cs = LList::Create();
    2043         cs->car = i1;
    2044         cs->cdr = i2;
     2042        cs->m_car = i1;
     2043        cs->m_cdr = i2;
    20452044        ret = cs;
    20462045        break;
     
    20782077#endif
    20792078
    2080             l_user_stack.push(((LSymbol *)var_name)->value);
     2079            l_user_stack.push(((LSymbol *)var_name)->m_value);
    20812080            tmp = CAR(CDR(CAR(var_list)))->Eval();
    20822081            ((LSymbol *)var_name)->SetValue(tmp);
     
    21802179        {
    21812180        case L_CHARACTER:
    2182             ret = LNumber::Create(((LChar *)i)->ch);
     2181            ret = LNumber::Create(((LChar *)i)->m_ch);
    21832182            break;
    21842183        case L_STRING:
     
    22032202            exit(0);
    22042203        }
    2205         ret = LChar::Create(((LNumber *)i)->num);
     2204        ret = LChar::Create(((LNumber *)i)->m_num);
    22062205        break;
    22072206    }
     
    23022301        }
    23032302#endif
    2304         ret = symb->name;
     2303        ret = symb->m_name;
    23052304        break;
    23062305    }
     
    24822481            {
    24832482                LObject *tmp = LNumber::Create(x);
    2484                 ((LSymbol *)sym)->value = tmp;
     2483                ((LSymbol *)sym)->m_value = tmp;
    24852484                break;
    24862485            }
     
    24992498                x = lnumber_value(CAR(CDR(sym))->Eval());
    25002499                LObject *tmp = LNumber::Create(x);
    2501                 ((LSymbol *)sym)->value = tmp;
     2500                ((LSymbol *)sym)->m_value = tmp;
    25022501                break;
    25032502            }
     
    25452544            for (void *s = symbol_list; s; s = CDR(s))
    25462545                fprintf(fp, "%8d  %s\n", ((LSymbol *)(CAR(s)))->call_counter,
    2547                         lstring_value(((LSymbol *)(CAR(s)))->name));
     2546                        lstring_value(((LSymbol *)(CAR(s)))->m_name));
    25482547            fclose(fp);
    25492548        }
     
    26912690    {
    26922691        LObject *v = CAR(arg_list)->Eval();
    2693         if (item_type(v) != L_NUMBER || (((LNumber *)v)->num != 0))
     2692        if (item_type(v) != L_NUMBER || (((LNumber *)v)->m_num != 0))
    26942693            ret = NULL;
    26952694        else
     
    28062805    }
    28072806    case SYS_FUNC_GC:
    2808         LispGC::CollectSpace(LSpace::Current, 0);
     2807        Lisp::CollectSpace(LSpace::Current, 0);
    28092808        break;
    28102809    case SYS_FUNC_SCHAR:
     
    28642863            }
    28652864            LObject *tmp = CAR(arg_list)->Eval();
    2866             ((LList *)l1)->cdr = tmp;
     2865            ((LList *)l1)->m_cdr = tmp;
    28672866            arg_list = (LList *)CDR(arg_list);
    28682867        } while (arg_list);
     
    29712970#endif
    29722971
    2973     LUserFunction *fun = (LUserFunction *)function;
     2972    LUserFunction *fun = (LUserFunction *)m_function;
    29742973
    29752974#ifdef TYPE_CHECKING
     
    29962995    {
    29972996        LSymbol *s = (LSymbol *)CAR(f_arg);
    2998         l_user_stack.push(s->value);
     2997        l_user_stack.push(s->m_value);
    29992998    }
    30002999
     
    30953094                ret = ((LSymbol *)this)->GetValue();
    30963095                if (item_type(ret) == L_OBJECT_VAR)
    3097                     ret = (LObject *)l_obj_get(((LObjectVar *)ret)->index);
     3096                    ret = (LObject *)l_obj_get(((LObjectVar *)ret)->m_index);
    30983097            }
    30993098            break;
     
    31193118
    31203119/*  l_user_stack.push(ret);
    3121   LispGC::CollectSpace(&LSpace::Perm);
     3120  Lisp::CollectSpace(&LSpace::Perm);
    31223121  ret=l_user_stack.pop(1);  */
    31233122
    31243123    return ret;
    31253124}
    3126 
    3127 void l_comp_init();
    31283125
    31293126void Lisp::Init()
     
    31443141    LSpace::Current = &LSpace::Perm;
    31453142
    3146     l_comp_init();
     3143    InitConstants();
     3144
    31473145    for(size_t i = 0; i < sizeof(sys_funcs) / sizeof(*sys_funcs); i++)
    31483146        add_sys_function(sys_funcs[i].name,
     
    31793177    }
    31803178#endif
    3181     return name;
     3179    return m_name;
    31823180}
    31833181
     
    31923190    }
    31933191#endif
    3194     if (value != l_undefined && item_type(value) == L_NUMBER)
    3195         ((LNumber *)value)->num = num;
     3192    if (m_value != l_undefined && item_type(m_value) == L_NUMBER)
     3193        ((LNumber *)m_value)->m_num = num;
    31963194    else
    3197         value = LNumber::Create(num);
     3195        m_value = LNumber::Create(num);
    31983196}
    31993197
     
    32083206    }
    32093207#endif
    3210     value = val;
     3208    m_value = val;
    32113209}
    32123210
     
    32213219    }
    32223220#endif
    3223     return function;
     3221    return m_function;
    32243222}
    32253223
     
    32343232    }
    32353233#endif
    3236     return value;
    3237 }
    3238 
     3234    return m_value;
     3235}
     3236
  • abuse/trunk/src/lisp/lisp.h

    r635 r636  
    3838       L_FIXED_POINT, L_COLLECTED_OBJECT };
    3939
    40 typedef uint32_t ltype;    // make sure structures aren't packed differently on various compiler
     40typedef uint8_t ltype;    // make sure structures aren't packed differently on various compiler
    4141                       // and sure that word, etc are word aligned
    42 
    43 class Lisp
    44 {
    45 public:
    46     static void Init();
    47     static void Uninit();
    48 };
    4942
    5043struct LSpace
     
    7366    /* Methods */
    7467    LObject *Eval();
     68    LObject *Assoc(LObject *item);
    7569    void Print();
    7670
    7771    /* Members */
    78     ltype type;
     72    ltype m_type;
    7973};
    8074
     
    8579
    8680    /* Members */
    87     int index;
     81    int m_index;
    8882};
    8983
     
    9791
    9892    /* Members */
    99     LObject *cdr, *car;
     93    LObject *m_cdr, *m_car;
    10094};
    10195
     
    106100
    107101    /* Members */
    108     long num;
     102    long m_num;
    109103};
    110104
     
    112106{
    113107    /* Members */
    114     LObject *ref;
     108    LObject *m_ref;
    115109};
    116110
     
    127121    /* Members */
    128122private:
    129     char str[1]; /* Can be allocated much larger than 1 */
     123    char m_str[1]; /* Can be allocated much larger than 1 */
    130124};
    131125
     
    152146    float time_taken;
    153147#endif
    154     LObject *value;
    155     LObject *function;
    156     LString *name;
    157     LSymbol *left, *right; // tree structure
     148    LObject *m_value;
     149    LObject *m_function;
     150    LString *m_name;
     151    LSymbol *m_left, *m_right; // tree structure
    158152
    159153    /* Static members */
     
    183177
    184178    /* Methods */
    185     inline LObject **GetData() { return data; }
     179    inline LObject **GetData() { return m_data; }
    186180    LObject *Get(int x);
    187181
    188182    /* Members */
    189     size_t len;
     183    size_t m_len;
    190184
    191185private:
    192     LObject *data[1]; /* Can be allocated much larger than 1 */
     186    LObject *m_data[1]; /* Can be allocated much larger than 1 */
    193187};
    194188
     
    198192    static LChar *Create(uint16_t ch);
    199193
    200     /* Members */
    201     uint16_t ch;
     194    /* Methods */
     195    uint16_t GetValue();
     196
     197    /* Members */
     198    uint16_t m_ch;
    202199};
    203200
     
    208205
    209206    /* Members */
    210     void *addr;
     207    void *m_addr;
    211208};
    212209
     
    217214
    218215    /* Members */
    219     int32_t x;
    220 };
    221 
    222 static inline LObject *&CAR(void *x) { return ((LList *)x)->car; }
    223 static inline LObject *&CDR(void *x) { return ((LList *)x)->cdr; }
     216    int32_t m_fixed;
     217};
     218
     219class Lisp
     220{
     221public:
     222    static void Init();
     223    static void Uninit();
     224
     225    static void InitConstants();
     226
     227    // Collect temporary or permanent spaces
     228    static void CollectSpace(LSpace *which_space, int grow);
     229
     230private:
     231    static LArray *CollectArray(LArray *x);
     232    static LList *CollectList(LList *x);
     233    static LObject *CollectObject(LObject *x);
     234    static void CollectSymbols(LSymbol *root);
     235    static void CollectStacks();
     236};
     237
     238static inline LObject *&CAR(void *x) { return ((LList *)x)->m_car; }
     239static inline LObject *&CDR(void *x) { return ((LList *)x)->m_cdr; }
    224240static inline ltype item_type(void *x) { if (x) return *(ltype *)x; return L_CONS_CELL; }
    225241
     
    228244void *lpointer_value(void *lpointer);
    229245int32_t lnumber_value(void *lnumber);
    230 unsigned short lcharacter_value(void *c);
    231246long lfixed_point_value(void *c);
    232247void *lisp_atom(void *i);
     
    236251void *lisp_equal(void *n1, void *n2);
    237252void *eval_block(void *list);
    238 void *assoc(void *item, void *list);
    239253void resize_tmp(size_t new_size);
    240254void resize_perm(size_t new_size);
     
    258272
    259273int end_of_program(char *s);
    260 void lisp_init();
    261 void lisp_uninit();
    262274
    263275void *nth(int num, void *list);
     
    265277int32_t lisp_sin(int32_t x);
    266278int32_t lisp_cos(int32_t x);
    267 void restore_heap(void *val, int heap);
    268 void *mark_heap(int heap);
    269279
    270280extern "C" {
  • abuse/trunk/src/lisp/lisp_gc.cpp

    r635 r636  
    4141static uint8_t *cstart, *cend, *collected_start, *collected_end;
    4242
    43 LArray *LispGC::CollectArray(LArray *x)
    44 {
    45     size_t s = x->len;
     43LArray *Lisp::CollectArray(LArray *x)
     44{
     45    size_t s = x->m_len;
    4646    LArray *a = LArray::Create(s, NULL);
    4747    LObject **src = x->GetData();
     
    5353}
    5454
    55 LList *LispGC::CollectList(LList *x)
     55LList *Lisp::CollectList(LList *x)
    5656{
    5757    LList *prev = NULL, *first = NULL;
     
    6060    {
    6161        LList *p = LList::Create();
    62         LObject *old_car = x->car;
     62        LObject *old_car = x->m_car;
    6363        LObject *old_x = x;
    6464        x = (LList *)CDR(x);
    65         ((LRedirect *)old_x)->type = L_COLLECTED_OBJECT;
    66         ((LRedirect *)old_x)->ref = p;
    67 
    68         p->car = CollectObject(old_car);
     65        ((LRedirect *)old_x)->m_type = L_COLLECTED_OBJECT;
     66        ((LRedirect *)old_x)->m_ref = p;
     67
     68        p->m_car = CollectObject(old_car);
    6969
    7070        if (prev)
    71             prev->cdr = p;
     71            prev->m_cdr = p;
    7272        else
    7373            first = p;
     
    7575    }
    7676    if (x)
    77         prev->cdr = CollectObject(x);
     77        prev->m_cdr = CollectObject(x);
    7878
    7979    return first; // we already set the collection pointers
    8080}
    8181
    82 LObject *LispGC::CollectObject(LObject *x)
     82LObject *Lisp::CollectObject(LObject *x)
    8383{
    8484    LObject *ret = x;
     
    9292            break;
    9393        case L_NUMBER:
    94             ret = LNumber::Create(((LNumber *)x)->num);
     94            ret = LNumber::Create(((LNumber *)x)->m_num);
    9595            break;
    9696        case L_SYS_FUNCTION:
     
    111111            break;
    112112        case L_CHARACTER:
    113             ret = LChar::Create(lcharacter_value(x));
     113            ret = LChar::Create(((LChar *)x)->m_ch);
    114114            break;
    115115        case L_C_FUNCTION:
     
    141141            break;
    142142        case L_OBJECT_VAR:
    143             ret = LObjectVar::Create(((LObjectVar *)x)->index);
     143            ret = LObjectVar::Create(((LObjectVar *)x)->m_index);
    144144            break;
    145145        case L_COLLECTED_OBJECT:
    146             ret = ((LRedirect *)x)->ref;
     146            ret = ((LRedirect *)x)->m_ref;
    147147            break;
    148148        default:
     
    150150            break;
    151151        }
    152         ((LRedirect *)x)->type = L_COLLECTED_OBJECT;
    153         ((LRedirect *)x)->ref = ret;
     152        ((LRedirect *)x)->m_type = L_COLLECTED_OBJECT;
     153        ((LRedirect *)x)->m_ref = ret;
    154154    }
    155155    else if ((uint8_t *)x < collected_start || (uint8_t *)x >= collected_end)
     
    172172}
    173173
    174 void LispGC::CollectSymbols(LSymbol *root)
     174void Lisp::CollectSymbols(LSymbol *root)
    175175{
    176176    if (!root)
    177177        return;
    178178
    179     root->value = CollectObject(root->value);
    180     root->function = CollectObject(root->function);
    181     root->name = (LString *)CollectObject(root->name);
    182     CollectSymbols(root->left);
    183     CollectSymbols(root->right);
    184 }
    185 
    186 void LispGC::CollectStacks()
     179    root->m_value = CollectObject(root->m_value);
     180    root->m_function = CollectObject(root->m_function);
     181    root->m_name = (LString *)CollectObject(root->m_name);
     182    CollectSymbols(root->m_left);
     183    CollectSymbols(root->m_right);
     184}
     185
     186void Lisp::CollectStacks()
    187187{
    188188    void **d = l_user_stack.sdata;
     
    205205}
    206206
    207 void LispGC::CollectSpace(LSpace *which_space, int grow)
     207void Lisp::CollectSpace(LSpace *which_space, int grow)
    208208{
    209209    LSpace *old_space = LSpace::Current;
  • abuse/trunk/src/lisp/lisp_gc.h

    r635 r636  
    1515// Stack user progs can push data and have it GCed
    1616extern GrowStack<void> l_user_stack;
    17 
    18 class LispGC
    19 {
    20 public:
    21     // Collect temporary or permanent spaces
    22     static void CollectSpace(LSpace *which_space, int grow);
    23 
    24 private:
    25     static LArray *CollectArray(LArray *x);
    26     static LList *CollectList(LList *x);
    27     static LObject *CollectObject(LObject *x);
    28     static void CollectSymbols(LSymbol *root);
    29     static void CollectStacks();
    30 };
    3117
    3218// This pointer reference stack lists all pointers to temporary lisp
  • abuse/trunk/src/lisp/lisp_opt.cpp

    r555 r636  
    9393}
    9494
    95 void l_comp_init()
     95void Lisp::InitConstants()
    9696{
    9797    // This needs to be defined first
    98     l_undefined = LSymbol::FindOrCreate(":UNDEFINED");
    99 
     98    LSymbol *tmp = LSymbol::FindOrCreate(":UNDEFINED");
     99    l_undefined = tmp;
    100100    // Collection problems result if we don't do this
    101     ((LSymbol *)l_undefined)->function = NULL;
    102     ((LSymbol *)l_undefined)->value = NULL;
     101    tmp->m_function = NULL;
     102    tmp->m_value = NULL;
    103103
    104104    true_symbol = LSymbol::FindOrCreate("T");
  • abuse/trunk/src/objects.cpp

    r635 r636  
    488488    am = LList::Create();
    489489    PtrRef r1(am);
    490     am->car = LNumber::Create(amount);
     490    am->m_car = LNumber::Create(amount);
    491491
    492492    frm = LList::Create();
    493493    PtrRef r2(frm);
    494     frm->car = LPointer::Create(from);
     494    frm->m_car = LPointer::Create(from);
    495495
    496496    hx = LList::Create();
    497497    PtrRef r3(hx);
    498     hx->car = LNumber::Create(hitx);
     498    hx->m_car = LNumber::Create(hitx);
    499499
    500500    hy = LList::Create();
    501501    PtrRef r4(hy);
    502     hy->car = LNumber::Create(hity);
     502    hy->m_car = LNumber::Create(hity);
    503503
    504504    px = LList::Create();
    505505    PtrRef r5(px);
    506     px->car = LNumber::Create(push_xvel);
     506    px->m_car = LNumber::Create(push_xvel);
    507507
    508508    py = LList::Create();
    509509    PtrRef r6(py);
    510     py->car = LNumber::Create(push_yvel);
    511 
    512     px->cdr = py;
    513     hy->cdr = px;
    514     hx->cdr = hy;
    515     frm->cdr = hx;
    516     am->cdr = frm;
     510    py->m_car = LNumber::Create(push_yvel);
     511
     512    px->m_cdr = py;
     513    hy->m_cdr = px;
     514    hx->m_cdr = hy;
     515    frm->m_cdr = hx;
     516    am->m_cdr = frm;
    517517
    518518    time_marker *prof1 = NULL;
     
    12031203    lcx = LList::Create();
    12041204    PtrRef r1(lcx);
    1205     lcx->car = LNumber::Create(cx);
     1205    lcx->m_car = LNumber::Create(cx);
    12061206
    12071207    lcy = LList::Create();
    12081208    PtrRef r2(lcy);
    1209     lcy->car = LNumber::Create(cy);
     1209    lcy->m_car = LNumber::Create(cy);
    12101210
    12111211    lb = LList::Create();
    12121212    PtrRef r3(lb);
    1213     lb->car = LNumber::Create(button);
    1214 
    1215     lcx->cdr = lcy;
    1216     lcy->cdr = lb;
     1213    lb->m_car = LNumber::Create(button);
     1214
     1215    lcx->m_cdr = lcy;
     1216    lcy->m_cdr = lb;
    12171217
    12181218    void *m = LSpace::Tmp.Mark();
Note: See TracChangeset for help on using the changeset viewer.