Changeset 492 for abuseTweet

Timestamp:

Apr 17, 2011, 10:28:52 AM (12 years ago)

Author:

Sam Hocevar

Message:

lisp: rename core classes to slightly shorter names (LispObject? -> LObject).

Location:

abuse/trunk/src

Files:

• ant.cpp (modified) (1 diff)
• cache.cpp (modified) (1 diff)
• chars.cpp (modified) (12 diffs)
• clisp.cpp (modified) (23 diffs)
• clisp.h (modified) (2 diffs)
• compiled.cpp (modified) (3 diffs)
• configuration.cpp (modified) (1 diff)
• cop.cpp (modified) (15 diffs)
• demo.h (modified) (1 diff)
• dev.cpp (modified) (3 diffs)
• director.cpp (modified) (1 diff)
• endgame.cpp (modified) (4 diffs)
• game.cpp (modified) (5 diffs)
• gamma.cpp (modified) (3 diffs)
• lcache.cpp (modified) (5 diffs)
• level.cpp (modified) (8 diffs)
• lisp/lisp.cpp (modified) (140 diffs)
• lisp/lisp.h (modified) (11 diffs)
• lisp/lisp_gc.cpp (modified) (15 diffs)
• lisp/lisp_opt.cpp (modified) (2 diffs)
• lisp/lisp_opt.h (modified) (1 diff)
• loader2.cpp (modified) (1 diff)
• menu.cpp (modified) (6 diffs)
• objects.cpp (modified) (17 diffs)
• particle.cpp (modified) (1 diff)
• seq.cpp (modified) (1 diff)
• statbar.cpp (modified) (1 diff)
• view.cpp (modified) (3 diffs)

abuse/trunk/src/ant.cpp

@@ -113 +113 @@
     PtrRef r1(call_list);
     push_onto_list(new_lisp_pointer(b),call_list);
-    push_onto_list(LispNumber::Create(angle),call_list);
-    push_onto_list(LispNumber::Create(firey),call_list);
-    push_onto_list(LispNumber::Create(firex),call_list);
-    push_onto_list(LispNumber::Create(o->aitype()),call_list);
+    push_onto_list(LNumber::Create(angle),call_list);
+    push_onto_list(LNumber::Create(firey),call_list);
+    push_onto_list(LNumber::Create(firex),call_list);
+    push_onto_list(LNumber::Create(o->aitype()),call_list);
     push_onto_list(new_lisp_pointer(o),call_list);
-    eval_user_fun((LispSymbol *)l_fire_object,call_list);
+    eval_user_fun((LSymbol *)l_fire_object,call_list);
     o->set_state((character_state)S_weapon_fire);
   }

abuse/trunk/src/cache.cpp

@@ -384 +384 @@
 
     void *call_with=NULL;
-    push_onto_list(LispNumber::Create(type),call_with);
-
-    void *CacheList=eval_function((LispSymbol *)cache_fun,call_with);
+    push_onto_list(LNumber::Create(type),call_with);
+
+    void *CacheList=eval_function((LSymbol *)cache_fun,call_with);
     PtrRef r1(CacheList);
 

abuse/trunk/src/chars.cpp

@@ -110 +110 @@
     int sp=current_space;
     current_space=PERM_SPACE;
-    ((LispSymbol *)symbol)->SetNumber(num);
+    ((LSymbol *)symbol)->SetNumber(num);
     current_space=sp;
   }
@@ -119 +119 @@
     lbreak("symbol has been assigned value %d, but value already in use by state %s\n"
        "use a different symbol for this state\n",
-       lstring_value(((LispSymbol *)seq_syms[num])->GetName()));
+       lstring_value(((LSymbol *)seq_syms[num])->GetName()));
     exit(0);
   } else if (num>=ts)
@@ -173 +173 @@
     return 0;
   }
-  return LispNumber::Create(current_object->lvars[t->var_index[number]]);
+  return LNumber::Create(current_object->lvars[t->var_index[number]]);
 }
 
@@ -202 +202 @@
   /* First see if the variable has been defined for another object
      if so report a conflict if any occur */
-  LispSymbol *s=(LispSymbol *)symbol;
+  LSymbol *s=(LSymbol *)symbol;
   if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
   {
@@ -210 +210 @@
   } else if (DEFINEDP(s->value))
   {
-    int index=((LispObjectVar *)s->value)->number;
+    int index=((LObjectVar *)s->value)->number;
     if (index<tiv)
     {
@@ -219 +219 @@
            "  with index %d, but %s has a var listed '%s' with same index\n"
            "  try moving definition of %s before previously declared object",
-           lstring_value(((LispSymbol *)name)->GetName()),
-           lstring_value(((LispSymbol *)symbol)->GetName()),
+           lstring_value(((LSymbol *)name)->GetName()),
+           lstring_value(((LSymbol *)symbol)->GetName()),
            index,
-           lstring_value(((LispSymbol *)name)->GetName()),
-           lstring_value(((LispSymbol *)vars[index])->GetName()),
-           lstring_value(((LispSymbol *)name)->GetName())
+           lstring_value(((LSymbol *)name)->GetName()),
+           lstring_value(((LSymbol *)vars[index])->GetName()),
+           lstring_value(((LSymbol *)name)->GetName())
            );
     exit(0);
@@ -285 +285 @@
   }
   for (i=0;i<tiv;i++)
-    if (!strcmp(lstring_value(((LispSymbol *)vars[i])->GetName()),name))
+    if (!strcmp(lstring_value(((LSymbol *)vars[i])->GetName()),name))
       return 1;
   return 0;
@@ -301 +301 @@
   tiv=0;
 
-  LispSymbol *l_abil =   LispSymbol::FindOrCreate("abilities");
-  LispSymbol *l_funs =   LispSymbol::FindOrCreate("funs");
-  LispSymbol *l_states = LispSymbol::FindOrCreate("states");
-  LispSymbol *l_flags =  LispSymbol::FindOrCreate("flags");
-  LispSymbol *l_range =  LispSymbol::FindOrCreate("range");
-  LispSymbol *l_draw_range = LispSymbol::FindOrCreate("draw_range");
-  LispSymbol *l_fields = LispSymbol::FindOrCreate("fields");
-  LispSymbol *l_logo =   LispSymbol::FindOrCreate("logo");
-  LispSymbol *l_vars =   LispSymbol::FindOrCreate("vars");
+  LSymbol *l_abil =   LSymbol::FindOrCreate("abilities");
+  LSymbol *l_funs =   LSymbol::FindOrCreate("funs");
+  LSymbol *l_states = LSymbol::FindOrCreate("states");
+  LSymbol *l_flags =  LSymbol::FindOrCreate("flags");
+  LSymbol *l_range =  LSymbol::FindOrCreate("range");
+  LSymbol *l_draw_range = LSymbol::FindOrCreate("draw_range");
+  LSymbol *l_fields = LSymbol::FindOrCreate("fields");
+  LSymbol *l_logo =   LSymbol::FindOrCreate("logo");
+  LSymbol *l_vars =   LSymbol::FindOrCreate("vars");
 
   memset(fun_table,0,sizeof(fun_table));     // destory all hopes of fun
@@ -336 +336 @@
       for (i=0;i<TOTAL_ABILITIES;i++)
       {
-    Cell *ab=assoc(LispSymbol::FindOrCreate(ability_names[i]),l);
+    Cell *ab=assoc(LSymbol::FindOrCreate(ability_names[i]),l);
     PtrRef r5(ab);
     if (!NILP(ab))
@@ -347 +347 @@
       for (i=0;i<TOTAL_OFUNS;i++)
       {
-    Cell *ab=assoc(LispSymbol::FindOrCreate(ofun_names[i]),l);
+    Cell *ab=assoc(LSymbol::FindOrCreate(ofun_names[i]),l);
     PtrRef r5(ab);
     if (!NILP(ab) && lcar(lcdr(ab)))
@@ -358 +358 @@
       for (i=0;i<TOTAL_CFLAGS;i++)
       {
-    Cell *ab=assoc(LispSymbol::FindOrCreate(cflag_names[i]),l);
+    Cell *ab=assoc(LSymbol::FindOrCreate(cflag_names[i]),l);
     PtrRef r5(ab);
     if (!NILP(ab) && eval(lcar(lcdr(ab))))
@@ -440 +440 @@
   if (!seq[stopped])
     lbreak("object (%s) has no stopped state, please define one!\n",
-       lstring_value(((LispSymbol *)name)->GetName()));
+       lstring_value(((LSymbol *)name)->GetName()));
 
 /*  char *fn=lstring_value(lcar(desc));

abuse/trunk/src/clisp.cpp

@@ -39 +39 @@
 
 // the following are references to lisp symbols
-LispSymbol *l_chat_input, *l_post_render;
-
-LispSymbol *l_difficulty, *l_easy, *l_hard, *l_medium, *l_extreme,
+LSymbol *l_chat_input, *l_post_render;
+
+LSymbol *l_difficulty, *l_easy, *l_hard, *l_medium, *l_extreme,
     *l_max_hp, *l_max_power,
     *l_empty_cache;
 
-// FIXME: port these to LispSymbol
+// FIXME: port these to LSymbol
 void *l_main_menu, *l_logo,*l_state_art,*l_abilities,*l_state_sfx,
      *l_song_list,*l_filename,*l_sfx_directory,*l_default_font,
@@ -103 +103 @@
                                              // to irnterface with c
 {
-  l_easy = LispSymbol::FindOrCreate("easy");
-  l_medium = LispSymbol::FindOrCreate("medium");
-  l_hard = LispSymbol::FindOrCreate("hard");
-  l_extreme = LispSymbol::FindOrCreate("extreme");
-
-  l_logo = LispSymbol::FindOrCreate("logo");
-  l_morph = LispSymbol::FindOrCreate("morph");
-
-  l_pushx = LispSymbol::FindOrCreate("pushx");
-  l_pushy = LispSymbol::FindOrCreate("pushy");
-
-  l_dist = LispSymbol::FindOrCreate("dist");
-  l_state_art = LispSymbol::FindOrCreate("state_art");
-  l_abilities = LispSymbol::FindOrCreate("abilities");
-  l_default_abilities = LispSymbol::FindOrCreate("default_abilities");
-  l_state_sfx = LispSymbol::FindOrCreate("state_sfx");
-  l_filename = LispSymbol::FindOrCreate("filename");
-  l_sfx_directory = LispSymbol::FindOrCreate("sfx_directory");
-  l_default_font = LispSymbol::FindOrCreate("default_font");
-  l_console_font = LispSymbol::FindOrCreate("console_font");
-  l_default_ai_function = LispSymbol::FindOrCreate("default_ai");
-  l_tile_files = LispSymbol::FindOrCreate("tile_files");
-  l_empty_cache = LispSymbol::FindOrCreate("empty_cache");
-  l_range = LispSymbol::FindOrCreate("range");
-  l_difficulty = LispSymbol::FindOrCreate("difficulty");
-  l_death_handler = LispSymbol::FindOrCreate("death_handler");
-  l_title_screen = LispSymbol::FindOrCreate("title_screen");
-  l_fields = LispSymbol::FindOrCreate("fields");
-  l_FIRE = LispSymbol::FindOrCreate("FIRE");
-  l_fire_object = LispSymbol::FindOrCreate("fire_object");
-  l_cop_dead_parts = LispSymbol::FindOrCreate("cop_dead_parts");
+  l_easy = LSymbol::FindOrCreate("easy");
+  l_medium = LSymbol::FindOrCreate("medium");
+  l_hard = LSymbol::FindOrCreate("hard");
+  l_extreme = LSymbol::FindOrCreate("extreme");
+
+  l_logo = LSymbol::FindOrCreate("logo");
+  l_morph = LSymbol::FindOrCreate("morph");
+
+  l_pushx = LSymbol::FindOrCreate("pushx");
+  l_pushy = LSymbol::FindOrCreate("pushy");
+
+  l_dist = LSymbol::FindOrCreate("dist");
+  l_state_art = LSymbol::FindOrCreate("state_art");
+  l_abilities = LSymbol::FindOrCreate("abilities");
+  l_default_abilities = LSymbol::FindOrCreate("default_abilities");
+  l_state_sfx = LSymbol::FindOrCreate("state_sfx");
+  l_filename = LSymbol::FindOrCreate("filename");
+  l_sfx_directory = LSymbol::FindOrCreate("sfx_directory");
+  l_default_font = LSymbol::FindOrCreate("default_font");
+  l_console_font = LSymbol::FindOrCreate("console_font");
+  l_default_ai_function = LSymbol::FindOrCreate("default_ai");
+  l_tile_files = LSymbol::FindOrCreate("tile_files");
+  l_empty_cache = LSymbol::FindOrCreate("empty_cache");
+  l_range = LSymbol::FindOrCreate("range");
+  l_difficulty = LSymbol::FindOrCreate("difficulty");
+  l_death_handler = LSymbol::FindOrCreate("death_handler");
+  l_title_screen = LSymbol::FindOrCreate("title_screen");
+  l_fields = LSymbol::FindOrCreate("fields");
+  l_FIRE = LSymbol::FindOrCreate("FIRE");
+  l_fire_object = LSymbol::FindOrCreate("fire_object");
+  l_cop_dead_parts = LSymbol::FindOrCreate("cop_dead_parts");
   l_difficulty->SetValue(l_hard);
-  l_restart_player = LispSymbol::FindOrCreate("restart_player");
-  l_help_screens = LispSymbol::FindOrCreate("help_screens");
-  l_save_order = LispSymbol::FindOrCreate("save_order");
-  l_next_song = LispSymbol::FindOrCreate("next_song");
-  l_player_draw = LispSymbol::FindOrCreate("player_draw");
-  l_sneaky_draw = LispSymbol::FindOrCreate("sneaky_draw");
-  l_keep_backup = LispSymbol::FindOrCreate("keep_backup");
-  l_level_loaded = LispSymbol::FindOrCreate("level_loaded");
-
-  l_draw_fast = LispSymbol::FindOrCreate("draw_fast");
-  l_player_tints = LispSymbol::FindOrCreate("player_tints");
-
-  l_max_hp = LispSymbol::FindOrCreate("max_hp");
+  l_restart_player = LSymbol::FindOrCreate("restart_player");
+  l_help_screens = LSymbol::FindOrCreate("help_screens");
+  l_save_order = LSymbol::FindOrCreate("save_order");
+  l_next_song = LSymbol::FindOrCreate("next_song");
+  l_player_draw = LSymbol::FindOrCreate("player_draw");
+  l_sneaky_draw = LSymbol::FindOrCreate("sneaky_draw");
+  l_keep_backup = LSymbol::FindOrCreate("keep_backup");
+  l_level_loaded = LSymbol::FindOrCreate("level_loaded");
+
+  l_draw_fast = LSymbol::FindOrCreate("draw_fast");
+  l_player_tints = LSymbol::FindOrCreate("player_tints");
+
+  l_max_hp = LSymbol::FindOrCreate("max_hp");
   l_max_hp->SetNumber(200);
-  l_max_power = LispSymbol::FindOrCreate("max_power");
-  l_main_menu = LispSymbol::FindOrCreate("main_menu");
+  l_max_power = LSymbol::FindOrCreate("max_power");
+  l_main_menu = LSymbol::FindOrCreate("main_menu");
   l_max_power->SetNumber(999);
 
-  LispSymbol::FindOrCreate("run_state")->SetNumber(RUN_STATE);
-  LispSymbol::FindOrCreate("pause_state")->SetNumber(PAUSE_STATE);
-  LispSymbol::FindOrCreate("menu_state")->SetNumber(MENU_STATE);
-  LispSymbol::FindOrCreate("scene_state")->SetNumber(SCENE_STATE);
-
-  l_statbar_ammo_x = LispSymbol::FindOrCreate("statbar_ammo_x");
-  l_statbar_ammo_y = LispSymbol::FindOrCreate("statbar_ammo_y");
-  l_statbar_ammo_w = LispSymbol::FindOrCreate("statbar_ammo_w");
-  l_statbar_ammo_h = LispSymbol::FindOrCreate("statbar_ammo_h");
-  l_statbar_ammo_bg_color = LispSymbol::FindOrCreate("statbar_ammo_bg_color");
-
-  l_statbar_health_x = LispSymbol::FindOrCreate("statbar_health_x");
-  l_statbar_health_y = LispSymbol::FindOrCreate("statbar_health_y");
-  l_statbar_health_w = LispSymbol::FindOrCreate("statbar_health_w");
-  l_statbar_health_h = LispSymbol::FindOrCreate("statbar_health_h");
-  l_statbar_health_bg_color = LispSymbol::FindOrCreate("statbar_health_bg_color");
-
-  l_statbar_logo_x = LispSymbol::FindOrCreate("statbar_logo_x");
-  l_statbar_logo_y = LispSymbol::FindOrCreate("statbar_logo_y");
-  l_object = LispSymbol::FindOrCreate("object");
-  l_tile = LispSymbol::FindOrCreate("tile");
-  l_cdc_logo = LispSymbol::FindOrCreate("logo");
-
-  l_switch_to_powerful = LispSymbol::FindOrCreate("switch_to_powerful");
-  l_mouse_can_switch = LispSymbol::FindOrCreate("mouse_can_switch");
-  l_ask_save_slot = LispSymbol::FindOrCreate("ask_save_slot");
-
-  l_level_load_start = LispSymbol::FindOrCreate("level_load_start");
-  l_level_load_end = LispSymbol::FindOrCreate("level_load_end");
-  l_get_local_input = LispSymbol::FindOrCreate("get_local_input");
-  l_chat_input = LispSymbol::FindOrCreate("chat_input");
-  l_player_text_color = LispSymbol::FindOrCreate("player_text_color");
+  LSymbol::FindOrCreate("run_state")->SetNumber(RUN_STATE);
+  LSymbol::FindOrCreate("pause_state")->SetNumber(PAUSE_STATE);
+  LSymbol::FindOrCreate("menu_state")->SetNumber(MENU_STATE);
+  LSymbol::FindOrCreate("scene_state")->SetNumber(SCENE_STATE);
+
+  l_statbar_ammo_x = LSymbol::FindOrCreate("statbar_ammo_x");
+  l_statbar_ammo_y = LSymbol::FindOrCreate("statbar_ammo_y");
+  l_statbar_ammo_w = LSymbol::FindOrCreate("statbar_ammo_w");
+  l_statbar_ammo_h = LSymbol::FindOrCreate("statbar_ammo_h");
+  l_statbar_ammo_bg_color = LSymbol::FindOrCreate("statbar_ammo_bg_color");
+
+  l_statbar_health_x = LSymbol::FindOrCreate("statbar_health_x");
+  l_statbar_health_y = LSymbol::FindOrCreate("statbar_health_y");
+  l_statbar_health_w = LSymbol::FindOrCreate("statbar_health_w");
+  l_statbar_health_h = LSymbol::FindOrCreate("statbar_health_h");
+  l_statbar_health_bg_color = LSymbol::FindOrCreate("statbar_health_bg_color");
+
+  l_statbar_logo_x = LSymbol::FindOrCreate("statbar_logo_x");
+  l_statbar_logo_y = LSymbol::FindOrCreate("statbar_logo_y");
+  l_object = LSymbol::FindOrCreate("object");
+  l_tile = LSymbol::FindOrCreate("tile");
+  l_cdc_logo = LSymbol::FindOrCreate("logo");
+
+  l_switch_to_powerful = LSymbol::FindOrCreate("switch_to_powerful");
+  l_mouse_can_switch = LSymbol::FindOrCreate("mouse_can_switch");
+  l_ask_save_slot = LSymbol::FindOrCreate("ask_save_slot");
+
+  l_level_load_start = LSymbol::FindOrCreate("level_load_start");
+  l_level_load_end = LSymbol::FindOrCreate("level_load_end");
+  l_get_local_input = LSymbol::FindOrCreate("get_local_input");
+  l_chat_input = LSymbol::FindOrCreate("chat_input");
+  l_player_text_color = LSymbol::FindOrCreate("player_text_color");
 
   int i;
   for (i=0;i<MAX_STATE;i++)
-    LispSymbol::FindOrCreate(state_names[i])->SetNumber(i);
+    LSymbol::FindOrCreate(state_names[i])->SetNumber(i);
   for (i=0;i<TOTAL_ABILITIES;i++)
-    LispSymbol::FindOrCreate(ability_names[i])->SetNumber(i);
+    LSymbol::FindOrCreate(ability_names[i])->SetNumber(i);
   for (i=0;i<TOTAL_CFLAGS;i++)
-    LispSymbol::FindOrCreate(cflag_names[i])->SetNumber(i);
-
-  l_song_list = LispSymbol::FindOrCreate("song_list");
-  l_post_render = LispSymbol::FindOrCreate("post_render");
+    LSymbol::FindOrCreate(cflag_names[i])->SetNumber(i);
+
+  l_song_list = LSymbol::FindOrCreate("song_list");
+  l_post_render = LSymbol::FindOrCreate("post_render");
 
   add_c_function("distx",0,0,                   1);
@@ -581 +581 @@
     exit(0);
       }
-      return eval_function((LispSymbol *)ai,NULL);
+      return eval_function((LSymbol *)ai,NULL);
     } break;
     case 1 :
@@ -709 +709 @@
       void *f=figures[current_object->otype]->get_fun(OFUN_USER_FUN);
       if (!f) return NULL;
-      return eval_function((LispSymbol *)f,args);
+      return eval_function((LSymbol *)f,args);
     } break;
     case 17 :
@@ -725 +725 @@
     } break;
     case 18 :
-    { return LispString::Create(object_names[current_object->otype]); } break;
+    { return LString::Create(object_names[current_object->otype]); } break;
     case 19 :
     { return current_object->float_tick(); } break;
@@ -758 +758 @@
     case 23 :         // def_character
     {
-      LispSymbol *sym=(LispSymbol *)lcar(args);
+      LSymbol *sym=(LSymbol *)lcar(args);
       if (item_type(sym)!=L_SYMBOL)
       {
@@ -782 +782 @@
       figures[total_objects]=new character_type(CDR(args),sym);
       total_objects++;
-      return LispNumber::Create(total_objects-1);
+      return LNumber::Create(total_objects-1);
     } break;
     case 24 :
@@ -792 +792 @@
       current_level->foreground_intersect(x1,y1,x2,y2);
       void *ret=NULL;
-      push_onto_list(LispNumber::Create(y2),ret);
-      push_onto_list(LispNumber::Create(x2),ret);
+      push_onto_list(LNumber::Create(y2),ret);
+      push_onto_list(LNumber::Create(x2),ret);
       return ret;
     } break;
@@ -799 +799 @@
     {
 #ifdef __linux__
-      return LispSymbol::FindOrCreate("LINUX");
+      return LSymbol::FindOrCreate("LINUX");
 #endif
 #ifdef __sgi
-      return LispSymbol::FindOrCreate("IRIX");
+      return LSymbol::FindOrCreate("IRIX");
 #endif
 #ifdef __WIN32
-      return LispSymbol::FindOrCreate("WIN32");
+      return LSymbol::FindOrCreate("WIN32");
 #endif
     } break;
     case 26 :
     {
-      return LispString::Create(current_level->name());
+      return LString::Create(current_level->name());
     } break;
     case 27 : return ant_ai(); break;
@@ -855 +855 @@
       char nm[50];
       last_savegame_name(nm);
-      return LispString::Create(nm);
+      return LString::Create(nm);
     } break;
     case 45 :
@@ -863 +863 @@
 //      get_savegame_name(nm);
       the_game->reset_keymap();
-      return LispString::Create(nm);
+      return LString::Create(nm);
     } break;
     case 46 :
     {
-      return LispString::Create(start_argv[lnumber_value(eval(CAR(args)))]);
+      return LString::Create(start_argv[lnumber_value(eval(CAR(args)))]);
     } break;
     case 47 :
@@ -878 +878 @@
       void *ret=NULL;
       PtrRef r1(ret);
-      push_onto_list(LispNumber::Create(b3),ret);
-      push_onto_list(LispNumber::Create(b2),ret);
-      push_onto_list(LispNumber::Create(b1),ret);
-      push_onto_list(LispNumber::Create(yv),ret);
-      push_onto_list(LispNumber::Create(xv),ret);
+      push_onto_list(LNumber::Create(b3),ret);
+      push_onto_list(LNumber::Create(b2),ret);
+      push_onto_list(LNumber::Create(b1),ret);
+      push_onto_list(LNumber::Create(yv),ret);
+      push_onto_list(LNumber::Create(xv),ret);
       return ret;
     } break;
@@ -890 +890 @@
       {
     PtrRef r1(ret);
-    push_onto_list(LispNumber::Create((last_demo_mbut&4)==4),ret);
-    push_onto_list(LispNumber::Create((last_demo_mbut&2)==2),ret);
-    push_onto_list(LispNumber::Create((last_demo_mbut&1)==1),ret);
-    push_onto_list(LispNumber::Create(last_demo_my),ret);
-    push_onto_list(LispNumber::Create(last_demo_mx),ret);
+    push_onto_list(LNumber::Create((last_demo_mbut&4)==4),ret);
+    push_onto_list(LNumber::Create((last_demo_mbut&2)==2),ret);
+    push_onto_list(LNumber::Create((last_demo_mbut&1)==1),ret);
+    push_onto_list(LNumber::Create(last_demo_my),ret);
+    push_onto_list(LNumber::Create(last_demo_mx),ret);
       }
       return ret;
@@ -908 +908 @@
       {
     PtrRef r1(ret);
-    push_onto_list(LispNumber::Create(ry),ret);
-    push_onto_list(LispNumber::Create(rx),ret);
+    push_onto_list(LNumber::Create(ry),ret);
+    push_onto_list(LNumber::Create(rx),ret);
       }
       return ret;
@@ -923 +923 @@
       {
     PtrRef r1(ret);
-    push_onto_list(LispNumber::Create(ry),ret);
-    push_onto_list(LispNumber::Create(rx),ret);
+    push_onto_list(LNumber::Create(ry),ret);
+    push_onto_list(LNumber::Create(rx),ret);
       }
       return ret;
@@ -935 +935 @@
         lbreak("object is not a player, cannot return name");
       else
-        return LispString::Create(c->name);
+        return LString::Create(c->name);
     } break;
     case 54 :
@@ -941 +941 @@
       char cd[150];
       getcwd(cd,100);
-      return LispString::Create(cd);
+      return LString::Create(cd);
     } break;
     case 55 :
@@ -964 +964 @@
     *tp=0;
       }
-      return LispString::Create(tmp);
+      return LString::Create(tmp);
     } break;
     case 58 :
@@ -976 +976 @@
     PtrRef r1(fl),r2(dl);
     
-    for (i=tfiles-1;i>=0;i--) { push_onto_list(LispString::Create(files[i]),fl); free(files[i]); }
+    for (i=tfiles-1;i>=0;i--) { push_onto_list(LString::Create(files[i]),fl); free(files[i]); }
     free(files);
 
-    for (i=tdirs-1;i>=0;i--) { push_onto_list(LispString::Create(dirs[i]),dl); free(dirs[i]); }
+    for (i=tdirs-1;i>=0;i--) { push_onto_list(LString::Create(dirs[i]),dl); free(dirs[i]); }
     free(dirs);
     
@@ -1012 +1012 @@
         {
           sprintf(name2,"%s%04ld.pcx",name,i);
-          push_onto_list(LispString::Create(name2),ret);
+          push_onto_list(LString::Create(name2),ret);
         }
       } else
@@ -1019 +1019 @@
         {
           sprintf(name2,"%s%04ld.pcx",name,i);
-          push_onto_list(LispString::Create(name2),ret);
+          push_onto_list(LString::Create(name2),ret);
         }
       }
@@ -1355 +1355 @@
     case 133 :  // def_sound
     {
-      LispSymbol *sym=NULL;
+      LSymbol *sym=NULL;
       if (CDR(args))
       {
-    sym=(LispSymbol *)lcar(args);
+    sym=(LSymbol *)lcar(args);
     if (item_type(sym)!=L_SYMBOL)
     {
@@ -2264 +2264 @@
     current_object=v->focus;
 
-    eval_function((LispSymbol *)l_restart_player,NULL);
+    eval_function((LSymbol *)l_restart_player,NULL);
     v->reset_player();
     v->focus->set_aistate(0);

abuse/trunk/src/clisp.h

@@ -14 +14 @@
 
 // variables for the status bar
-extern LispSymbol *l_chat_input, *l_post_render;
+extern LSymbol *l_chat_input, *l_post_render;
 
-// FIXME: port these to LispSymbol
+// FIXME: port these to LSymbol
 extern void *l_statbar_ammo_x,*l_statbar_ammo_y,
             *l_statbar_ammo_w,*l_statbar_ammo_h,
@@ -42 +42 @@
 
 /******************************** Lisp objects **********************************/
-extern LispSymbol *l_difficulty, *l_easy, *l_hard, *l_medium, *l_extreme,
+extern LSymbol *l_difficulty, *l_easy, *l_hard, *l_medium, *l_extreme,
     *l_max_hp, *l_max_power,
     *l_empty_cache;
 
-// FIXME: port these to LispSymbol
+// FIXME: port these to LSymbol
 extern void *l_main_menu,
      *l_logo,*l_state_art,*l_default_abilities,*l_abilities,

abuse/trunk/src/compiled.cpp

@@ -42 +42 @@
 static int32_t c_state(char const *name)
 {
-  void *sym = LispSymbol::Find(name);
+  void *sym = LSymbol::Find(name);
   if (sym)
   {
-    if (item_type(((LispSymbol *)sym)->value)!=L_NUMBER)
+    if (item_type(((LSymbol *)sym)->value)!=L_NUMBER)
       compile_error=1;
     else
-      return lnumber_value(((LispSymbol *)sym)->value);
+      return lnumber_value(((LSymbol *)sym)->value);
   } else compile_error=1;
   return 0;
@@ -122 +122 @@
   S_DELETE_SND=  c_state("DEL_OBJECT_SND");
 
-  void *b = LispSymbol::FindOrCreate("bad_guy_list");
+  void *b = LSymbol::FindOrCreate("bad_guy_list");
   if (b && DEFINEDP(symbol_value(b)))
   {
@@ -138 +138 @@
   }
 
-  void *v = LispSymbol::FindOrCreate("last_save_game")->GetValue();
+  void *v = LSymbol::FindOrCreate("last_save_game")->GetValue();
   if (DEFINEDP(v))
     last_save_game_number=lnumber_value(v);

abuse/trunk/src/configuration.cpp

@@ -36 +36 @@
     char tmp[40];
     sprintf( tmp, "player%d", player );
-    LispSymbol *f = LispSymbol::Find(tmp);
+    LSymbol *f = LSymbol::Find(tmp);
     if( !NILP(f) && DEFINEDP(f->GetValue()))
     {
         void *what = f->GetValue();
-        if(what == LispSymbol::FindOrCreate("keyboard"))
+        if(what == LSymbol::FindOrCreate("keyboard"))
             return 1;
-        else if(what == LispSymbol::FindOrCreate("joystick"))
+        else if(what == LSymbol::FindOrCreate("joystick"))
             return 2;
     }

abuse/trunk/src/cop.cpp

@@ -228 +228 @@
   PtrRef r1(list);
   push_onto_list(new_lisp_pointer(target),list);
-  push_onto_list(LispNumber::Create(angle),list);
-  push_onto_list(LispNumber::Create(y2),list);
-  push_onto_list(LispNumber::Create(x2),list);
-  push_onto_list(LispNumber::Create(type),list);
+  push_onto_list(LNumber::Create(angle),list);
+  push_onto_list(LNumber::Create(y2),list);
+  push_onto_list(LNumber::Create(x2),list);
+  push_onto_list(LNumber::Create(type),list);
   push_onto_list(new_lisp_pointer(o->get_object(0)),list);
-  eval_function((LispSymbol *)l_fire_object,list);
+  eval_function((LSymbol *)l_fire_object,list);
   o->lvars[top_just_fired]=1;
   other->lvars[just_fired]=1;
@@ -260 +260 @@
     o->lvars[fire_delay1]=3;
     if (player_fire_weapon(o,SHOTGUN,NULL,o->lvars[point_angle],small_fire_off))
-          ret=LispNumber::Create(-1);
-    else ret=LispNumber::Create(0);
+          ret=LNumber::Create(-1);
+    else ret=LNumber::Create(0);
       } else
       {
     o->lvars[fire_delay1]=5;                  // no ammo, set large fire delay for next shot
     player_fire_weapon(o,SHOTGUN,NULL,o->lvars[point_angle],small_fire_off);
-    ret=LispNumber::Create(0);
+    ret=LNumber::Create(0);
       }
-    } else ret=LispNumber::Create(0);                // can't fire yet, return 0 ammo subtract
+    } else ret=LNumber::Create(0);                // can't fire yet, return 0 ammo subtract
   }
   return ret;
@@ -303 +303 @@
     if (player_fire_weapon(o,ammo_type(o->otype),NULL,o->lvars[point_angle],
                    o->otype==DFRIS ? large_fire_off : small_fire_off ))    
-          ret=LispNumber::Create(-1);
-    else ret=LispNumber::Create(0);
-      } else ret=LispNumber::Create(0);
-    } else ret=LispNumber::Create(0);                // can't fire yet, return 0 ammo subtract
+          ret=LNumber::Create(-1);
+    else ret=LNumber::Create(0);
+      } else ret=LNumber::Create(0);
+    } else ret=LNumber::Create(0);                // can't fire yet, return 0 ammo subtract
   }
   return ret;
@@ -329 +329 @@
     o->lvars[fire_delay1]=2;
     if (player_fire_weapon(o,PLASMA,NULL,o->lvars[point_angle],small_fire_off))    
-          ret=LispNumber::Create(-1);
-    else ret=LispNumber::Create(0);
-      } else ret=LispNumber::Create(0);
-    } else ret=LispNumber::Create(0);                // can't fire yet, return 0 ammo subtract
+          ret=LNumber::Create(-1);
+    else ret=LNumber::Create(0);
+      } else ret=LNumber::Create(0);
+    } else ret=LNumber::Create(0);                // can't fire yet, return 0 ammo subtract
   }
   return ret;
@@ -354 +354 @@
     if (player_fire_weapon(o,LSABER,NULL,o->lvars[point_angle]+(current_level->tick_counter()&7)-8,
                    small_fire_off))
-          ret=LispNumber::Create(-1);
-    else ret=LispNumber::Create(0);
-      } else ret=LispNumber::Create(0);
-    } else ret=LispNumber::Create(0);                // can't fire yet, return 0 ammo subtract
+          ret=LNumber::Create(-1);
+    else ret=LNumber::Create(0);
+      } else ret=LNumber::Create(0);
+    } else ret=LNumber::Create(0);                // can't fire yet, return 0 ammo subtract
   }
   return ret;
@@ -403 +403 @@
     }
     if (player_fire_weapon(o,ROCKET,target,o->lvars[point_angle],large_fire_off))    
-          ret=LispNumber::Create(-1);
-    else ret=LispNumber::Create(0);
-
-      } else ret=LispNumber::Create(0);
-    } else ret=LispNumber::Create(0);                // can't fire yet, return 0 ammo subtract
+          ret=LNumber::Create(-1);
+    else ret=LNumber::Create(0);
+
+      } else ret=LNumber::Create(0);
+    } else ret=LNumber::Create(0);                // can't fire yet, return 0 ammo subtract
   }
   return ret;
@@ -658 +658 @@
       view *v=o->controller();
 
-      push_onto_list(LispNumber::Create(v->weapon_total(v->current_weapon)),args);
+      push_onto_list(LNumber::Create(v->weapon_total(v->current_weapon)),args);
       push_onto_list(l_FIRE,args);
 
       current_object=top;
-      void *ret=eval_function((LispSymbol *)figures[top->otype]->get_fun(OFUN_USER_FUN),args);    
+      void *ret=eval_function((LSymbol *)figures[top->otype]->get_fun(OFUN_USER_FUN),args);    
       current_object=o;
       v->add_ammo(v->current_weapon,lnumber_value(ret));    
@@ -672 +672 @@
       {
         // call the user function to reset the player
-    eval_function((LispSymbol *)l_restart_player,NULL);
+    eval_function((LSymbol *)l_restart_player,NULL);
     o->controller()->reset_player();
     o->set_aistate(0);
@@ -681 +681 @@
   }
 
-  return LispNumber::Create(ret);
+  return LNumber::Create(ret);
 }
 
@@ -727 +727 @@
     if (o->lvars[just_fired_var])
     {
-      o->draw_double_tint(lnumber_value(((LispArray *)((LispSymbol *)l_player_tints)->GetValue())->Get(num)), S_bright_tint);
+      o->draw_double_tint(lnumber_value(((LArray *)((LSymbol *)l_player_tints)->GetValue())->Get(num)), S_bright_tint);
       o->lvars[just_fired_var]=0;
     } else
-      o->draw_tint(lnumber_value(((LispArray *)((LispSymbol *)l_player_tints)->GetValue())->Get(num)));
+      o->draw_tint(lnumber_value(((LArray *)((LSymbol *)l_player_tints)->GetValue())->Get(num)));
   }
   return NULL;
@@ -755 +755 @@
       PtrRef r1(ret);
 
-      push_onto_list(LispNumber::Create(bot->get_tint()),ret);
+      push_onto_list(LNumber::Create(bot->get_tint()),ret);
 
       if (bot->lvars[special_power]==SNEAKY_POWER)
@@ -766 +766 @@
       o->draw_predator();
       } else
-        eval_function((LispSymbol *)l_player_draw,ret);
+        eval_function((LSymbol *)l_player_draw,ret);
 
       o->y=oldy;
@@ -829 +829 @@
       case FAST_POWER :
       {
-    eval_function((LispSymbol *)l_draw_fast,NULL);
+    eval_function((LSymbol *)l_draw_fast,NULL);
     int old_state=o->state;
     switch (o->state)
@@ -1021 +1021 @@
     for (i=0;i<tp;i++)
     {
-      int color=lnumber_value(((LispArray *)((LispSymbol *)l_player_text_color)->GetValue())->Get(sorted_players[i]->get_tint()));
+      int color=lnumber_value(((LArray *)((LSymbol *)l_player_text_color)->GetValue())->Get(sorted_players[i]->get_tint()));
       sprintf(msg,"%3ld %s",(long)sorted_players[i]->kills,sorted_players[i]->name);
       if (sorted_players[i]==local)
@@ -1062 +1062 @@
   {
     enum { NAME_LEN=18 } ;
-    int color=lnumber_value(((LispArray *)((LispSymbol *)l_player_text_color)->GetValue())->Get(v->get_tint()));
+    int color=lnumber_value(((LArray *)((LSymbol *)l_player_text_color)->GetValue())->Get(v->get_tint()));
     char max_name[NAME_LEN];
     strncpy(max_name,v->name,NAME_LEN-1);

abuse/trunk/src/demo.h

@@ -16 +16 @@
 class demo_manager
 {
-  LispSymbol *initial_difficulty;
+  LSymbol *initial_difficulty;
   bFILE *record_file;
   int skip_next;

abuse/trunk/src/dev.cpp

@@ -42 +42 @@
 char const *symbol_str(char const *name)
 {
-  LispSymbol *sym = LispSymbol::FindOrCreate(name);
+  LSymbol *sym = LSymbol::FindOrCreate(name);
   if (sym->GetValue() && item_type(sym->GetValue())==L_STRING)
     return lstring_value(sym->GetValue());
@@ -67 +67 @@
 
   // check again to see if the symbol is there
-  sym = LispSymbol::FindOrCreate(name);
+  sym = LSymbol::FindOrCreate(name);
   if (sym->GetValue() && item_type(sym->GetValue())==L_STRING)
     return lstring_value(sym->GetValue());
@@ -73 +73 @@
 
   // check to see if there is a missing symbol definition
-  sym = LispSymbol::FindOrCreate("missing_sym");
+  sym = LSymbol::FindOrCreate("missing_sym");
   if (sym->GetValue() && item_type(sym->GetValue())==L_STRING)
     return lstring_value(sym->GetValue());

abuse/trunk/src/director.cpp

@@ -126 +126 @@
   pan_time=frame_time=text_time=NULL;
   int done=0;
-  LispSymbol *pan_symbol = LispSymbol::FindOrCreate("pan"),
-             *text_symbol = LispSymbol::FindOrCreate("text");
+  LSymbol *pan_symbol = LSymbol::FindOrCreate("pan"),
+             *text_symbol = LSymbol::FindOrCreate("text");
 
   JCFont *font=wm->font();

abuse/trunk/src/endgame.cpp

@@ -153 +153 @@
 
 
-  int explo_snd = lnumber_value(LispSymbol::FindOrCreate("P_EXPLODE_SND")->GetValue());
-  int space_snd = lnumber_value(LispSymbol::FindOrCreate("SPACE_SND")->GetValue());
-  int zip_snd = lnumber_value(LispSymbol::FindOrCreate("SHIP_ZIP_SND")->GetValue());
+  int explo_snd = lnumber_value(LSymbol::FindOrCreate("P_EXPLODE_SND")->GetValue());
+  int space_snd = lnumber_value(LSymbol::FindOrCreate("SPACE_SND")->GetValue());
+  int zip_snd = lnumber_value(LSymbol::FindOrCreate("SHIP_ZIP_SND")->GetValue());
 
 
@@ -370 +370 @@
     cmap[i]=pal->find_closest(i*256/32,i*256/32,i*256/32);
 
-  void *end_plot = LispSymbol::FindOrCreate("plot_end")->GetValue();
+  void *end_plot = LSymbol::FindOrCreate("plot_end")->GetValue();
 
 
@@ -427 +427 @@
   image *im=cache.img(cache.reg("art/endgame.spe","tbc",SPEC_IMAGE,1));
 
-  void *to_be = LispSymbol::FindOrCreate("to_be_continued")->GetValue();
+  void *to_be = LSymbol::FindOrCreate("to_be_continued")->GetValue();
   PtrRef r1(to_be);
 
-  void *mid_plot = LispSymbol::FindOrCreate("plot_middle")->GetValue();
+  void *mid_plot = LSymbol::FindOrCreate("plot_middle")->GetValue();
   PtrRef r2(mid_plot);
 
@@ -485 +485 @@
   int dx=(xres+1)/2-320/2,dy=(yres+1)/2-200/2;
 
-  void *end_plot = LispSymbol::FindOrCreate("plot_end")->GetValue();
+  void *end_plot = LSymbol::FindOrCreate("plot_end")->GetValue();
   PtrRef r2(end_plot);
 

abuse/trunk/src/game.cpp

@@ -1232 +1232 @@
     }
 
-    void *logo_snd = LispSymbol::FindOrCreate("LOGO_SND")->GetValue();
+    void *logo_snd = LSymbol::FindOrCreate("LOGO_SND")->GetValue();
 
     if(DEFINEDP(logo_snd) && (sound_avail & SFX_INITIALIZED))
@@ -1249 +1249 @@
     milli_wait(400);
 
-    void *space_snd = LispSymbol::FindOrCreate("SPACE_SND")->GetValue();
+    void *space_snd = LSymbol::FindOrCreate("SPACE_SND")->GetValue();
 
     fade_out(32);
@@ -1255 +1255 @@
 
     int i;
-    char *str = lstring_value(eval(LispSymbol::FindOrCreate("plot_start")));
+    char *str = lstring_value(eval(LSymbol::FindOrCreate("plot_start")));
 
     bFILE *fp = open_file("art/smoke.spe", "rb");
@@ -2344 +2344 @@
     int sp = current_space;
     current_space = PERM_SPACE;
-    eval_function((LispSymbol *)l_next_song, NULL);
+    eval_function((LSymbol *)l_next_song, NULL);
     current_space = sp;
       } */
@@ -2637 +2637 @@
     if(!(main_net_cfg && main_net_cfg->restart_state()))
     {
-      LispSymbol *end_msg = LispSymbol::FindOrCreate("end_msg");
+      LSymbol *end_msg = LSymbol::FindOrCreate("end_msg");
       if(DEFINEDP(end_msg->GetValue()))
       printf("%s\n", lstring_value(end_msg->GetValue()));

abuse/trunk/src/gamma.cpp

@@ -57 +57 @@
 static char const *lang_string(char const *symbol)
 {
-    LispSymbol *v = LispSymbol::Find(symbol);
+    LSymbol *v = LSymbol::Find(symbol);
     if (!v || !DEFINEDP(v->GetValue()))
         return "Language symbol missing!";
@@ -69 +69 @@
 
     // see if user has already done this routine
-    LispSymbol *gs = LispSymbol::Find("darkest_gray");
+    LSymbol *gs = LSymbol::Find("darkest_gray");
 
     if(old_pal)
@@ -182 +182 @@
                 int sp = current_space;
                 current_space = PERM_SPACE;
-                LispSymbol::FindOrCreate("darkest_gray")->SetNumber(dg);
+                LSymbol::FindOrCreate("darkest_gray")->SetNumber(dg);
 
                 current_space = sp;

abuse/trunk/src/lcache.cpp

@@ -27 +27 @@
     for (;b && item_type(b)==L_CONS_CELL;b=CDR(b))
     {
-      t+=sizeof(LispList);
+      t+=sizeof(LList);
     }
     if (b) t+=block_size(b);
@@ -34 +34 @@
     ret=t;
     } else if (type== L_NUMBER)
-    { ret=sizeof(LispNumber); }
+    { ret=sizeof(LNumber); }
     else if (type==L_CHARACTER)
-    { ret=sizeof(LispChar); }
+    { ret=sizeof(LChar); }
     else if (type==L_STRING)
     {
-      ret=sizeof(LispString)+strlen(lstring_value(level))+1;
+      ret=sizeof(LString)+strlen(lstring_value(level))+1;
       if (ret<8)
         ret=8;
     }
     else if (type==L_POINTER)
-    { ret=sizeof(LispPointer); }
+    { ret=sizeof(LPointer); }
     else ret=0;
   }
@@ -103 +103 @@
   {
     case L_NUMBER :
-    { return LispNumber::Create(fp->read_uint32()); } break;
+    { return LNumber::Create(fp->read_uint32()); } break;
     case L_CHARACTER :
     { return new_lisp_character(fp->read_uint16()); } break;
     case L_STRING :
     { long l=fp->read_uint32();
-      LispString *s = LispString::Create(l);
+      LString *s = LString::Create(l);
       fp->read(lstring_value(s),l);
       return s;
@@ -121 +121 @@
       {
     long x=abs(t);
-    LispList *last=NULL,*first=NULL;
+    LList *last=NULL,*first=NULL;
     while (x)
     {
-      LispList *c = LispList::Create();
+      LList *c = LList::Create();
       if (first)
         last->cdr=c;
@@ -131 +131 @@
       x--;
     }
-    last->cdr = (t < 0) ? (LispObject *)load_block(fp) : NULL;
+    last->cdr = (t < 0) ? (LObject *)load_block(fp) : NULL;
 
-    for (last=first,x=0;x<abs(t);x++,last=(LispList *)last->cdr)
-      last->car = (LispObject *)load_block(fp);
+    for (last=first,x=0;x<abs(t);x++,last=(LList *)last->cdr)
+      last->car = (LObject *)load_block(fp);
     return first;
       }

abuse/trunk/src/level.cpp

@@ -1080 +1080 @@
       {
         if (figures[new_type]->seq[k] &&
-           !strcmp(lstring_value(((LispSymbol *)figures[new_type]->seq_syms[k])->GetName()),old_name))
+           !strcmp(lstring_value(((LSymbol *)figures[new_type]->seq_syms[k])->GetName()),old_name))
         *(s_remap[i]+j)=k;
       }
@@ -1119 +1119 @@
           if (figures[new_type]->vars[k])
           {
-        if (!strcmp(lstring_value(((LispSymbol *)figures[new_type]->vars[k])->GetName()),old_name))
+        if (!strcmp(lstring_value(((LSymbol *)figures[new_type]->vars[k])->GetName()),old_name))
           *(v_remap[i]+j)=figures[new_type]->var_index[k];
           }
@@ -1510 +1510 @@
     void *arg_list=NULL;
     PtrRef r1(arg_list);
-    push_onto_list(LispString::Create(n),arg_list);
-    eval_function((LispSymbol *)l_level_loaded,arg_list);
+    push_onto_list(LString::Create(n),arg_list);
+    eval_function((LSymbol *)l_level_loaded,arg_list);
 
     current_space=sp;
@@ -1560 +1560 @@
     for (;j<figures[i]->ts;j++)
       if (figures[i]->seq[j])
-        size+=1+strlen(lstring_value(((LispSymbol *)figures[i]->seq_syms[j])->GetName()))+1;
+        size+=1+strlen(lstring_value(((LSymbol *)figures[i]->seq_syms[j])->GetName()))+1;
   }
   sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"describe_states",NULL,size,0));
@@ -1573 +1573 @@
     for (;j<figures[i]->tiv;j++)
       if (figures[i]->vars[j])
-        size+=1+strlen(lstring_value(((LispSymbol *)figures[i]->vars[j])->GetName()))+1;
+        size+=1+strlen(lstring_value(((LSymbol *)figures[i]->vars[j])->GetName()))+1;
   }
   sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"describe_lvars",NULL,size,0));
@@ -1827 +1827 @@
   } else
   {
-    LispSymbol *fun = LispSymbol::FindOrCreate("set_player_defaults");
+    LSymbol *fun = LSymbol::FindOrCreate("set_player_defaults");
     if (DEFINEDP(fun->GetFunction()))
     {
@@ -1887 +1887 @@
       if (figures[i]->seq[j])
       {
-    char *state_name=lstring_value(((LispSymbol *)figures[i]->seq_syms[j])->GetName());
+    char *state_name=lstring_value(((LSymbol *)figures[i]->seq_syms[j])->GetName());
     fp->write_uint8(strlen(state_name)+1);
     fp->write(state_name,strlen(state_name)+1);
@@ -1906 +1906 @@
         if (figures[i]->vars[j] && figures[i]->var_index[j]==x)
     {
-      char *var_name=lstring_value(((LispSymbol *)figures[i]->vars[j])->GetName());
+      char *var_name=lstring_value(((LSymbol *)figures[i]->vars[j])->GetName());
       fp->write_uint8(strlen(var_name)+1);
       fp->write(var_name,strlen(var_name)+1);

abuse/trunk/src/lisp/lisp.cpp

@@ -41 +41 @@
 
 bFILE *current_print_file=NULL;
-LispSymbol *lsym_root=NULL;
+LSymbol *lsym_root=NULL;
 long ltotal_syms=0;
 
@@ -220 +220 @@
 }
 
-LispArray *LispArray::Create(int size, void *rest)
+LArray *LArray::Create(int size, void *rest)
 {
   PtrRef r11(rest);
-  size_t s = sizeof(LispArray)
-           + ((size < 1 ? 1 : size) - 1) * sizeof(LispObject *);
-  LispArray *p = (LispArray *)lmalloc(s, current_space);
+  size_t s = sizeof(LArray)
+           + ((size < 1 ? 1 : size) - 1) * sizeof(LObject *);
+  LArray *p = (LArray *)lmalloc(s, current_space);
   p->type = L_1D_ARRAY;
   p->size = size;
-  LispObject **data = p->GetData();
-  memset(data, 0, size * sizeof(LispObject *));
+  LObject **data = p->GetData();
+  memset(data, 0, size * sizeof(LObject *));
   PtrRef r1(p);
 
@@ -247 +247 @@
           exit(0);
         }
-        data[i] = (LispObject *)CAR(x);
+        data[i] = (LObject *)CAR(x);
       }
       if (x)
@@ -261 +261 @@
       data = p->GetData();
       for (int i=0;i<size;i++)
-        data[i] = (LispObject *)x;
+        data[i] = (LObject *)x;
     }
     else
@@ -274 +274 @@
 }
 
-LispFixedPoint *new_lisp_fixed_point(int32_t x)
-{
-  LispFixedPoint *p=(LispFixedPoint *)lmalloc(sizeof(LispFixedPoint), current_space);
+LFixedPoint *new_lisp_fixed_point(int32_t x)
+{
+  LFixedPoint *p=(LFixedPoint *)lmalloc(sizeof(LFixedPoint), current_space);
   p->type=L_FIXED_POINT;
   p->x=x;
@@ -283 +283 @@
 
 
-LispObjectVar *new_lisp_object_var(int16_t number)
-{
-  LispObjectVar *p=(LispObjectVar *)lmalloc(sizeof(LispObjectVar), current_space);
+LObjectVar *new_lisp_object_var(int16_t number)
+{
+  LObjectVar *p=(LObjectVar *)lmalloc(sizeof(LObjectVar), current_space);
   p->type=L_OBJECT_VAR;
   p->number=number;
@@ -292 +292 @@
 
 
-struct LispPointer *new_lisp_pointer(void *addr)
+struct LPointer *new_lisp_pointer(void *addr)
 {
   if (addr==NULL) return NULL;
-  LispPointer *p=(LispPointer *)lmalloc(sizeof(LispPointer), current_space);
+  LPointer *p=(LPointer *)lmalloc(sizeof(LPointer), current_space);
   p->type=L_POINTER;
   p->addr=addr;
@@ -301 +301 @@
 }
 
-struct LispChar *new_lisp_character(uint16_t ch)
-{
-  LispChar *c=(LispChar *)lmalloc(sizeof(LispChar), current_space);
+struct LChar *new_lisp_character(uint16_t ch)
+{
+  LChar *c=(LChar *)lmalloc(sizeof(LChar), current_space);
   c->type=L_CHARACTER;
   c->ch=ch;
@@ -309 +309 @@
 }
 
-struct LispString *LispString::Create(char const *string)
-{
-    size_t size = sizeof(LispString) + strlen(string);
-    if (size < sizeof(LispRedirect))
-        size = sizeof(LispRedirect);
-
-    LispString *s = (LispString *)lmalloc(size, current_space);
+struct LString *LString::Create(char const *string)
+{
+    size_t size = sizeof(LString) + strlen(string);
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LString *s = (LString *)lmalloc(size, current_space);
     s->type = L_STRING;
     strcpy(s->str, string);
@@ -321 +321 @@
 }
 
-struct LispString *LispString::Create(char const *string, int length)
-{
-    size_t size = sizeof(LispString) + length;
-    if (size < sizeof(LispRedirect))
-        size = sizeof(LispRedirect);
-
-    LispString *s = (LispString *)lmalloc(size, current_space);
+struct LString *LString::Create(char const *string, int length)
+{
+    size_t size = sizeof(LString) + length;
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LString *s = (LString *)lmalloc(size, current_space);
     s->type = L_STRING;
     memcpy(s->str, string, length);
@@ -334 +334 @@
 }
 
-struct LispString *LispString::Create(int length)
-{
-    size_t size = sizeof(LispString) + length - 1;
-    if (size < sizeof(LispRedirect))
-        size = sizeof(LispRedirect);
-
-    LispString *s = (LispString *)lmalloc(size, current_space);
+struct LString *LString::Create(int length)
+{
+    size_t size = sizeof(LString) + length - 1;
+    if (size < sizeof(LRedirect))
+        size = sizeof(LRedirect);
+
+    LString *s = (LString *)lmalloc(size, current_space);
     s->type = L_STRING;
     s->str[0] = '\0';
@@ -347 +347 @@
 
 #ifdef NO_LIBS
-LispUserFunction *new_lisp_user_function(void *arg_list, void *block_list)
+LUserFunction *new_lisp_user_function(void *arg_list, void *block_list)
 {
   PtrRef r1(arg_list), r2(block_list);
-  LispUserFunction *lu=(LispUserFunction *)lmalloc(sizeof(LispUserFunction), current_space);
+  LUserFunction *lu=(LUserFunction *)lmalloc(sizeof(LUserFunction), current_space);
   lu->type=L_USER_FUNCTION;
   lu->arg_list=arg_list;
@@ -357 +357 @@
 }
 #else
-LispUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
+LUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
 {
   int sp=current_space;
@@ -363 +363 @@
     current_space=PERM_SPACE;       // make sure all functions get defined in permanant space
 
-  LispUserFunction *lu=(LispUserFunction *)lmalloc(sizeof(LispUserFunction), current_space);
+  LUserFunction *lu=(LUserFunction *)lmalloc(sizeof(LUserFunction), current_space);
   lu->type=L_USER_FUNCTION;
   lu->alist=arg_list;
@@ -375 +375 @@
 
 
-LispSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number)
+LSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number)
 {
   // sys functions should reside in permanant space
-  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
+  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
   ls->type=L_SYS_FUNCTION;
@@ -387 +387 @@
 }
 
-LispSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number)
+LSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number)
 {
   // sys functions should reside in permanant space
-  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
+  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
   ls->type=L_C_FUNCTION;
@@ -399 +399 @@
 }
 
-LispSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number)
+LSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number)
 {
   // sys functions should reside in permanant space
-  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
+  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
   ls->type=L_C_BOOL;
@@ -411 +411 @@
 }
 
-LispSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number)
+LSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number)
 {
   // sys functions should reside in permanant space
-  LispSysFunction *ls=(LispSysFunction *)lmalloc(sizeof(LispSysFunction),
+  LSysFunction *ls=(LSysFunction *)lmalloc(sizeof(LSysFunction),
                              current_space==GC_SPACE ? GC_SPACE : PERM_SPACE);
   ls->type=L_L_FUNCTION;
@@ -423 +423 @@
 }
 
-LispNumber *new_lisp_node(long num)
-{
-  LispNumber *n=(LispNumber *)lmalloc(sizeof(LispNumber), current_space);
+LNumber *new_lisp_node(long num)
+{
+  LNumber *n=(LNumber *)lmalloc(sizeof(LNumber), current_space);
   n->type=L_NUMBER;
   n->num=num;
@@ -431 +431 @@
 }
 
-LispSymbol *new_lisp_symbol(char *name)
-{
-  LispSymbol *s=(LispSymbol *)lmalloc(sizeof(LispSymbol), current_space);
+LSymbol *new_lisp_symbol(char *name)
+{
+  LSymbol *s=(LSymbol *)lmalloc(sizeof(LSymbol), current_space);
   s->type=L_SYMBOL;
-  s->name=LispString::Create(name);
+  s->name=LString::Create(name);
   s->value=l_undefined;
   s->function=l_undefined;
@@ -444 +444 @@
 }
 
-LispNumber *LispNumber::Create(long num)
-{
-    LispNumber *s = (LispNumber *)lmalloc(sizeof(LispNumber), current_space);
+LNumber *LNumber::Create(long num)
+{
+    LNumber *s = (LNumber *)lmalloc(sizeof(LNumber), current_space);
     s->type = L_NUMBER;
     s->num = num;
@@ -452 +452 @@
 }
 
-LispList *LispList::Create()
-{
-    LispList *c = (LispList *)lmalloc(sizeof(LispList), current_space);
+LList *LList::Create()
+{
+    LList *c = (LList *)lmalloc(sizeof(LList), current_space);
     c->type = L_CONS_CELL;
     c->car = NULL;
@@ -508 +508 @@
   }
 #endif
-  return ((LispPointer *)lpointer)->addr;
+  return ((LPointer *)lpointer)->addr;
 }
 
@@ -516 +516 @@
   {
     case L_NUMBER :
-      return ((LispNumber *)lnumber)->num;
+      return ((LNumber *)lnumber)->num;
     case L_FIXED_POINT :
-      return (((LispFixedPoint *)lnumber)->x)>>16;
+      return (((LFixedPoint *)lnumber)->x)>>16;
     case L_STRING :
       return (uint8_t)*lstring_value(lnumber);
@@ -533 +533 @@
 }
 
-char *LispString::GetString()
+char *LString::GetString()
 {
 #ifdef TYPE_CHECKING
@@ -557 +557 @@
   if (!c) return NULL;
   else if (item_type(c)==(ltype)L_CONS_CELL)
-    return ((LispList *)c)->cdr;
+    return ((LList *)c)->cdr;
   else
     return NULL;
@@ -566 +566 @@
   if (!c) return NULL;
   else if (item_type(c)==(ltype)L_CONS_CELL)
-    return ((LispList *)c)->car;
+    return ((LList *)c)->car;
   else return NULL;
 }
@@ -580 +580 @@
   }
 #endif
-  return ((LispChar *)c)->ch;
+  return ((LChar *)c)->ch;
 }
 
@@ -588 +588 @@
   {
     case L_NUMBER :
-      return ((LispNumber *)c)->num<<16; break;
+      return ((LNumber *)c)->num<<16; break;
     case L_FIXED_POINT :
-      return (((LispFixedPoint *)c)->x); break;
+      return (((LFixedPoint *)c)->x); break;
     default :
     {
@@ -609 +609 @@
     if (t1!=t2) return NULL;
     else if (t1==L_NUMBER)
-    { if (((LispNumber *)n1)->num==((LispNumber *)n2)->num)
+    { if (((LNumber *)n1)->num==((LNumber *)n2)->num)
         return true_symbol;
       else return NULL;
     } else if (t1==L_CHARACTER)
     {
-      if (((LispChar *)n1)->ch==((LispChar *)n2)->ch)
+      if (((LChar *)n1)->ch==((LChar *)n2)->ch)
         return true_symbol;
       else return NULL;
@@ -626 +626 @@
 }
 
-LispObject *LispArray::Get(long x)
+LObject *LArray::Get(long x)
 {
 #ifdef TYPE_CHECKING
@@ -784 +784 @@
 
 /*
-LispSymbol *find_symbol(char const *name)
-{
-  LispList *cs;
-  for (cs=(LispList *)symbol_list;cs;cs=(LispList *)CDR(cs))
-  {
-    if (!strcmp( ((char *)((LispSymbol *)cs->car)->name)+sizeof(LispString), name))
-      return (LispSymbol *)(cs->car);
+LSymbol *find_symbol(char const *name)
+{
+  LList *cs;
+  for (cs=(LList *)symbol_list;cs;cs=(LList *)CDR(cs))
+  {
+    if (!strcmp( ((char *)((LSymbol *)cs->car)->name)+sizeof(LString), name))
+      return (LSymbol *)(cs->car);
   }
   return NULL;
@@ -796 +796 @@
 
 
-LispSymbol *make_find_symbol(char const *name)    // find a symbol, if it doesn't exsist it is created
-{
-  LispSymbol *s=find_symbol(name);
+LSymbol *make_find_symbol(char const *name)    // find a symbol, if it doesn't exsist it is created
+{
+  LSymbol *s=find_symbol(name);
   if (s) return s;
   else
@@ -805 +805 @@
     if (current_space!=GC_SPACE)
       current_space=PERM_SPACE;       // make sure all symbols get defined in permanant space
-    LispList *cs;
-    cs=LispList::Create();
+    LList *cs;
+    cs=LList::Create();
     s=new_lisp_symbol(name);
     cs->car=s;
@@ -818 +818 @@
 */
 
-LispSymbol *LispSymbol::Find(char const *name)
-{
-    LispSymbol *p = lsym_root;
+LSymbol *LSymbol::Find(char const *name)
+{
+    LSymbol *p = lsym_root;
     while (p)
     {
@@ -831 +831 @@
 }
 
-LispSymbol *LispSymbol::FindOrCreate(char const *name)
-{
-    LispSymbol *p = lsym_root;
-    LispSymbol **parent = &lsym_root;
+LSymbol *LSymbol::FindOrCreate(char const *name)
+{
+    LSymbol *p = lsym_root;
+    LSymbol **parent = &lsym_root;
     while (p)
     {
@@ -849 +849 @@
        current_space = PERM_SPACE;
 
-    p = (LispSymbol *)malloc(sizeof(LispSymbol));
+    p = (LSymbol *)malloc(sizeof(LSymbol));
     p->type = L_SYMBOL;
-    p->name = LispString::Create(name);
+    p->name = LString::Create(name);
 
     // If constant, set the value to ourself
@@ -867 +867 @@
 }
 
-void ldelete_syms(LispSymbol *root)
+void ldelete_syms(LSymbol *root)
 {
   if (root)
@@ -887 +887 @@
       if (lisp_eq(CAR(CAR(list)), item))
         return lcar(list);
-      list=(LispList *)(CDR(list));
+      list=(LList *)(CDR(list));
     }
   }
@@ -893 +893 @@
 }
 
-size_t LispList::GetLength()
+size_t LList::GetLength()
 {
     size_t ret = 0;
@@ -906 +906 @@
 #endif
 
-    for (LispObject *p = this; p; p = CDR(p))
+    for (LObject *p = this; p; p = CDR(p))
         ret++;
     return ret;
@@ -917 +917 @@
 
   void *ret=NULL;
-  size_t l1 = ((LispList *)list1)->GetLength();
-  size_t l2 = ((LispList *)list2)->GetLength();
+  size_t l1 = ((LList *)list1)->GetLength();
+  size_t l2 = ((LList *)list2)->GetLength();
 
   if (l1!=l2)
@@ -929 +929 @@
   if (l1!=0)
   {
-    LispList *first = NULL, *last = NULL, *cur = NULL;
-    LispObject *tmp;
+    LList *first = NULL, *last = NULL, *cur = NULL;
+    LObject *tmp;
     PtrRef r1(first), r2(last), r3(cur);
     while (list1)
     {
-      cur = LispList::Create();
+      cur = LList::Create();
       if (!first)
         first = cur;
@@ -941 +941 @@
       last = cur;
 
-      LispList *cell = LispList::Create();
-      tmp = (LispObject *)lcar(list1);
+      LList *cell = LList::Create();
+      tmp = (LObject *)lcar(list1);
       cell->car = tmp;
-      tmp = (LispObject *)lcar(list2);
+      tmp = (LObject *)lcar(list2);
       cell->cdr = tmp;
       cur->car = cell;
 
-      list1 = ((LispList *)list1)->cdr;
-      list2 = ((LispList *)list2)->cdr;
-    }
-    cur->cdr = (LispObject *)list3;
+      list1 = ((LList *)list1)->cdr;
+      list2 = ((LList *)list2)->cdr;
+    }
+    cur->cdr = (LObject *)list3;
     ret=first;
   } else ret=NULL;
@@ -957 +957 @@
 }
 
-void LispSymbol::SetFunction(LispObject *fun)
+void LSymbol::SetFunction(LObject *fun)
 {
     function = fun;
 }
 
-LispSymbol *add_sys_function(char const *name, short min_args, short max_args, short number)
+LSymbol *add_sys_function(char const *name, short min_args, short max_args, short number)
 {
   need_perm_space("add_sys_function");
-  LispSymbol *s = LispSymbol::FindOrCreate(name);
+  LSymbol *s = LSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -975 +975 @@
 }
 
-LispSymbol *add_c_object(void *symbol, int16_t number)
+LSymbol *add_c_object(void *symbol, int16_t number)
 {
   need_perm_space("add_c_object");
-  LispSymbol *s=(LispSymbol *)symbol;
+  LSymbol *s=(LSymbol *)symbol;
   if (s->value!=l_undefined)
   {
@@ -988 +988 @@
 }
 
-LispSymbol *add_c_function(char const *name, short min_args, short max_args, short number)
+LSymbol *add_c_function(char const *name, short min_args, short max_args, short number)
 {
   total_user_functions++;
   need_perm_space("add_c_function");
-  LispSymbol *s = LispSymbol::FindOrCreate(name);
+  LSymbol *s = LSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1002 +1002 @@
 }
 
-LispSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number)
+LSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number)
 {
   total_user_functions++;
   need_perm_space("add_c_bool_fun");
-  LispSymbol *s = LispSymbol::FindOrCreate(name);
+  LSymbol *s = LSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1017 +1017 @@
 
 
-LispSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number)
+LSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number)
 {
   total_user_functions++;
   need_perm_space("add_c_bool_fun");
-  LispSymbol *s = LispSymbol::FindOrCreate(name);
+  LSymbol *s = LSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1106 +1106 @@
 {
   PtrRef r1(object), r2(list);
-  LispList *c = LispList::Create();
-  c->car = (LispObject *)object;
-  c->cdr = (LispObject *)list;
+  LList *c = LList::Create();
+  c->car = (LObject *)object;
+  c->cdr = (LObject *)list;
   list=c;
 }
@@ -1125 +1125 @@
   else if (n[0]=='\'')                    // short hand for quote function
   {
-    void *cs = LispList::Create(), *c2=NULL, *tmp;
+    void *cs = LList::Create(), *c2=NULL, *tmp;
     PtrRef r1(cs), r2(c2);
 
-    ((LispList *)cs)->car=quote_symbol;
-    c2 = LispList::Create();
+    ((LList *)cs)->car=quote_symbol;
+    c2 = LList::Create();
     tmp=compile(s);
-    ((LispList *)c2)->car = (LispObject *)tmp;
-    ((LispList *)c2)->cdr=NULL;
-    ((LispList *)cs)->cdr = (LispObject *)c2;
+    ((LList *)c2)->car = (LObject *)tmp;
+    ((LList *)c2)->cdr=NULL;
+    ((LList *)cs)->cdr = (LObject *)c2;
     ret=cs;
   }
   else if (n[0]=='`')                    // short hand for backquote function
   {
-    void *cs = LispList::Create(), *c2=NULL, *tmp;
+    void *cs = LList::Create(), *c2=NULL, *tmp;
     PtrRef r1(cs), r2(c2);
 
-    ((LispList *)cs)->car=backquote_symbol;
-    c2 = LispList::Create();
+    ((LList *)cs)->car=backquote_symbol;
+    c2 = LList::Create();
     tmp=compile(s);
-    ((LispList *)c2)->car = (LispObject *)tmp;
-    ((LispList *)c2)->cdr=NULL;
-    ((LispList *)cs)->cdr = (LispObject *)c2;
+    ((LList *)c2)->car = (LObject *)tmp;
+    ((LList *)c2)->cdr=NULL;
+    ((LList *)cs)->cdr = (LObject *)c2;
     ret=cs;
   }  else if (n[0]==',')              // short hand for comma function
   {
-    void *cs = LispList::Create(), *c2=NULL, *tmp;
+    void *cs = LList::Create(), *c2=NULL, *tmp;
     PtrRef r1(cs), r2(c2);
 
-    ((LispList *)cs)->car=comma_symbol;
-    c2 = LispList::Create();
+    ((LList *)cs)->car=comma_symbol;
+    c2 = LList::Create();
     tmp=compile(s);
-    ((LispList *)c2)->car = (LispObject *)tmp;
-    ((LispList *)c2)->cdr=NULL;
-    ((LispList *)cs)->cdr = (LispObject *)c2;
+    ((LList *)c2)->car = (LObject *)tmp;
+    ((LList *)c2)->cdr=NULL;
+    ((LList *)cs)->cdr = (LObject *)c2;
     ret=cs;
   }
@@ -1187 +1187 @@
                     read_ltoken(s, n);              // skip the '.'
                     tmp=compile(s);
-                    ((LispList *)last)->cdr = (LispObject *)tmp;          // link the last cdr to
+                    ((LList *)last)->cdr = (LObject *)tmp;          // link the last cdr to
                     last=NULL;
                   }
@@ -1195 +1195 @@
                 {        
                   void *tmp;
-                  cur = LispList::Create();
+                  cur = LList::Create();
                   PtrRef r1(cur);
                   if (!first) first=cur;
                   tmp=compile(s);    
-                  ((LispList *)cur)->car = (LispObject *)tmp;
+                  ((LList *)cur)->car = (LObject *)tmp;
                   if (last)
-                    ((LispList *)last)->cdr = (LispObject *)cur;
+                    ((LList *)last)->cdr = (LObject *)cur;
                   last=cur;
                 }
@@ -1212 +1212 @@
   else if (isdigit(n[0]) || (n[0]=='-' && isdigit(n[1])))
   {
-    LispNumber *num = LispNumber::Create(0);
+    LNumber *num = LNumber::Create(0);
     sscanf(n, "%ld", &num->num);
     ret=num;
   } else if (n[0]=='"')
   {
-    ret = LispString::Create(str_token_len(s));
+    ret = LString::Create(str_token_len(s));
     char *start=lstring_value(ret);
     for (;*s && (*s!='"' || s[1]=='"');s++, start++)
@@ -1247 +1247 @@
     else if (n[1]==0)                           // short hand for function
     {
-      void *cs = LispList::Create(), *c2=NULL, *tmp;
+      void *cs = LList::Create(), *c2=NULL, *tmp;
       PtrRef r4(cs), r5(c2);
-      tmp = LispSymbol::FindOrCreate("function");
-      ((LispList *)cs)->car = (LispObject *)tmp;
-      c2 = LispList::Create();
+      tmp = LSymbol::FindOrCreate("function");
+      ((LList *)cs)->car = (LObject *)tmp;
+      c2 = LList::Create();
       tmp=compile(s);
-      ((LispList *)c2)->car = (LispObject *)tmp;
-      ((LispList *)cs)->cdr = (LispObject *)c2;
+      ((LList *)c2)->car = (LObject *)tmp;
+      ((LList *)cs)->cdr = (LObject *)c2;
       ret=cs;
     }
@@ -1263 +1263 @@
     }
   } else {
-    ret = LispSymbol::FindOrCreate(n);
+    ret = LSymbol::FindOrCreate(n);
   }
   return ret;
@@ -1306 +1306 @@
       case L_CONS_CELL :
       {
-                LispList *cs=(LispList *)i;
+                LList *cs=(LList *)i;
         lprint_string("(");
-        for (;cs;cs=(LispList *)lcdr(cs))    
+        for (;cs;cs=(LList *)lcdr(cs))    
                 {
                   if (item_type(cs)==(ltype)L_CONS_CELL)
@@ -1329 +1329 @@
       {
                 char num[10];
-                sprintf(num, "%ld", ((LispNumber *)i)->num);
+                sprintf(num, "%ld", ((LNumber *)i)->num);
         lprint_string(num);
       }
       break;
       case L_SYMBOL :
-        lprint_string(((LispSymbol *)i)->name->GetString());
+        lprint_string(((LSymbol *)i)->name->GetString());
       break;
       case L_USER_FUNCTION :
@@ -1376 +1376 @@
                 if (current_print_file)
                 {
-                  uint8_t ch=((LispChar *)i)->ch;
+                  uint8_t ch=((LChar *)i)->ch;
                   current_print_file->write(&ch, 1);
                 } else
                 {
-                  uint16_t ch=((LispChar *)i)->ch;
+                  uint16_t ch=((LChar *)i)->ch;
                   dprintf("#\\");
                   switch (ch)
@@ -1395 +1395 @@
       case L_OBJECT_VAR :
       {
-                l_obj_print(((LispObjectVar *)i)->number);
+                l_obj_print(((LObjectVar *)i)->number);
       } break;
       case L_1D_ARRAY :
       {
-          LispArray *a = (LispArray *)i;
-          LispObject **data = a->GetData();
+          LArray *a = (LArray *)i;
+          LObject **data = a->GetData();
           dprintf("#(");
           for (int j = 0; j < a->size; j++)
@@ -1413 +1413 @@
       {
                 lprint_string("GC_refrence->");
-                lprint(((LispRedirect *)i)->new_reference);
+                lprint(((LRedirect *)i)->new_reference);
       } break;
       default :
@@ -1424 +1424 @@
 }
 
-void *eval_sys_function(LispSysFunction *fun, void *arg_list);
-
-void *eval_function(LispSymbol *sym, void *arg_list)
+void *eval_sys_function(LSysFunction *fun, void *arg_list);
+
+void *eval_function(LSymbol *sym, void *arg_list)
 {
 #ifdef TYPE_CHECKING
@@ -1438 +1438 @@
 #endif
 
-  void *fun=(LispSysFunction *)(((LispSymbol *)sym)->function);
+  void *fun=(LSysFunction *)(((LSymbol *)sym)->function);
   PtrRef ref2( fun  );
 
@@ -1452 +1452 @@
     case L_L_FUNCTION :
     {
-      req_min=((LispSysFunction *)fun)->min_args;
-      req_max=((LispSysFunction *)fun)->max_args;
+      req_min=((LSysFunction *)fun)->min_args;
+      req_max=((LSysFunction *)fun)->max_args;
     } break;
     case L_USER_FUNCTION :
@@ -1499 +1499 @@
   {
     case L_SYS_FUNCTION :
-    { ret=eval_sys_function( ((LispSysFunction *)fun), arg_list); } break;
+    { ret=eval_sys_function( ((LSysFunction *)fun), arg_list); } break;
     case L_L_FUNCTION :
-    { ret=l_caller( ((LispSysFunction *)fun)->fun_number, arg_list); } break;
+    { ret=l_caller( ((LSysFunction *)fun)->fun_number, arg_list); } break;
     case L_USER_FUNCTION :
     {
@@ -1514 +1514 @@
       {
         if (first) {
-          tmp = LispList::Create();
-          ((LispList *)cur)->cdr = (LispObject *)tmp;
+          tmp = LList::Create();
+          ((LList *)cur)->cdr = (LObject *)tmp;
           cur=tmp;
         } else
-          cur=first = LispList::Create();
+          cur=first = LList::Create();
     
         void *val=eval(CAR(arg_list));
-        ((LispList *)cur)->car = (LispObject *)val;
+        ((LList *)cur)->car = (LObject *)val;
         arg_list=lcdr(arg_list);
       }
       if(t == L_C_FUNCTION)
-        ret = LispNumber::Create(c_caller( ((LispSysFunction *)fun)->fun_number, first));
-      else if (c_caller( ((LispSysFunction *)fun)->fun_number, first))
+        ret = LNumber::Create(c_caller( ((LSysFunction *)fun)->fun_number, first));
+      else if (c_caller( ((LSysFunction *)fun)->fun_number, first))
         ret=true_symbol;
       else ret=NULL;
@@ -1536 +1536 @@
 #ifdef L_PROFILE
   time_marker end;
-  ((LispSymbol *)sym)->time_taken+=end.diff_time(&start);
+  ((LSymbol *)sym)->time_taken+=end.diff_time(&start);
 #endif
 
@@ -1543 +1543 @@
 
 #ifdef L_PROFILE
-void pro_print(bFILE *out, LispSymbol *p)
+void pro_print(bFILE *out, LSymbol *p)
 {
   if (p)
@@ -1582 +1582 @@
     }
   }
-  int i, stop = 0, num_args = ((LispList *)CDR(arg_list))->GetLength();
+  int i, stop = 0, num_args = ((LList *)CDR(arg_list))->GetLength();
   if (!num_args) return 0;
 
   void **arg_on=(void **)malloc(sizeof(void *)*num_args);
-  LispList *list_on=(LispList *)CDR(arg_list);
+  LList *list_on=(LList *)CDR(arg_list);
   long old_ptr_son=PtrRef::stack.son;
 
   for (i=0;i<num_args;i++)
   {
-    arg_on[i]=(LispList *)eval(CAR(list_on));
+    arg_on[i]=(LList *)eval(CAR(list_on));
     PtrRef::stack.push(&arg_on[i]);
 
-    list_on=(LispList *)CDR(list_on);
+    list_on=(LList *)CDR(list_on);
     if (!arg_on[i]) stop=1;
   }
@@ -1604 +1604 @@
   }
 
-  LispList *na_list=NULL, *return_list=NULL, *last_return=NULL;
+  LList *na_list=NULL, *return_list=NULL, *last_return=NULL;
 
   do
@@ -1610 +1610 @@
     na_list=NULL;          // create a cons list with all of the parameters for the function
 
-    LispList *first=NULL;                       // save the start of the list
+    LList *first=NULL;                       // save the start of the list
     for (i=0;!stop &&i<num_args;i++)
     {
       if (!na_list)
-        first=na_list = LispList::Create();
+        first=na_list = LList::Create();
       else
       {
-        na_list->cdr = (LispObject *)LispList::Create();
-                na_list=(LispList *)CDR(na_list);
+        na_list->cdr = (LObject *)LList::Create();
+                na_list=(LList *)CDR(na_list);
       }
 
@@ -1624 +1624 @@
       if (arg_on[i])
       {
-                na_list->car = (LispObject *)CAR(arg_on[i]);
-                arg_on[i]=(LispList *)CDR(arg_on[i]);
+                na_list->car = (LObject *)CAR(arg_on[i]);
+                arg_on[i]=(LList *)CDR(arg_on[i]);
       }
       else stop=1;
@@ -1631 +1631 @@
     if (!stop)
     {
-      LispList *c = LispList::Create();
-      c->car = (LispObject *)eval_function((LispSymbol *)sym, first);
+      LList *c = LList::Create();
+      c->car = (LObject *)eval_function((LSymbol *)sym, first);
       if (return_list)
         last_return->cdr=c;
@@ -1657 +1657 @@
   if (rtype==string_symbol)
   {
-    int elements = ((LispList *)el_list)->GetLength(); // see how many things we need to concat
-    if (!elements) ret = LispString::Create("");
+    int elements = ((LList *)el_list)->GetLength(); // see how many things we need to concat
+    if (!elements) ret = LString::Create("");
     else
     {
@@ -1674 +1674 @@
       case L_CONS_CELL :
       {
-        LispList *char_list=(LispList *)str_eval[i];
+        LList *char_list=(LList *)str_eval[i];
         while (char_list)
         {
@@ -1685 +1685 @@
         exit(0);
           }
-          char_list=(LispList *)CDR(char_list);
+          char_list=(LList *)CDR(char_list);
         }
       } break;
@@ -1697 +1697 @@
     }
       }
-      LispString *st = LispString::Create(len+1);
+      LString *st = LString::Create(len+1);
       char *s=lstring_value(st);
 
@@ -1707 +1707 @@
       case L_CONS_CELL :
       {
-        LispList *char_list=(LispList *)str_eval[i];
+        LList *char_list=(LList *)str_eval[i];
         while (char_list)
         {
           if (item_type(CAR(char_list))==L_CHARACTER)
-            *(s++)=((LispChar *)CAR(char_list))->ch;
-          char_list=(LispList *)CDR(char_list);
+            *(s++)=((LChar *)CAR(char_list))->ch;
+          char_list=(LList *)CDR(char_list);
         }
       } break;
@@ -1745 +1745 @@
   else if (args==NULL)
     return NULL;
-  else if ((LispSymbol *) (((LispList *)args)->car)==comma_symbol)
+  else if ((LSymbol *) (((LList *)args)->car)==comma_symbol)
     return eval(CAR(CDR(args)));
   else
@@ -1758 +1758 @@
     {
       tmp=eval(CAR(CDR(args)));
-      ((LispList *)last)->cdr = (LispObject *)tmp;
+      ((LList *)last)->cdr = (LObject *)tmp;
       args=NULL;
     }
     else
     {
-      cur = LispList::Create();
+      cur = LList::Create();
       if (first)
-        ((LispList *)last)->cdr = (LispObject *)cur;
+        ((LList *)last)->cdr = (LObject *)cur;
       else
             first=cur;
       last=cur;
           tmp=backquote_eval(CAR(args));
-          ((LispList *)cur)->car = (LispObject *)tmp;
+          ((LList *)cur)->car = (LObject *)tmp;
        args=CDR(args);
     }
@@ -1776 +1776 @@
       {
     tmp=backquote_eval(args);
-    ((LispList *)last)->cdr = (LispObject *)tmp;
+    ((LList *)last)->cdr = (LObject *)tmp;
     args=NULL;
       }
@@ -1787 +1787 @@
 
 
-void *eval_sys_function(LispSysFunction *fun, void *arg_list)
+void *eval_sys_function(LSysFunction *fun, void *arg_list)
 {
   PtrRef ref1(arg_list);
@@ -1812 +1812 @@
       switch (item_type(v))
       {
-        case L_STRING : ret = LispNumber::Create(strlen(lstring_value(v))); break;
-        case L_CONS_CELL : ret = LispNumber::Create(((LispList *)v)->GetLength()); break;
+        case L_STRING : ret = LNumber::Create(strlen(lstring_value(v))); break;
+        case L_CONS_CELL : ret = LNumber::Create(((LList *)v)->GetLength()); break;
         default :
         { lprint(v);
@@ -1826 +1826 @@
       while (arg_list)
       {
-    cur = LispList::Create();
+    cur = LList::Create();
     void *val=eval(CAR(arg_list));
-    ((LispList *) cur)->car = (LispObject *)val;
+    ((LList *) cur)->car = (LObject *)val;
     if (last)
-      ((LispList *)last)->cdr = (LispObject *)cur;
+      ((LList *)last)->cdr = (LObject *)cur;
     else first=cur;
     last=cur;
-    arg_list=(LispList *)CDR(arg_list);
+    arg_list=(LList *)CDR(arg_list);
       }    
       ret=first;
     } break;
     case SYS_FUNC_CONS:
-    { void *c = LispList::Create();
+    { void *c = LList::Create();
       PtrRef r1(c);
       void *val=eval(CAR(arg_list));
-      ((LispList *)c)->car = (LispObject *)val;
+      ((LList *)c)->car = (LObject *)val;
       val=eval(CAR(CDR(arg_list)));
-      ((LispList *)c)->cdr = (LispObject *)val;
+      ((LList *)c)->cdr = (LObject *)val;
       ret=c;
     } break;
@@ -1869 +1869 @@
     arg_list=CDR(arg_list);
       }
-      ret = LispNumber::Create(sum);
+      ret = LNumber::Create(sum);
     }
     break;
@@ -1896 +1896 @@
       if (arg_list) first=eval(CAR(arg_list));
     } while (arg_list);
-    ret = LispNumber::Create(sum);
+    ret = LNumber::Create(sum);
       }
     }
@@ -1914 +1914 @@
     } else if (first)
     {
-      sum=((LispNumber *)i)->num;
+      sum=((LNumber *)i)->num;
       first=0;
     }
-    else sum/=((LispNumber *)i)->num;
+    else sum/=((LNumber *)i)->num;
     arg_list=CDR(arg_list);
       }
-      ret = LispNumber::Create(sum);
+      ret = LNumber::Create(sum);
     }
     break;
@@ -1931 +1931 @@
     arg_list=CDR(arg_list);
       }
-      ret = LispNumber::Create(x);
+      ret = LNumber::Create(x);
     }
     break;
@@ -1957 +1957 @@
         case L_SYMBOL :
         {
-          switch (item_type (((LispSymbol *)i)->value))
+          switch (item_type (((LSymbol *)i)->value))
           {
             case L_NUMBER :
             {
-              if (x==L_NUMBER && ((LispSymbol *)i)->value!=l_undefined)
-                ((LispSymbol *)i)->SetNumber(lnumber_value(set_to));
+              if (x==L_NUMBER && ((LSymbol *)i)->value!=l_undefined)
+                ((LSymbol *)i)->SetNumber(lnumber_value(set_to));
               else
-                ((LispSymbol *)i)->SetValue((LispNumber *)set_to);
+                ((LSymbol *)i)->SetValue((LNumber *)set_to);
             } break;
             case L_OBJECT_VAR :
             {
-              l_obj_set(((LispObjectVar *)(((LispSymbol *)i)->value))->number, set_to);
+              l_obj_set(((LObjectVar *)(((LSymbol *)i)->value))->number, set_to);
             } break;
             default :
-              ((LispSymbol *)i)->SetValue((LispObject *)set_to);
+              ((LSymbol *)i)->SetValue((LObject *)set_to);
           }
-          ret=((LispSymbol *)i)->value;
+          ret=((LSymbol *)i)->value;
         } break;
         case L_CONS_CELL :   // this better be an 'aref'
         {
 #ifdef TYPE_CHECKING
-          void *car=((LispList *)i)->car;
+          void *car=((LList *)i)->car;
           if (car==car_symbol)
           {
@@ -1984 +1984 @@
             if (!car || item_type(car)!=L_CONS_CELL)
             { lprint(car); lbreak("setq car : evaled object is not a cons cell\n"); exit(0); }
-            ((LispList *)car)->car = (LispObject *)set_to;
+            ((LList *)car)->car = (LObject *)set_to;
           } else if (car==cdr_symbol)
           {
@@ -1990 +1990 @@
             if (!car || item_type(car)!=L_CONS_CELL)
             { lprint(car); lbreak("setq cdr : evaled object is not a cons cell\n"); exit(0); }
-            ((LispList *)car)->cdr = (LispObject *)set_to;
+            ((LList *)car)->cdr = (LObject *)set_to;
           } else if (car==aref_symbol)
           {
 #endif
-            LispArray *a = (LispArray *)eval(CAR(CDR(i)));
+            LArray *a = (LArray *)eval(CAR(CDR(i)));
             PtrRef r1(a);
 #ifdef TYPE_CHECKING
@@ -2012 +2012 @@
             }
 #endif
-            a->GetData()[num] = (LispObject *)set_to;
+            a->GetData()[num] = (LObject *)set_to;
 #ifdef TYPE_CHECKING
           } else
@@ -2038 +2038 @@
       void *item=eval(CAR(arg_list));
       PtrRef r1(item);
-      void *list=(LispList *)eval(CAR(CDR(arg_list)));
+      void *list=(LList *)eval(CAR(CDR(arg_list)));
       PtrRef r2(list);
-      ret=assoc(item, (LispList *)list);
+      ret=assoc(item, (LList *)list);
     } break;
     case SYS_FUNC_NOT:
@@ -2050 +2050 @@
       void *i1=eval(CAR(arg_list)), *i2=eval(CAR(CDR(arg_list)));
       PtrRef r1(i1);
-      LispList *cs = LispList::Create();
-      cs->car = (LispObject *)i1;
-      cs->cdr = (LispObject *)i2;
+      LList *cs = LList::Create();
+      cs->car = (LObject *)i1;
+      cs->cdr = (LObject *)i2;
       ret=cs;
     } break;
@@ -2085 +2085 @@
 #endif
 
-    l_user_stack.push(((LispSymbol *)var_name)->value);
+    l_user_stack.push(((LSymbol *)var_name)->value);
     tmp=eval(CAR(CDR(CAR(var_list))));    
-    ((LispSymbol *)var_name)->SetValue((LispObject *)tmp);
+    ((LSymbol *)var_name)->SetValue((LObject *)tmp);
     var_list=CDR(var_list);
       }
@@ -2104 +2104 @@
       {
     void *var_name=CAR(CAR(var_list));
-    ((LispSymbol *)var_name)->SetValue((LispObject *)l_user_stack.sdata[cur_stack++]);
+    ((LSymbol *)var_name)->SetValue((LObject *)l_user_stack.sdata[cur_stack++]);
     var_list=CDR(var_list);
       }
@@ -2112 +2112 @@
     case SYS_FUNC_DEFUN:
     {
-      LispSymbol *symbol = (LispSymbol *)CAR(arg_list);
+      LSymbol *symbol = (LSymbol *)CAR(arg_list);
 #ifdef TYPE_CHECKING
       if (item_type(symbol)!=L_SYMBOL)
@@ -2133 +2133 @@
       intptr_t a=cache.reg_lisp_block(lcar(lcdr(arg_list)));
       intptr_t b=cache.reg_lisp_block(block_list);
-      LispUserFunction *ufun=new_lisp_user_function(a, b);
+      LUserFunction *ufun=new_lisp_user_function(a, b);
 #else
-      LispUserFunction *ufun=new_lisp_user_function(lcar(lcdr(arg_list)), block_list);
+      LUserFunction *ufun=new_lisp_user_function(lcar(lcdr(arg_list)), block_list);
 #endif
       symbol->SetFunction(ufun);
@@ -2183 +2183 @@
       {
         case L_CHARACTER :
-        { ret = LispNumber::Create(((LispChar *)i)->ch); } break;
+        { ret = LNumber::Create(((LChar *)i)->ch); } break;
         case L_STRING :
-        {  ret = LispNumber::Create(*lstring_value(i)); } break;
+        {  ret = LNumber::Create(*lstring_value(i)); } break;
         default :
         {
@@ -2204 +2204 @@
     exit(0);
       }
-      ret=new_lisp_character(((LispNumber *)i)->num);
+      ret=new_lisp_character(((LNumber *)i)->num);
     } break;
     case SYS_FUNC_COND:
@@ -2242 +2242 @@
     } break;
     case SYS_FUNC_FUNCTION:
-      ret = ((LispSymbol *)eval(CAR(arg_list)))->GetFunction();
+      ret = ((LSymbol *)eval(CAR(arg_list)))->GetFunction();
     break;
     case SYS_FUNC_MAPCAR:
@@ -2249 +2249 @@
     {
       void *n1=eval(CAR(arg_list));
-      ret=eval_function((LispSymbol *)n1, CDR(arg_list));
+      ret=eval_function((LSymbol *)n1, CDR(arg_list));
     } break;
     case SYS_FUNC_GT:
@@ -2299 +2299 @@
       }
 #endif
-      ret=((LispSymbol *)symb)->name;
+      ret=((LSymbol *)symb)->name;
     break;
     case SYS_FUNC_TRACE:
@@ -2331 +2331 @@
       while (dig--)
         *(tp--)='0';
-      ret=LispString::Create(tp+1);
+      ret=LString::Create(tp+1);
     } break;
     case SYS_FUNC_LOCAL_LOAD:
@@ -2365 +2365 @@
             {
                 delete fp;
-                if( DEFINEDP(((LispSymbol *)load_warning)->GetValue())
-                     && ((LispSymbol *)load_warning)->GetValue())
+                if( DEFINEDP(((LSymbol *)load_warning)->GetValue())
+                     && ((LSymbol *)load_warning)->GetValue())
                     dprintf("Warning : file %s does not exist\n", st);
                 ret = NULL;
@@ -2412 +2412 @@
     } break;
     case SYS_FUNC_ABS:
-      ret = LispNumber::Create(abs(lnumber_value(eval(CAR(arg_list))))); break;
+      ret = LNumber::Create(abs(lnumber_value(eval(CAR(arg_list))))); break;
     case SYS_FUNC_MIN:
     {
       int x=lnumber_value(eval(CAR(arg_list))), y=lnumber_value(eval(CAR(CDR(arg_list))));
-      ret = LispNumber::Create(x < y ? x : y);
+      ret = LNumber::Create(x < y ? x : y);
     } break;
     case SYS_FUNC_MAX:
     {
       int x=lnumber_value(eval(CAR(arg_list))), y=lnumber_value(eval(CAR(CDR(arg_list))));
-      ret = LispNumber::Create(x > y ? x : y);
+      ret = LNumber::Create(x > y ? x : y);
     } break;
     case SYS_FUNC_BACKQUOTE:
@@ -2451 +2451 @@
       long y=(lnumber_value(eval(CAR(arg_list))));   arg_list=CDR(arg_list);
       long x=(lnumber_value(eval(CAR(arg_list))));
-      ret = LispNumber::Create(lisp_atan2(y, x));
+      ret = LNumber::Create(lisp_atan2(y, x));
     } break;
     case SYS_FUNC_ENUM:
@@ -2465 +2465 @@
     {
       case L_SYMBOL :
-      { ((LispSymbol *)sym)->value = LispNumber::Create(x); } break;
+      { ((LSymbol *)sym)->value = LNumber::Create(x); } break;
       case L_CONS_CELL :
       {
@@ -2478 +2478 @@
 #endif
         x=lnumber_value(eval(CAR(CDR(sym))));
-        ((LispSymbol *)sym)->value = LispNumber::Create(x);
+        ((LSymbol *)sym)->value = LNumber::Create(x);
       } break;
       default :
@@ -2506 +2506 @@
       long y=lnumber_value(eval(CAR(arg_list)));
       if (y==0) { lbreak("mod : division by zero\n"); y=1; }
-      ret = LispNumber::Create(x%y);
+      ret = LNumber::Create(x%y);
     } break;
 /*    case SYS_FUNC_WRITE_PROFILE:
@@ -2517 +2517 @@
       {    
     for (void *s=symbol_list;s;s=CDR(s))        
-      fprintf(fp, "%8d  %s\n", ((LispSymbol *)(CAR(s)))->call_counter,
-          lstring_value(((LispSymbol *)(CAR(s)))->name));
+      fprintf(fp, "%8d  %s\n", ((LSymbol *)(CAR(s)))->call_counter,
+          lstring_value(((LSymbol *)(CAR(s)))->name));
     fclose(fp);
       }
@@ -2524 +2524 @@
     case SYS_FUNC_FOR:
     {
-      LispSymbol *bind_var = (LispSymbol *)CAR(arg_list);
+      LSymbol *bind_var = (LSymbol *)CAR(arg_list);
       arg_list = CDR(arg_list);
       PtrRef r1(bind_var);
@@ -2546 +2546 @@
       while (ilist)
       {
-                bind_var->SetValue((LispObject *)CAR(ilist));
+                bind_var->SetValue((LObject *)CAR(ilist));
                 for (block=arg_list;block;block=CDR(block))
                   ret=eval(CAR(block));
                 ilist=CDR(ilist);
       }
-      bind_var->SetValue((LispObject *)l_user_stack.pop(1)); // restore symbol value
+      bind_var->SetValue((LObject *)l_user_stack.pop(1)); // restore symbol value
       ret=ret;
     } break;
@@ -2585 +2585 @@
                 arg_list=CDR(arg_list);
       }
-      ret = LispNumber::Create(first);
+      ret = LNumber::Create(first);
     } break;
     case SYS_FUNC_BIT_OR:
@@ -2595 +2595 @@
                 arg_list=CDR(arg_list);
       }
-      ret = LispNumber::Create(first);
+      ret = LNumber::Create(first);
     } break;
     case SYS_FUNC_BIT_XOR:
@@ -2605 +2605 @@
                 arg_list=CDR(arg_list);
       }
-      ret = LispNumber::Create(first);
+      ret = LNumber::Create(first);
     } break;
     case SYS_FUNC_MAKE_ARRAY:
@@ -2615 +2615 @@
                 exit(0);
       }
-      ret = LispArray::Create(l, CDR(arg_list));
+      ret = LArray::Create(l, CDR(arg_list));
     } break;
     case SYS_FUNC_AREF:
     {
       long x=lnumber_value(eval(CAR(CDR(arg_list))));
-      ret = ((LispArray *)eval(CAR(arg_list)))->Get(x);
+      ret = ((LArray *)eval(CAR(arg_list)))->Get(x);
     } break;
     case SYS_FUNC_IF_1PROGN:
@@ -2646 +2646 @@
     {
       void *v=eval(CAR(arg_list));
-      if (item_type(v)!=L_NUMBER || (((LispNumber *)v)->num!=0))
+      if (item_type(v)!=L_NUMBER || (((LNumber *)v)->num!=0))
         ret=NULL;
       else ret=true_symbol;
@@ -2666 +2666 @@
       char *find=strstr(haystack, needle);
       if (find)
-        ret = LispNumber::Create(find-haystack);
+        ret = LNumber::Create(find-haystack);
       else ret=NULL;
     } break;
@@ -2694 +2694 @@
       PtrRef r1(init_var);
       int i, ustack_start=l_user_stack.son;      // restore stack at end
-      LispSymbol *sym = NULL;
+      LSymbol *sym = NULL;
       PtrRef r2(sym);
 
@@ -2700 +2700 @@
       for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var))
       {
-                sym = (LispSymbol *)CAR(CAR(init_var));
+                sym = (LSymbol *)CAR(CAR(init_var));
                 if (item_type(sym)!=L_SYMBOL)
                 { lbreak("expecting symbol name for iteration var\n"); exit(0); }
@@ -2714 +2714 @@
       for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var), do_evaled++)
       {
-                sym = (LispSymbol *)CAR(CAR(init_var));
-                sym->SetValue((LispObject *)*do_evaled);
+                sym = (LSymbol *)CAR(CAR(init_var));
+                sym->SetValue((LObject *)*do_evaled);
       }
 
@@ -2736 +2736 @@
       for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var), do_evaled++)
       {
-                sym = (LispSymbol *)CAR(CAR(init_var));
-                sym->SetValue((LispObject *)*do_evaled);
+                sym = (LSymbol *)CAR(CAR(init_var));
+                sym->SetValue((LObject *)*do_evaled);
       }
 
@@ -2765 +2765 @@
       char str[20];
       sprintf(str, "%ld", (long int)lnumber_value(eval(CAR(arg_list))));
-      ret=LispString::Create(str);
+      ret=LString::Create(str);
     } break;
     case SYS_FUNC_NCONC:
@@ -2786 +2786 @@
                 next=l1;
                 while (next) { l1=next; next=lcdr(next); }
-                ((LispList *)l1)->cdr = (LispObject *)eval(CAR(arg_list));
+                ((LList *)l1)->cdr = (LObject *)eval(CAR(arg_list));
                 arg_list=CDR(arg_list);
       } while (arg_list);
@@ -2821 +2821 @@
         lbreak("substr : bad x1 or x2 value");
 
-      LispString *s=LispString::Create(x2-x1+2);
+      LString *s=LString::Create(x2-x1+2);
       if (x2-x1)
         memcpy(lstring_value(s), lstring_value(st)+x1, x2-x1+1);
@@ -2837 +2837 @@
         if (!rstart) rstart=q;
         while (r && CDR(r)) r=CDR(r);
-        CDR(r) = (LispObject *)q;
+        CDR(r) = (LObject *)q;
         arg_list=CDR(arg_list);
       }
@@ -2844 +2844 @@
 
     default :
-    { dprintf("Undefined system function number %d\n", ((LispSysFunction *)fun)->fun_number); }
+    { dprintf("Undefined system function number %d\n", ((LSysFunction *)fun)->fun_number); }
   }
   return ret;
@@ -2867 +2867 @@
 
 
-void *eval_user_fun(LispSymbol *sym, void *arg_list)
+void *eval_user_fun(LSymbol *sym, void *arg_list)
 {
   void *ret=NULL;
@@ -2885 +2885 @@
 
 
-  LispUserFunction *fun=(LispUserFunction *)(((LispSymbol *)sym)->function);
+  LUserFunction *fun=(LUserFunction *)(((LSymbol *)sym)->function);
 
 #ifdef TYPE_CHECKING
@@ -2916 +2916 @@
   for (;f_arg;f_arg=CDR(f_arg))
   {
-    LispSymbol *s = (LispSymbol *)CAR(f_arg);
+    LSymbol *s = (LSymbol *)CAR(f_arg);
     l_user_stack.push(s->value);
   }
@@ -2937 +2937 @@
     // now store all the values and put them into the symbols
     for (f_arg=fun_arg_list;f_arg;f_arg=CDR(f_arg))
-      ((LispSymbol *)CAR(f_arg))->SetValue((LispObject *)l_user_stack.sdata[i++]);
+      ((LSymbol *)CAR(f_arg))->SetValue((LObject *)l_user_stack.sdata[i++]);
 
     l_user_stack.son=new_start;
@@ -2957 +2957 @@
   long cur_stack=stack_start;
   for (f_arg=fun_arg_list;f_arg;f_arg=CDR(f_arg))
-    ((LispSymbol *)CAR(f_arg))->SetValue((LispObject *)l_user_stack.sdata[cur_stack++]);
+    ((LSymbol *)CAR(f_arg))->SetValue((LObject *)l_user_stack.sdata[cur_stack++]);
 
   l_user_stack.son=stack_start;
@@ -2963 +2963 @@
 #ifdef L_PROFILE
   time_marker end;
-  ((LispSymbol *)sym)->time_taken+=end.diff_time(&start);
+  ((LSymbol *)sym)->time_taken+=end.diff_time(&start);
 #endif
 
@@ -3015 +3015 @@
         else
                 {
-                  ret = ((LispSymbol *)prog)->GetValue();
+                  ret = ((LSymbol *)prog)->GetValue();
                   if (item_type(ret)==L_OBJECT_VAR)
-                    ret=l_obj_get(((LispObjectVar *)ret)->number);
+                    ret=l_obj_get(((LObjectVar *)ret)->number);
                 }
       } break;
       case L_CONS_CELL :
       {
-        ret=eval_function((LispSymbol *)CAR(prog), CDR(prog));
+        ret=eval_function((LSymbol *)CAR(prog), CDR(prog));
       }
       break;
@@ -3127 +3127 @@
 }
 
-LispString *LispSymbol::GetName()
+LString *LSymbol::GetName()
 {
 #ifdef TYPE_CHECKING
@@ -3140 +3140 @@
 }
 
-void LispSymbol::SetNumber(long num)
+void LSymbol::SetNumber(long num)
 {
 #ifdef TYPE_CHECKING
@@ -3151 +3151 @@
 #endif
     if (value != l_undefined && item_type(value) == L_NUMBER)
-        ((LispNumber *)value)->num = num;
+        ((LNumber *)value)->num = num;
     else
-        value = LispNumber::Create(num);
-}
-
-void LispSymbol::SetValue(LispObject *val)
+        value = LNumber::Create(num);
+}
+
+void LSymbol::SetValue(LObject *val)
 {
 #ifdef TYPE_CHECKING
@@ -3169 +3169 @@
 }
 
-LispObject *LispSymbol::GetFunction()
+LObject *LSymbol::GetFunction()
 {
 #ifdef TYPE_CHECKING
@@ -3182 +3182 @@
 }
 
-LispObject *LispSymbol::GetValue()
+LObject *LSymbol::GetValue()
 {
 #ifdef TYPE_CHECKING

abuse/trunk/src/lisp/lisp.h

@@ -45 +45 @@
                        // and sure that word, etc are word aligned
 
-struct LispObject
+struct LObject
 {
     ltype type;
 };
 
-struct LispObjectVar : LispObject
+struct LObjectVar : LObject
 {
     long number;
 };
 
-struct LispList : LispObject
-{
-    static LispList *Create();
+struct LList : LObject
+{
+    static LList *Create();
 
     size_t GetLength();
 
-    LispObject *cdr, *car;
-};
-
-struct LispNumber : LispObject
-{
-    static LispNumber *Create(long num);
+    LObject *cdr, *car;
+};
+
+struct LNumber : LObject
+{
+    static LNumber *Create(long num);
 
     long num;
 };
 
-struct LispRedirect : LispObject
-{
-    LispObject *new_reference;
-};
-
-struct LispString : LispObject
-{
-    static LispString *Create(char const *string);
-    static LispString *Create(char const *string, int length);
-    static LispString *Create(int length);
+struct LRedirect : LObject
+{
+    LObject *new_reference;
+};
+
+struct LString : LObject
+{
+    static LString *Create(char const *string);
+    static LString *Create(char const *string, int length);
+    static LString *Create(int length);
 
     char *GetString();
@@ -87 +87 @@
 };
 
-struct LispSymbol : LispObject
-{
-    static LispSymbol *Find(char const *name);
-    static LispSymbol *FindOrCreate(char const *name);
-
-    LispString *GetName();
-    LispObject *GetFunction();
-    LispObject *GetValue();
-
-    void SetFunction(LispObject *fun);
-    void SetValue(LispObject *value);
+struct LSymbol : LObject
+{
+    static LSymbol *Find(char const *name);
+    static LSymbol *FindOrCreate(char const *name);
+
+    LString *GetName();
+    LObject *GetFunction();
+    LObject *GetValue();
+
+    void SetFunction(LObject *fun);
+    void SetValue(LObject *value);
     void SetNumber(long num);
 
@@ -103 +103 @@
     float time_taken;
 #endif
-    LispObject *value;
-    LispObject *function;
-    LispString *name;
-    LispSymbol *left, *right; // tree structure
-};
-
-struct LispSysFunction : LispObject
+    LObject *value;
+    LObject *function;
+    LString *name;
+    LSymbol *left, *right; // tree structure
+};
+
+struct LSysFunction : LObject
 {
     short min_args, max_args;
@@ -115 +115 @@
 };
 
-struct LispUserFunction : LispObject
+struct LUserFunction : LObject
 {
 #ifndef NO_LIBS
@@ -124 +124 @@
 };
 
-struct LispArray : LispObject
-{
-    static LispArray *Create(int size, void *rest);
-
-    inline LispObject **GetData() { return data; }
-    LispObject *Get(long x);
+struct LArray : LObject
+{
+    static LArray *Create(int size, void *rest);
+
+    inline LObject **GetData() { return data; }
+    LObject *Get(long x);
 
     unsigned short size;
@@ -135 +135 @@
 
 private:
-    LispObject *data[1];
-};
-
-struct LispChar : LispObject
+    LObject *data[1];
+};
+
+struct LChar : LObject
 {
     int16_t pad;
@@ -144 +144 @@
 };
 
-struct LispPointer : LispObject
+struct LPointer : LObject
 {
     void *addr;
 };
 
-
-struct LispFixedPoint : LispObject
+struct LFixedPoint : LObject
 {
     int32_t x;
 };
 
-static inline LispObject *&CAR(void *x) { return ((LispList *)x)->car; }
-static inline LispObject *&CDR(void *x) { return ((LispList *)x)->cdr; }
+static inline LObject *&CAR(void *x) { return ((LList *)x)->car; }
+static inline LObject *&CDR(void *x) { return ((LList *)x)->cdr; }
 static inline ltype item_type(void *x) { if (x) return *(ltype *)x; return L_CONS_CELL; }
 
@@ -174 +173 @@
 void *eval(void *prog);
 void *eval_block(void *list);
-void *eval_function(LispSymbol *sym, void *arg_list);
-void *eval_user_fun(LispSymbol *sym, void *arg_list);
+void *eval_function(LSymbol *sym, void *arg_list);
+void *eval_user_fun(LSymbol *sym, void *arg_list);
 void *compile(char const *&s);
 void *assoc(void *item, void *list);
@@ -182 +181 @@
 
 void push_onto_list(void *object, void *&list);
-LispSymbol *add_c_object(void *symbol, int16_t number);
-LispSymbol *add_c_function(char const *name, short min_args, short max_args, short number);
-LispSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number);
-LispSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number);
+LSymbol *add_c_object(void *symbol, int16_t number);
+LSymbol *add_c_function(char const *name, short min_args, short max_args, short number);
+LSymbol *add_c_bool_fun(char const *name, short min_args, short max_args, short number);
+LSymbol *add_lisp_function(char const *name, short min_args, short max_args, short number);
 int read_ltoken(char *&s, char *buffer);
 void print_trace_stack(int max_levels);
 
 
-LispPointer *new_lisp_pointer(void *addr);
-LispChar *new_lisp_character(uint16_t ch);
-LispFixedPoint *new_lisp_fixed_point(int32_t x);
-LispObjectVar *new_lisp_object_var(int16_t number);
-LispSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number);
-LispSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number);
-LispSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number);
+LPointer *new_lisp_pointer(void *addr);
+LChar *new_lisp_character(uint16_t ch);
+LFixedPoint *new_lisp_fixed_point(int32_t x);
+LObjectVar *new_lisp_object_var(int16_t number);
+LSysFunction *new_lisp_sys_function(int min_args, int max_args, int fun_number);
+LSysFunction *new_lisp_c_function(int min_args, int max_args, int fun_number);
+LSysFunction *new_lisp_c_bool(int min_args, int max_args, int fun_number);
 
 #ifdef NO_LIBS
-LispUserFunction *new_lisp_user_function(void *arg_list, void *block_list);
+LUserFunction *new_lisp_user_function(void *arg_list, void *block_list);
 #else
-LispUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list);
-#endif
-
-LispSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number);
+LUserFunction *new_lisp_user_function(intptr_t arg_list, intptr_t block_list);
+#endif
+
+LSysFunction *new_user_lisp_function(int min_args, int max_args, int fun_number);
 
 int end_of_program(char *s);
@@ -210 +209 @@
 void lisp_init(long perm_size, long tmp_size);
 void lisp_uninit();
-extern LispSymbol *lsym_root;
+extern LSymbol *lsym_root;
 
 extern uint8_t *space[4], *free_space[4];
@@ -234 +233 @@
 
 // FIXME: get rid of this later
-static inline void *symbol_value(void *sym) { return ((LispSymbol *)sym)->GetValue(); }
-static inline char *lstring_value(void *str) { return ((LispString *)str)->GetString(); }
+static inline void *symbol_value(void *sym) { return ((LSymbol *)sym)->GetValue(); }
+static inline char *lstring_value(void *str) { return ((LString *)str)->GetString(); }
 
 #include "lisp_opt.h"

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -84 +84 @@
 }
 
-static LispObject *CollectObject(LispObject *x);
-
-static LispArray *CollectArray(LispArray *x)
+static LObject *CollectObject(LObject *x);
+
+static LArray *CollectArray(LArray *x)
 {
     size_t s = x->size;
-    LispArray *a = LispArray::Create(s, NULL);
-    LispObject **src = x->GetData();
-    LispObject **dst = a->GetData();
+    LArray *a = LArray::Create(s, NULL);
+    LObject **src = x->GetData();
+    LObject **dst = a->GetData();
     for (size_t i = 0; i < s; i++)
         dst[i] = CollectObject(src[i]);
@@ -98 +98 @@
 }
 
-inline LispList *CollectList(LispList *x)
-{
-    LispList *last = NULL, *first = NULL;
+inline LList *CollectList(LList *x)
+{
+    LList *last = NULL, *first = NULL;
 
     for (; x && item_type(x) == L_CONS_CELL; )
     {
-        LispList *p = LispList::Create();
-        LispObject *old_car = x->car;
-        LispObject *old_cdr = x->cdr;
-        LispObject *old_x = x;
-        x = (LispList *)CDR(x);
-        ((LispRedirect *)old_x)->type = L_COLLECTED_OBJECT;
-        ((LispRedirect *)old_x)->new_reference = p;
+        LList *p = LList::Create();
+        LObject *old_car = x->car;
+        LObject *old_cdr = x->cdr;
+        LObject *old_x = x;
+        x = (LList *)CDR(x);
+        ((LRedirect *)old_x)->type = L_COLLECTED_OBJECT;
+        ((LRedirect *)old_x)->new_reference = p;
 
         p->car = CollectObject(old_car);
@@ -126 +126 @@
 }
 
-static LispObject *CollectObject(LispObject *x)
-{
-  LispObject *ret = x;
+static LObject *CollectObject(LObject *x)
+{
+  LObject *ret = x;
 
   if (((uint8_t *)x) >= cstart && ((uint8_t *)x) < cend)
@@ -139 +139 @@
         break;
       case L_NUMBER:
-        ret = LispNumber::Create(((LispNumber *)x)->num);
+        ret = LNumber::Create(((LNumber *)x)->num);
         break;
       case L_SYS_FUNCTION:
-        ret = new_lisp_sys_function(((LispSysFunction *)x)->min_args,
-                                    ((LispSysFunction *)x)->max_args,
-                                    ((LispSysFunction *)x)->fun_number);
+        ret = new_lisp_sys_function(((LSysFunction *)x)->min_args,
+                                    ((LSysFunction *)x)->max_args,
+                                    ((LSysFunction *)x)->fun_number);
         break;
       case L_USER_FUNCTION:
 #ifndef NO_LIBS
-        ret = new_lisp_user_function(((LispUserFunction *)x)->alist,
-                                     ((LispUserFunction *)x)->blist);
+        ret = new_lisp_user_function(((LUserFunction *)x)->alist,
+                                     ((LUserFunction *)x)->blist);
 
 #else
         {
-          LispObject *arg = CollectObject(((LispUserFunction *)x)->arg_list);
-          LispObject *block = CollectObject(((LispUserFunction *)x)->block_list);
+          LObject *arg = CollectObject(((LUserFunction *)x)->arg_list);
+          LObject *block = CollectObject(((LUserFunction *)x)->block_list);
           ret = new_lisp_user_function(arg, block);
         }
@@ -160 +160 @@
         break;
       case L_STRING:
-        ret = LispString::Create(lstring_value(x));
+        ret = LString::Create(lstring_value(x));
         break;
       case L_CHARACTER:
@@ -166 +166 @@
         break;
       case L_C_FUNCTION:
-        ret = new_lisp_c_function(((LispSysFunction *)x)->min_args,
-                                  ((LispSysFunction *)x)->max_args,
-                                  ((LispSysFunction *)x)->fun_number);
+        ret = new_lisp_c_function(((LSysFunction *)x)->min_args,
+                                  ((LSysFunction *)x)->max_args,
+                                  ((LSysFunction *)x)->fun_number);
         break;
       case L_C_BOOL:
-        ret = new_lisp_c_bool(((LispSysFunction *)x)->min_args,
-                              ((LispSysFunction *)x)->max_args,
-                              ((LispSysFunction *)x)->fun_number);
+        ret = new_lisp_c_bool(((LSysFunction *)x)->min_args,
+                              ((LSysFunction *)x)->max_args,
+                              ((LSysFunction *)x)->fun_number);
         break;
       case L_L_FUNCTION:
-        ret = new_user_lisp_function(((LispSysFunction *)x)->min_args,
-                                     ((LispSysFunction *)x)->max_args,
-                                     ((LispSysFunction *)x)->fun_number);
+        ret = new_user_lisp_function(((LSysFunction *)x)->min_args,
+                                     ((LSysFunction *)x)->max_args,
+                                     ((LSysFunction *)x)->fun_number);
         break;
       case L_POINTER:
@@ -184 +184 @@
         break;
       case L_1D_ARRAY:
-        ret = CollectArray((LispArray *)x);
+        ret = CollectArray((LArray *)x);
         break;
       case L_FIXED_POINT:
@@ -190 +190 @@
         break;
       case L_CONS_CELL:
-        ret = CollectList((LispList *)x);
+        ret = CollectList((LList *)x);
         break;
       case L_OBJECT_VAR:
-        ret = new_lisp_object_var(((LispObjectVar *)x)->number);
+        ret = new_lisp_object_var(((LObjectVar *)x)->number);
         break;
       case L_COLLECTED_OBJECT:
-        ret = ((LispRedirect *)x)->new_reference;
+        ret = ((LRedirect *)x)->new_reference;
         break;
       default:
@@ -205 +205 @@
         break;
     }
-    ((LispRedirect *)x)->type = L_COLLECTED_OBJECT;
-    ((LispRedirect *)x)->new_reference = ret;
+    ((LRedirect *)x)->type = L_COLLECTED_OBJECT;
+    ((LRedirect *)x)->new_reference = ret;
   }
   else if ((uint8_t *)x < collected_start || (uint8_t *)x >= collected_end)
@@ -213 +213 @@
     {
       for (; x && item_type(x) == L_CONS_CELL; x = CDR(x))
-        ((LispList *)x)->car = CollectObject(((LispList *)x)->car);
+        ((LList *)x)->car = CollectObject(((LList *)x)->car);
       if (x)
-        ((LispList *)x)->cdr = CollectObject(((LispList *)x)->cdr);
+        ((LList *)x)->cdr = CollectObject(((LList *)x)->cdr);
     }
   }
@@ -222 +222 @@
 }
 
-static void collect_symbols(LispSymbol *root)
+static void collect_symbols(LSymbol *root)
 {
   if (root)
@@ -228 +228 @@
     root->value = CollectObject(root->value);
     root->function = CollectObject(root->function);
-    root->name = (LispString *)CollectObject(root->name);
+    root->name = (LString *)CollectObject(root->name);
     collect_symbols(root->left);
     collect_symbols(root->right);
@@ -240 +240 @@
   void **d = l_user_stack.sdata;
   for (int i = 0; i < t; i++, d++)
-    *d = CollectObject((LispObject *)*d);
+    *d = CollectObject((LObject *)*d);
 
   t = PtrRef::stack.son;
@@ -247 +247 @@
   {
     void **ptr = *d2;
-    *ptr = CollectObject((LispObject *)*ptr);
+    *ptr = CollectObject((LObject *)*ptr);
   }
 
@@ -254 +254 @@
   {
     void **ptr = *d2;
-    *ptr = CollectObject((LispObject *)*ptr);
+    *ptr = CollectObject((LObject *)*ptr);
   }
 }

abuse/trunk/src/lisp/lisp_opt.cpp

@@ -19 +19 @@
 #include "lisp_gc.h"
 
-LispObject *l_undefined;
-LispSymbol *true_symbol = NULL, *list_symbol, *string_symbol, *quote_symbol,
+LObject *l_undefined;
+LSymbol *true_symbol = NULL, *list_symbol, *string_symbol, *quote_symbol,
      *backquote_symbol, *comma_symbol, *do_symbol, *in_symbol, *aref_symbol,
      *if_symbol, *progn_symbol, *car_symbol, *cdr_symbol;
@@ -95 +95 @@
 {
     // This needs to be defined first
-    l_undefined = LispSymbol::FindOrCreate(":UNDEFINED");
+    l_undefined = LSymbol::FindOrCreate(":UNDEFINED");
 
     // Collection problems result if we don't do this
-    ((LispSymbol *)l_undefined)->function = NULL;
-    ((LispSymbol *)l_undefined)->value = NULL;
+    ((LSymbol *)l_undefined)->function = NULL;
+    ((LSymbol *)l_undefined)->value = NULL;
 
-    true_symbol = LispSymbol::FindOrCreate("T");
+    true_symbol = LSymbol::FindOrCreate("T");
 
-    list_symbol = LispSymbol::FindOrCreate("list");
-    string_symbol = LispSymbol::FindOrCreate("string");
-    quote_symbol = LispSymbol::FindOrCreate("quote");
-    backquote_symbol = LispSymbol::FindOrCreate("backquote");
-    comma_symbol = LispSymbol::FindOrCreate("comma");
-    in_symbol = LispSymbol::FindOrCreate("in");
-    do_symbol = LispSymbol::FindOrCreate("do");
-    aref_symbol = LispSymbol::FindOrCreate("aref");
-    colon_initial_contents = LispSymbol::FindOrCreate(":initial-contents");
-    colon_initial_element = LispSymbol::FindOrCreate(":initial-element");
+    list_symbol = LSymbol::FindOrCreate("list");
+    string_symbol = LSymbol::FindOrCreate("string");
+    quote_symbol = LSymbol::FindOrCreate("quote");
+    backquote_symbol = LSymbol::FindOrCreate("backquote");
+    comma_symbol = LSymbol::FindOrCreate("comma");
+    in_symbol = LSymbol::FindOrCreate("in");
+    do_symbol = LSymbol::FindOrCreate("do");
+    aref_symbol = LSymbol::FindOrCreate("aref");
+    colon_initial_contents = LSymbol::FindOrCreate(":initial-contents");
+    colon_initial_element = LSymbol::FindOrCreate(":initial-element");
 
-    if_1progn = LispSymbol::FindOrCreate("if-1progn");
-    if_2progn = LispSymbol::FindOrCreate("if-2progn");
-    if_12progn = LispSymbol::FindOrCreate("if-12progn");
-    if_symbol = LispSymbol::FindOrCreate("if");
-    progn_symbol = LispSymbol::FindOrCreate("progn");
-    not_symbol = LispSymbol::FindOrCreate("not");
-    eq_symbol = LispSymbol::FindOrCreate("eq");
-    zero_symbol = LispSymbol::FindOrCreate("0");
-    eq0_symbol = LispSymbol::FindOrCreate("eq0");
-    car_symbol = LispSymbol::FindOrCreate("car");
-    cdr_symbol = LispSymbol::FindOrCreate("cdr");
-    load_warning = LispSymbol::FindOrCreate("load_warning");
+    if_1progn = LSymbol::FindOrCreate("if-1progn");
+    if_2progn = LSymbol::FindOrCreate("if-2progn");
+    if_12progn = LSymbol::FindOrCreate("if-12progn");
+    if_symbol = LSymbol::FindOrCreate("if");
+    progn_symbol = LSymbol::FindOrCreate("progn");
+    not_symbol = LSymbol::FindOrCreate("not");
+    eq_symbol = LSymbol::FindOrCreate("eq");
+    zero_symbol = LSymbol::FindOrCreate("0");
+    eq0_symbol = LSymbol::FindOrCreate("eq0");
+    car_symbol = LSymbol::FindOrCreate("car");
+    cdr_symbol = LSymbol::FindOrCreate("cdr");
+    load_warning = LSymbol::FindOrCreate("load_warning");
 }
 

abuse/trunk/src/lisp/lisp_opt.h

@@ -13 +13 @@
 #include "lisp.h"
 
-extern LispObject *l_undefined;
-extern LispSymbol *true_symbol, *list_symbol, *string_symbol, *quote_symbol,
+extern LObject *l_undefined;
+extern LSymbol *true_symbol, *list_symbol, *string_symbol, *quote_symbol,
      *backquote_symbol, *comma_symbol, *do_symbol, *in_symbol, *aref_symbol,
      *if_symbol, *progn_symbol, *car_symbol, *cdr_symbol;

abuse/trunk/src/loader2.cpp

@@ -368 +368 @@
   char const *ff;
   // FIXME: unnecessary duplicate call
-  if (DEFINEDP(LispSymbol::FindOrCreate("frame_file")->GetValue()))
-    ff = lstring_value(LispSymbol::FindOrCreate("frame_file")->GetValue());
+  if (DEFINEDP(LSymbol::FindOrCreate("frame_file")->GetValue()))
+    ff = lstring_value(LSymbol::FindOrCreate("frame_file")->GetValue());
   else
     ff = "art/frame.spe";

abuse/trunk/src/menu.cpp

@@ -134 +134 @@
   args=CAR(CDR(args));
 
-  int options = ((LispList *)args)->GetLength();
+  int options = ((LList *)args)->GetLength();
   int mh=(font->height()+1)*options+10,maxw=0;
 
@@ -377 +377 @@
 void show_sell(int abortable)
 {
-  LispSymbol *ss = LispSymbol::FindOrCreate("sell_screens");
+  LSymbol *ss = LSymbol::FindOrCreate("sell_screens");
   if (!DEFINEDP(ss->GetValue()))
   {
@@ -385 +385 @@
 //    char *prog="((\"art/endgame.spe\" . \"credit\") (\"art/help.spe\" . \"sell6\"))";
     char const *prog="((\"art/endgame.spe\" . \"credit\"))";
-    ss->SetValue((LispObject *)compile(prog));
+    ss->SetValue((LObject *)compile(prog));
     current_space=sp;
   }
@@ -394 +394 @@
     wm->set_mouse_shape(blank.copy(),0,0);      // don't show mouse
 
-    LispObject *tmp = (LispObject *)ss->GetValue();
+    LObject *tmp = (LObject *)ss->GetValue();
     int quit=0;
     while (tmp && !quit)
@@ -409 +409 @@
         quit=1;
       fade_out(16);
-      tmp = (LispObject *)CDR(tmp);
+      tmp = (LObject *)CDR(tmp);
     }
     wm->set_mouse_shape(cache.img(c_normal)->copy(),1,1);
@@ -696 +696 @@
                 if (!current_demo)
                 {
-                    LispSymbol *d = LispSymbol::FindOrCreate("demos");
+                    LSymbol *d = LSymbol::FindOrCreate("demos");
                     if (DEFINEDP(d->GetValue()))
                         current_demo = d->GetValue();

abuse/trunk/src/objects.cpp

@@ -105 +105 @@
   for (i=0;i<figures[otype]->tiv;i++)
   {
-    if (!strcmp(lstring_value(((LispSymbol *)figures[otype]->vars[i])->GetName()),name))
+    if (!strcmp(lstring_value(((LSymbol *)figures[otype]->vars[i])->GetName()),name))
     {
       return lvars[figures[otype]->var_index[i]];
-/*      LispObjectVar *cobj=(LispObjectVar *)symbol_value(figures[otype]->vars[i]);
+/*      LObjectVar *cobj=(LObjectVar *)symbol_value(figures[otype]->vars[i]);
       character_type *t=figures[otype];
       int number=cobj->number;
@@ -135 +135 @@
   }
   for (i=0;i<figures[otype]->tiv;i++)
-    if (!strcmp(lstring_value(((LispSymbol *)figures[otype]->vars[i])->GetName()),name))
+    if (!strcmp(lstring_value(((LSymbol *)figures[otype]->vars[i])->GetName()),name))
     {
       lvars[figures[otype]->var_index[i]]=value;
@@ -265 +265 @@
 
     void *m=mark_heap(TMP_SPACE);
-    eval_function((LispSymbol *)ns,NULL);
+    eval_function((LSymbol *)ns,NULL);
     restore_heap(m,TMP_SPACE);
 
@@ -279 +279 @@
         current_object = this;
         void *m = mark_heap( TMP_SPACE );
-        (void)eval_function( (LispSymbol *)ns, NULL );
+        (void)eval_function( (LSymbol *)ns, NULL );
         restore_heap( m, TMP_SPACE );
     }
@@ -419 +419 @@
       prof1=new time_marker;
 
-    Cell *ret=(Cell *)eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_AI),NULL);
+    Cell *ret=(Cell *)eval_function((LSymbol *)figures[otype]->get_fun(OFUN_AI),NULL);
     if (profiling())
     {
@@ -483 +483 @@
   if (d)
   {
-    LispList *am, *frm, *hx, *hy, *px, *py;
+    LList *am, *frm, *hx, *hy, *px, *py;
     game_object *o = current_object;
     current_object = this;
@@ -489 +489 @@
     void *m = mark_heap(TMP_SPACE);
 
-    am = LispList::Create();
+    am = LList::Create();
     PtrRef r1(am);
-    am->car = LispNumber::Create(amount);
-
-    frm = LispList::Create();
+    am->car = LNumber::Create(amount);
+
+    frm = LList::Create();
     PtrRef r2(frm);
     frm->car = new_lisp_pointer(from);
 
-    hx = LispList::Create();
+    hx = LList::Create();
     PtrRef r3(hx);
-    hx->car = LispNumber::Create(hitx);
-
-    hy = LispList::Create();
+    hx->car = LNumber::Create(hitx);
+
+    hy = LList::Create();
     PtrRef r4(hy);
-    hy->car = LispNumber::Create(hity);
-
-    px = LispList::Create();
+    hy->car = LNumber::Create(hity);
+
+    px = LList::Create();
     PtrRef r5(px);
-    px->car = LispNumber::Create(push_xvel);
-
-    py = LispList::Create();
+    px->car = LNumber::Create(push_xvel);
+
+    py = LList::Create();
     PtrRef r6(py);
-    py->car = LispNumber::Create(push_yvel);
+    py->car = LNumber::Create(push_yvel);
 
     px->cdr = py;
@@ -523 +523 @@
       prof1 = new time_marker;
 
-    eval_user_fun((LispSymbol *)d, am);
+    eval_user_fun((LSymbol *)d, am);
     if (profiling())
     {
@@ -635 +635 @@
       prof1=new time_marker;
 
-    eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_DRAW),NULL);
+    eval_function((LSymbol *)figures[otype]->get_fun(OFUN_DRAW),NULL);
     if (profiling())
     {
@@ -662 +662 @@
       prof1=new time_marker;
 
-    eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_MAP_DRAW),NULL);
+    eval_function((LSymbol *)figures[otype]->get_fun(OFUN_MAP_DRAW),NULL);
     if (profiling())
     {
@@ -903 +903 @@
       } else
       {
-    push_onto_list(LispNumber::Create(ly),rlist);
-    push_onto_list(LispNumber::Create(lx),rlist);
+    push_onto_list(LNumber::Create(ly),rlist);
+    push_onto_list(LNumber::Create(lx),rlist);
     push_onto_list(l_tile,rlist);
       }
-      push_onto_list(LispNumber::Create(ret),rlist);
+      push_onto_list(LNumber::Create(ret),rlist);
 
       return rlist;
@@ -1169 +1169 @@
       prof1=new time_marker;
 
-    eval_function((LispSymbol *)figures[type]->get_fun(OFUN_CONSTRUCTOR),NULL);
+    eval_function((LSymbol *)figures[type]->get_fun(OFUN_CONSTRUCTOR),NULL);
     if (profiling())
     {
@@ -1207 +1207 @@
   if (figures[otype]->get_fun(OFUN_MOVER))      // is a lisp move function defined?
   {
-    LispList *lcx, *lcy, *lb;
+    LList *lcx, *lcy, *lb;
 
     game_object *o=current_object;
@@ -1213 +1213 @@
 
     // make a list of the parameters, and call the lisp function
-    lcx = LispList::Create();
+    lcx = LList::Create();
     PtrRef r1(lcx);
-    lcx->car = LispNumber::Create(cx);
-
-    lcy = LispList::Create();
+    lcx->car = LNumber::Create(cx);
+
+    lcy = LList::Create();
     PtrRef r2(lcy);
-    lcy->car = LispNumber::Create(cy);
-
-    lb = LispList::Create();
+    lcy->car = LNumber::Create(cy);
+
+    lb = LList::Create();
     PtrRef r3(lb);
-    lb->car = LispNumber::Create(button);
+    lb->car = LNumber::Create(button);
 
     lcx->cdr = lcy;
@@ -1234 +1234 @@
       prof1=new time_marker;
 
-    void *r=eval_function((LispSymbol *)figures[otype]->get_fun(OFUN_MOVER),
+    void *r=eval_function((LSymbol *)figures[otype]->get_fun(OFUN_MOVER),
               (void *)lcx);
     if (profiling())
@@ -1594 +1594 @@
         prof1=new time_marker;
 
-      eval_user_fun((LispSymbol *)f,NULL);
+      eval_user_fun((LSymbol *)f,NULL);
 
       if (profiling())
@@ -1637 +1637 @@
       prof1=new time_marker;
 
-    eval_function((LispSymbol *)figures[new_type]->get_fun(OFUN_CONSTRUCTOR),NULL);
+    eval_function((LSymbol *)figures[new_type]->get_fun(OFUN_CONSTRUCTOR),NULL);
     if (profiling())
     {

abuse/trunk/src/particle.cpp

@@ -61 +61 @@
 int defun_pseq(void *args)
 {
-  LispSymbol *sym=(LispSymbol *)lcar(args);
+  LSymbol *sym=(LSymbol *)lcar(args);
   if (item_type(sym)!=L_SYMBOL)
   {

abuse/trunk/src/seq.cpp

@@ -40 +40 @@
     total=1;
   else
-    total = ((LispList *)pict_list)->GetLength();
+    total = ((LList *)pict_list)->GetLength();
 
   seq=(int *) malloc(sizeof(int)*total);

abuse/trunk/src/statbar.cpp

@@ -41 +41 @@
   char sbname[100];
   char iname[20];
-  void *l_name = LispSymbol::FindOrCreate("sbar_file");
+  void *l_name = LSymbol::FindOrCreate("sbar_file");
   if (symbol_value(l_name)!=l_undefined)
     strcpy(sbname,lstring_value(symbol_value(l_name)));

abuse/trunk/src/view.cpp

@@ -334 +334 @@
 /*    if( DEFINEDP( symbol_function( l_get_local_input ) ) )
     {
-        void *ret = eval_function((LispSymbol *)l_get_local_input, NULL );
+        void *ret = eval_function((LSymbol *)l_get_local_input, NULL );
         sug_x = lnumber_value( CAR( ret ) );
         ret = CDR( ret );
@@ -460 +460 @@
       void *m=mark_heap(TMP_SPACE);
       void *list=NULL;
-      push_onto_list(LispString::Create(chat_buf),list);
-      eval_function((LispSymbol *)l_chat_input,list);
+      push_onto_list(LString::Create(chat_buf),list);
+      eval_function((LSymbol *)l_chat_input,list);
       restore_heap(m,TMP_SPACE);
 
@@ -883 +883 @@
       game_object *o=current_object;
       current_object=focus;
-      eval_user_fun((LispSymbol *)figures[focus->otype]->get_fun(OFUN_CONSTRUCTOR),NULL);
+      eval_user_fun((LSymbol *)figures[focus->otype]->get_fun(OFUN_CONSTRUCTOR),NULL);
       current_object=o;
     }