Changeset 484 for abuseTweet

Timestamp:

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

Author:

Sam Hocevar

Message:

lisp: populate LispSymbol? with symbol-related methods.

Location:

abuse/trunk/src

Files:

• chars.cpp (modified) (10 diffs)
• clisp.cpp (modified) (7 diffs)
• clisp.h (modified) (3 diffs)
• compiled.cpp (modified) (3 diffs)
• configuration.cpp (modified) (1 diff)
• cop.cpp (modified) (3 diffs)
• demo.cpp (modified) (2 diffs)
• demo.h (modified) (1 diff)
• dev.cpp (modified) (2 diffs)
• director.cpp (modified) (1 diff)
• endgame.cpp (modified) (4 diffs)
• game.cpp (modified) (5 diffs)
• gamma.cpp (modified) (4 diffs)
• level.cpp (modified) (8 diffs)
• lisp/lisp.cpp (modified) (23 diffs)
• lisp/lisp.h (modified) (5 diffs)
• lisp/lisp_gc.cpp (modified) (1 diff)
• lisp/lisp_gc.h (modified) (1 diff)
• lisp/lisp_opt.cpp (modified) (1 diff)
• loader2.cpp (modified) (2 diffs)
• menu.cpp (modified) (5 diffs)
• objects.cpp (modified) (2 diffs)
• particle.cpp (modified) (1 diff)
• statbar.cpp (modified) (1 diff)
• view.cpp (modified) (1 diff)

abuse/trunk/src/chars.cpp

@@ -81 +81 @@
 };
 
-int character_type::add_state(void *symbol)             // returns index into seq to use
+int character_type::add_state(void *symbol) // returns index into seq to use
 {
   if (item_type(symbol)!=L_SYMBOL)
@@ -110 +110 @@
     int sp=current_space;
     current_space=PERM_SPACE;
-    set_symbol_number(symbol,num);
+    ((LispSymbol *)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(symbol_name(seq_syms[num])));
+       lstring_value(((LispSymbol *)seq_syms[num])->GetName()));
     exit(0);
   } else if (num>=ts)
@@ -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(symbol_name(name)),
-           lstring_value(symbol_name(symbol)),
+           lstring_value(((LispSymbol *)name)->GetName()),
+           lstring_value(((LispSymbol *)symbol)->GetName()),
            index,
-           lstring_value(symbol_name(name)),
-           lstring_value(symbol_name(vars[index])),
-           lstring_value(symbol_name(name))
+           lstring_value(((LispSymbol *)name)->GetName()),
+           lstring_value(((LispSymbol *)vars[index])->GetName()),
+           lstring_value(((LispSymbol *)name)->GetName())
            );
     exit(0);
@@ -285 +285 @@
   }
   for (i=0;i<tiv;i++)
-    if (!strcmp(lstring_value(symbol_name(vars[i])),name))
+    if (!strcmp(lstring_value(((LispSymbol *)vars[i])->GetName()),name))
       return 1;
   return 0;
@@ -301 +301 @@
   tiv=0;
 
-  void *l_abil=  make_find_symbol("abilities");
-  void *l_funs=  make_find_symbol("funs");
-  void *l_states=make_find_symbol("states");
-  void *l_flags= make_find_symbol("flags");
-  void *l_range= make_find_symbol("range");
-  void *l_draw_range= make_find_symbol("draw_range");
-  void *l_fields=make_find_symbol("fields");
-  void *l_logo=  make_find_symbol("logo");
-  void *l_vars=  make_find_symbol("vars");
+  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");
 
   memset(fun_table,0,sizeof(fun_table));     // destory all hopes of fun
@@ -336 +336 @@
       for (i=0;i<TOTAL_ABILITIES;i++)
       {
-    Cell *ab=assoc(make_find_symbol(ability_names[i]),l);
+    Cell *ab=assoc(LispSymbol::FindOrCreate(ability_names[i]),l);
     p_ref r5(ab);
     if (!NILP(ab))
@@ -347 +347 @@
       for (i=0;i<TOTAL_OFUNS;i++)
       {
-    Cell *ab=assoc(make_find_symbol(ofun_names[i]),l);
+    Cell *ab=assoc(LispSymbol::FindOrCreate(ofun_names[i]),l);
     p_ref r5(ab);
     if (!NILP(ab) && lcar(lcdr(ab)))
@@ -358 +358 @@
       for (i=0;i<TOTAL_CFLAGS;i++)
       {
-    Cell *ab=assoc(make_find_symbol(cflag_names[i]),l);
+    Cell *ab=assoc(LispSymbol::FindOrCreate(cflag_names[i]),l);
     p_ref 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(symbol_name(name)));
+       lstring_value(((LispSymbol *)name)->GetName()));
 
 /*  char *fn=lstring_value(lcar(desc));

abuse/trunk/src/clisp.cpp

@@ -39 +39 @@
 
 // the following are references to lisp symbols
-void *l_difficulty,*l_easy,*l_hard,*l_medium,*l_main_menu,*l_extreme,
-     *l_logo,*l_state_art,*l_abilities,*l_state_sfx,
-     *l_song_list,*l_filename,*l_sfx_directory,*l_max_hp,*l_default_font,
-     *l_morph,*l_max_power,*l_default_abilities,*l_default_ai_function,
-     *l_tile_files,*l_empty_cache,*l_range,*l_hurt_all,*l_death_handler,
+LispSymbol *l_chat_input, *l_post_render;
+
+LispSymbol *l_difficulty, *l_easy, *l_hard, *l_medium, *l_extreme,
+    *l_max_hp, *l_max_power,
+    *l_empty_cache;
+
+// FIXME: port these to LispSymbol
+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,
+     *l_morph,*l_default_abilities,*l_default_ai_function,
+     *l_tile_files,*l_range,*l_hurt_all,*l_death_handler,
      *l_title_screen,*l_console_font,*l_fields,*l_dist,*l_pushx,*l_pushy,
      *l_object,*l_tile,*l_fire_object,*l_FIRE,*l_cop_dead_parts,*l_restart_player,
@@ -55 +61 @@
      *l_ask_save_slot,
      *l_get_local_input,
-     *l_post_render,
-     *l_chat_input,
      *l_player_text_color,
      *l_level_loaded;        // called when a new level is loaded
@@ -99 +103 @@
                                              // to irnterface with c
 {
-  l_easy=make_find_symbol("easy");
-  l_medium=make_find_symbol("medium");
-  l_hard=make_find_symbol("hard");
-  l_extreme=make_find_symbol("extreme");
-
-  l_logo=make_find_symbol("logo");
-  l_morph=make_find_symbol("morph");
-
-  l_pushx=make_find_symbol("pushx");
-  l_pushy=make_find_symbol("pushy");
-
-  l_dist=make_find_symbol("dist");
-  l_state_art=make_find_symbol("state_art");
-  l_abilities=make_find_symbol("abilities");
-  l_default_abilities=make_find_symbol("default_abilities");
-  l_state_sfx=make_find_symbol("state_sfx");
-  l_filename=make_find_symbol("filename");
-  l_sfx_directory=make_find_symbol("sfx_directory");
-  l_default_font=make_find_symbol("default_font");
-  l_console_font=make_find_symbol("console_font");
-  l_default_ai_function=make_find_symbol("default_ai");
-  l_tile_files=make_find_symbol("tile_files");
-  l_empty_cache=make_find_symbol("empty_cache");
-  l_range=make_find_symbol("range");
-  l_difficulty=make_find_symbol("difficulty");
-  l_death_handler=make_find_symbol("death_handler");
-  l_title_screen=make_find_symbol("title_screen");
-  l_fields=make_find_symbol("fields");
-  l_FIRE=make_find_symbol("FIRE");
-  l_fire_object=make_find_symbol("fire_object");
-  l_cop_dead_parts=make_find_symbol("cop_dead_parts");  set_symbol_value(l_difficulty,l_hard);
-  l_restart_player=make_find_symbol("restart_player");
-  l_help_screens=make_find_symbol("help_screens");
-  l_save_order=make_find_symbol("save_order");
-  l_next_song=make_find_symbol("next_song");
-  l_player_draw=make_find_symbol("player_draw");
-  l_sneaky_draw=make_find_symbol("sneaky_draw");
-  l_keep_backup=make_find_symbol("keep_backup");
-  l_level_loaded=make_find_symbol("level_loaded");
-
-  l_draw_fast=make_find_symbol("draw_fast");
-  l_player_tints=make_find_symbol("player_tints");
-
-  l_max_hp=make_find_symbol("max_hp");
-  set_symbol_number(l_max_hp,200);
-  l_max_power=make_find_symbol("max_power");
-  l_main_menu=make_find_symbol("main_menu");
-  set_symbol_number(l_max_power,999);
-
-  set_symbol_number(make_find_symbol("run_state"),RUN_STATE);
-  set_symbol_number(make_find_symbol("pause_state"),PAUSE_STATE);
-  set_symbol_number(make_find_symbol("menu_state"),MENU_STATE);
-  set_symbol_number(make_find_symbol("scene_state"),SCENE_STATE);
-
-  l_statbar_ammo_x=make_find_symbol("statbar_ammo_x");
-  l_statbar_ammo_y=make_find_symbol("statbar_ammo_y");
-  l_statbar_ammo_w=make_find_symbol("statbar_ammo_w");
-  l_statbar_ammo_h=make_find_symbol("statbar_ammo_h");
-  l_statbar_ammo_bg_color=make_find_symbol("statbar_ammo_bg_color");
-
-  l_statbar_health_x=make_find_symbol("statbar_health_x");
-  l_statbar_health_y=make_find_symbol("statbar_health_y");
-  l_statbar_health_w=make_find_symbol("statbar_health_w");
-  l_statbar_health_h=make_find_symbol("statbar_health_h");
-  l_statbar_health_bg_color=make_find_symbol("statbar_health_bg_color");
-
-  l_statbar_logo_x=make_find_symbol("statbar_logo_x");
-  l_statbar_logo_y=make_find_symbol("statbar_logo_y");
-  l_object=make_find_symbol("object");
-  l_tile=make_find_symbol("tile");
-  l_cdc_logo=make_find_symbol("logo");
-
-  l_switch_to_powerful=make_find_symbol("switch_to_powerful");
-  l_mouse_can_switch=make_find_symbol("mouse_can_switch");
-  l_ask_save_slot=make_find_symbol("ask_save_slot");
-
-  l_level_load_start=make_find_symbol("level_load_start");
-  l_level_load_end=make_find_symbol("level_load_end");
-  l_get_local_input=make_find_symbol("get_local_input");
-  l_chat_input=make_find_symbol("chat_input");
-  l_player_text_color=make_find_symbol("player_text_color");
+  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_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_max_hp->SetNumber(200);
+  l_max_power = LispSymbol::FindOrCreate("max_power");
+  l_main_menu = LispSymbol::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");
 
   int i;
   for (i=0;i<MAX_STATE;i++)
-    set_symbol_number(make_find_symbol(state_names[i]),i);
+    LispSymbol::FindOrCreate(state_names[i])->SetNumber(i);
   for (i=0;i<TOTAL_ABILITIES;i++)
-    set_symbol_number(make_find_symbol(ability_names[i]),i);
+    LispSymbol::FindOrCreate(ability_names[i])->SetNumber(i);
   for (i=0;i<TOTAL_CFLAGS;i++)
-    set_symbol_number(make_find_symbol(cflag_names[i]),i);
-
-  l_song_list=make_find_symbol("song_list");
-  l_post_render=make_find_symbol("post_render");
+    LispSymbol::FindOrCreate(cflag_names[i])->SetNumber(i);
+
+  l_song_list = LispSymbol::FindOrCreate("song_list");
+  l_post_render = LispSymbol::FindOrCreate("post_render");
 
   add_c_function("distx",0,0,                   1);
@@ -756 +761 @@
       if (item_type(sym)!=L_SYMBOL)
       {
-    lbreak("expecting first arg to def-character to be a symbol!\n");
-    exit(0);
+        lbreak("expecting first arg to def-character to be a symbol!\n");
+        exit(0);
       }
       int sp=current_space;
       current_space=PERM_SPACE;
-      set_symbol_number(sym,total_objects);   // set the symbol value to the object number
+      sym->SetNumber(total_objects);   // set the symbol value to the object number
       current_space=sp;
       if (!total_objects)
@@ -774 +779 @@
       }
 
-      object_names[total_objects] = strdup(lstring_value(symbol_name(sym)));
+      object_names[total_objects] = strdup(lstring_value(sym->GetName()));
       figures[total_objects]=new character_type(CDR(args),sym);
       total_objects++;
@@ -794 +799 @@
     {
 #ifdef __linux__
-      return make_find_symbol("LINUX");
+      return LispSymbol::FindOrCreate("LINUX");
 #endif
 #ifdef __sgi
-      return make_find_symbol("IRIX");
+      return LispSymbol::FindOrCreate("IRIX");
 #endif
 #ifdef __WIN32
-      return make_find_symbol("WIN32");
+      return LispSymbol::FindOrCreate("WIN32");
 #endif
     } break;
@@ -1366 +1371 @@
       int id=cache.reg(lstring_value(lcar(args)),NULL,SPEC_EXTERN_SFX,1);
       if (sym)
-        set_symbol_number(sym,id);    // set the symbol value to sfx id                
+        sym->SetNumber(id);    // set the symbol value to sfx id
       current_space=sp;
       return id;

abuse/trunk/src/clisp.h

@@ -14 +14 @@
 
 // variables for the status bar
+extern LispSymbol *l_chat_input, *l_post_render;
+
+// FIXME: port these to LispSymbol
 extern void *l_statbar_ammo_x,*l_statbar_ammo_y,
             *l_statbar_ammo_w,*l_statbar_ammo_h,
@@ -34 +37 @@
         *l_ask_save_slot,
         *l_get_local_input,
-        *l_post_render,
-        *l_chat_input,
         *l_player_text_color,
         *l_level_loaded;        // called when a new level is loaded
@@ -41 +42 @@
 
 /******************************** Lisp objects **********************************/
-extern void *l_difficulty,*l_easy,*l_hard,*l_medium,*l_extreme,*l_main_menu,
+extern LispSymbol *l_difficulty, *l_easy, *l_hard, *l_medium, *l_extreme,
+    *l_max_hp, *l_max_power,
+    *l_empty_cache;
+
+// FIXME: port these to LispSymbol
+extern void *l_main_menu,
      *l_logo,*l_state_art,*l_default_abilities,*l_abilities,
-     *l_default_ai_function,*l_state_sfx,
-     *l_morph,*l_max_power,
-     *l_song_list,*l_filename,*l_sfx_directory,*l_max_hp,*l_default_font,
-     *l_empty_cache,*l_range,*l_joy_file,*l_death_handler,
+     *l_default_ai_function,*l_state_sfx, *l_morph,
+     *l_song_list,*l_filename,*l_sfx_directory,*l_default_font,
+     *l_range,*l_joy_file,*l_death_handler,
      *l_title_screen,*l_console_font,*l_fields,*l_FIRE,*l_fire_object,
      *l_cop_dead_parts,*l_restart_player,*l_help_screens,*l_save_order;

abuse/trunk/src/compiled.cpp

@@ -42 +42 @@
 static int32_t c_state(char const *name)
 {
-  void *sym=find_symbol(name);
+  void *sym = LispSymbol::Find(name);
   if (sym)
   {
@@ -122 +122 @@
   S_DELETE_SND=  c_state("DEL_OBJECT_SND");
 
-  void *b=make_find_symbol("bad_guy_list");
+  void *b = LispSymbol::FindOrCreate("bad_guy_list");
   if (b && DEFINEDP(symbol_value(b)))
   {
@@ -138 +138 @@
   }
 
-  void *v=symbol_value(make_find_symbol("last_save_game"));
+  void *v = LispSymbol::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 );
-    Cell *f = find_symbol( tmp );
-    if( !NILP( f ) && DEFINEDP( symbol_value( f ) ) )
-    {
-        void *what = symbol_value( f );
-        if( what == make_find_symbol( "keyboard" ) )
+    LispSymbol *f = LispSymbol::Find(tmp);
+    if( !NILP(f) && DEFINEDP(f->GetValue()))
+    {
+        void *what = f->GetValue();
+        if(what == LispSymbol::FindOrCreate("keyboard"))
             return 1;
-        else if( what == make_find_symbol( "joystick" ) )
+        else if(what == LispSymbol::FindOrCreate("joystick"))
             return 2;
     }

abuse/trunk/src/cop.cpp

@@ -727 +727 @@
     if (o->lvars[just_fired_var])
     {
-      o->draw_double_tint(lnumber_value(((LispArray *)symbol_value(l_player_tints))->Get(num)),S_bright_tint);
+      o->draw_double_tint(lnumber_value(((LispArray *)((LispSymbol *)l_player_tints)->GetValue())->Get(num)), S_bright_tint);
       o->lvars[just_fired_var]=0;
     } else
-      o->draw_tint(lnumber_value(((LispArray *)symbol_value(l_player_tints))->Get(num)));
+      o->draw_tint(lnumber_value(((LispArray *)((LispSymbol *)l_player_tints)->GetValue())->Get(num)));
   }
   return NULL;
@@ -1021 +1021 @@
     for (i=0;i<tp;i++)
     {
-      int color=lnumber_value(((LispArray *)symbol_value(l_player_text_color))->Get(sorted_players[i]->get_tint()));
+      int color=lnumber_value(((LispArray *)((LispSymbol *)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 *)symbol_value(l_player_text_color))->Get(v->get_tint()));
+    int color=lnumber_value(((LispArray *)((LispSymbol *)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.cpp

@@ -169 +169 @@
 
   the_game->load_level(tname);
-  initial_difficulty=l_difficulty;
+  initial_difficulty = l_difficulty;
 
   switch (diff)
   {
-    case 0 :
-    { set_symbol_value(l_difficulty,l_easy); } break;
-    case 1 :
-    { set_symbol_value(l_difficulty,l_medium); } break;
-    case 2 :
-    { set_symbol_value(l_difficulty,l_hard); } break;
-    case 3 :
-    { set_symbol_value(l_difficulty,l_extreme); } break;
+    case 0: l_difficulty->SetValue(l_easy); break;
+    case 1: l_difficulty->SetValue(l_medium); break;
+    case 2: l_difficulty->SetValue(l_hard); break;
+    case 3: l_difficulty->SetValue(l_extreme); break;
   }
 
@@ -207 +203 @@
 */
       delete record_file;
-      l_difficulty=initial_difficulty;
+      l_difficulty = initial_difficulty;
       the_game->set_state(MENU_STATE);
       wm->push_event(new event(ID_NULL,NULL));

abuse/trunk/src/demo.h

@@ -11 +11 @@
 #define __DEMO_HPP_
 
+#include "lisp.h"
 #include "jwindow.h"
 
 class demo_manager
 {
-  void *initial_difficulty;
+  LispSymbol *initial_difficulty;
   bFILE *record_file;
   int skip_next;

abuse/trunk/src/dev.cpp

@@ -42 +42 @@
 char const *symbol_str(char const *name)
 {
-  void *sym=make_find_symbol(name);
-  if (symbol_value(sym) && item_type(symbol_value(sym))==L_STRING)
-    return lstring_value(symbol_value(sym));
+  LispSymbol *sym = LispSymbol::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=make_find_symbol(name);
-  if (symbol_value(sym) && item_type(symbol_value(sym))==L_STRING)
-    return lstring_value(symbol_value(sym));
+  sym = LispSymbol::FindOrCreate(name);
+  if (sym->GetValue() && item_type(sym->GetValue())==L_STRING)
+    return lstring_value(sym->GetValue());
 
 
   // check to see if there is a missing symbol definition
-  sym=make_find_symbol("missing_sym");
-  if (symbol_value(sym) && item_type(symbol_value(sym))==L_STRING)
-    return lstring_value(symbol_value(sym));
+  sym = LispSymbol::FindOrCreate("missing_sym");
+  if (sym->GetValue() && item_type(sym->GetValue())==L_STRING)
+    return lstring_value(sym->GetValue());
 
   // last resort, return english string

abuse/trunk/src/director.cpp

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

abuse/trunk/src/endgame.cpp

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

abuse/trunk/src/game.cpp

@@ -686 +686 @@
 static void post_render()
 {
-  if(DEFINEDP(symbol_function(l_post_render)))
+  if(DEFINEDP(l_post_render->GetFunction()))
   {
     screen->dirt_off();
     clear_tmp();
-    eval_function((LispSymbol *)l_post_render, NULL);
+    eval_function(l_post_render, NULL);
     clear_tmp();
     screen->dirt_on();
@@ -1232 +1232 @@
     }
 
-    void *logo_snd = symbol_value(make_find_symbol("LOGO_SND"));
+    void *logo_snd = LispSymbol::FindOrCreate("LOGO_SND")->GetValue();
 
     if(DEFINEDP(logo_snd) && (sound_avail & SFX_INITIALIZED))
@@ -1249 +1249 @@
     milli_wait(400);
 
-    void *space_snd = symbol_value(make_find_symbol("SPACE_SND"));
+    void *space_snd = LispSymbol::FindOrCreate("SPACE_SND")->GetValue();
 
     fade_out(32);
@@ -1255 +1255 @@
 
     int i;
-    char *str = lstring_value(eval(make_find_symbol("plot_start")));
+    char *str = lstring_value(eval(LispSymbol::FindOrCreate("plot_start")));
 
     bFILE *fp = open_file("art/smoke.spe", "rb");
@@ -2637 +2637 @@
     if(!(main_net_cfg && main_net_cfg->restart_state()))
     {
-      void *end_msg = make_find_symbol("end_msg");
-      if(DEFINEDP(symbol_value(end_msg)))
-      printf("%s\n", lstring_value(symbol_value(end_msg)));
+      LispSymbol *end_msg = LispSymbol::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)
 {
-  void *v=find_symbol(symbol);
-  if (!v || !DEFINEDP(symbol_value(v))) return "Language symbol missing!";
-  else return lstring_value(symbol_value(v));
+    LispSymbol *v = LispSymbol::Find(symbol);
+    if (!v || !DEFINEDP(v->GetValue()))
+        return "Language symbol missing!";
+    return lstring_value(v->GetValue());
 }
 
@@ -68 +69 @@
 
     // see if user has already done this routine
-    Cell *gs = find_symbol("darkest_gray");
+    LispSymbol *gs = LispSymbol::Find("darkest_gray");
 
     if(old_pal)
@@ -77 +78 @@
     }
 
-    if(gs && DEFINEDP(symbol_value(gs)) && !force_menu)
-    {
-        dg = lnumber_value(symbol_value(gs));
+    if(gs && DEFINEDP(gs->GetValue()) && !force_menu)
+    {
+        dg = lnumber_value(gs->GetValue());
     }
     else
     {
-        if(gs && DEFINEDP(symbol_value(gs)))
-        {
-            dg = old_dg = lnumber_value(symbol_value(gs));
+        if(gs && DEFINEDP(gs->GetValue()))
+        {
+            dg = old_dg = lnumber_value(gs->GetValue());
         }
         // load in a fine gray palette they can chose from
@@ -181 +182 @@
                 int sp = current_space;
                 current_space = PERM_SPACE;
-                set_symbol_value(make_find_symbol("darkest_gray"), new_lisp_number(dg));
+                LispSymbol::FindOrCreate("darkest_gray")->SetNumber(dg);
 
                 current_space = sp;

abuse/trunk/src/level.cpp

@@ -1080 +1080 @@
       {
         if (figures[new_type]->seq[k] &&
-           !strcmp(lstring_value(symbol_name(figures[new_type]->seq_syms[k])),old_name))
+           !strcmp(lstring_value(((LispSymbol *)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(symbol_name(figures[new_type]->vars[k])),old_name))
+        if (!strcmp(lstring_value(((LispSymbol *)figures[new_type]->vars[k])->GetName()),old_name))
           *(v_remap[i]+j)=figures[new_type]->var_index[k];
           }
@@ -1560 +1560 @@
     for (;j<figures[i]->ts;j++)
       if (figures[i]->seq[j])
-        size+=1+strlen(lstring_value(symbol_name(figures[i]->seq_syms[j])))+1;
+        size+=1+strlen(lstring_value(((LispSymbol *)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(symbol_name(figures[i]->vars[j])))+1;
+        size+=1+strlen(lstring_value(((LispSymbol *)figures[i]->vars[j])->GetName()))+1;
   }
   sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"describe_lvars",NULL,size,0));
@@ -1827 +1827 @@
   } else
   {
-    void *fun=make_find_symbol("set_player_defaults");
-    if (DEFINEDP(symbol_function(fun)))
+    LispSymbol *fun = LispSymbol::FindOrCreate("set_player_defaults");
+    if (DEFINEDP(fun->GetFunction()))
     {
       view *f;
@@ -1838 +1838 @@
       current_object=f->focus;
       void *m=mark_heap(TMP_SPACE);
-      eval_function((LispSymbol *)fun,NULL);
+      eval_function(fun,NULL);
       restore_heap(m,TMP_SPACE);
     }
@@ -1887 +1887 @@
       if (figures[i]->seq[j])
       {
-    char *state_name=lstring_value(symbol_name(figures[i]->seq_syms[j]));
+    char *state_name=lstring_value(((LispSymbol *)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(symbol_name(figures[i]->vars[j]));
+      char *var_name=lstring_value(((LispSymbol *)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

@@ -820 +820 @@
 */
 
-LispSymbol *find_symbol(char const *name)
-{
-  LispSymbol *p=lsym_root;
-  while (p)
-  {
-    int cmp=strcmp(name, ((char *)p->name)+sizeof(LispString));
-    if (cmp==0) return p;
-    else if (cmp<0) p=p->left;
-    else p=p->right;
-  }
-  return NULL;
-}
-
-
-
-LispSymbol *make_find_symbol(char const *name)
-{
-  LispSymbol *p=lsym_root;
-  LispSymbol **parent=&lsym_root;
-  while (p)
-  {
-    int cmp=strcmp(name, ((char *)p->name)+sizeof(LispString));
-    if (cmp==0) return p;
-    else if (cmp<0)
-    {
-      parent=&p->left;
-      p=p->left;
-    }
-    else
-    {
-      parent=&p->right;
-      p=p->right;
-    }
-  }
-  int sp=current_space;
-  if (current_space!=GC_SPACE)
-     current_space=PERM_SPACE;       // make sure all symbols get defined in permanant space
-
-  p=(LispSymbol *)malloc(sizeof(LispSymbol));
-  p->type=L_SYMBOL;
-  p->name=new_lisp_string(name);
-
-  if (name[0]==':')     // constant, set the value to ourself
-    p->value=p;
-  else
-    p->value=l_undefined;
-  p->function=l_undefined;
+LispSymbol *LispSymbol::Find(char const *name)
+{
+    LispSymbol *p = lsym_root;
+    while (p)
+    {
+        int cmp = strcmp(name, ((char *)p->name) + sizeof(LispString));
+        if (cmp == 0)
+            return p;
+        p = (cmp < 0) ? p->left : p->right;
+    }
+    return NULL;
+}
+
+LispSymbol *LispSymbol::FindOrCreate(char const *name)
+{
+    LispSymbol *p = lsym_root;
+    LispSymbol **parent = &lsym_root;
+    while (p)
+    {
+        int cmp = strcmp(name, ((char *)p->name) + sizeof(LispString));
+        if (cmp == 0)
+            return p;
+        parent = (cmp < 0) ? &p->left : &p->right;
+        p = *parent;
+    }
+
+    // Make sure all symbols get defined in permanant space
+    int sp = current_space;
+    if (current_space != GC_SPACE)
+       current_space = PERM_SPACE;
+
+    p = (LispSymbol *)malloc(sizeof(LispSymbol));
+    p->type = L_SYMBOL;
+    p->name = new_lisp_string(name);
+
+    // If constant, set the value to ourself
+    p->value = (name[0] == ':') ? p : l_undefined;
+    p->function = l_undefined;
 #ifdef L_PROFILE
-  p->time_taken=0;
-#endif
-  p->left=p->right=NULL;
-  *parent=p;
-  ltotal_syms++;
-
-  current_space=sp;
-  return p;
-}
-
+    p->time_taken = 0;
+#endif
+    p->left = p->right = NULL;
+    *parent = p;
+    ltotal_syms++;
+
+    current_space = sp;
+    return p;
+}
 
 void ldelete_syms(LispSymbol *root)
@@ -898 +888 @@
     {
       if (lisp_eq(CAR(CAR(list)), item))
-        return lcar(list);    
+        return lcar(list);
       list=(LispList *)(CDR(list));
     }
@@ -967 +957 @@
 }
 
-void *lookup_symbol_function(void *symbol)
-{
-  return ((LispSymbol *)symbol)->function;
-}
-
-void set_symbol_function(void *symbol, void *function)
-{
-  ((LispSymbol *)symbol)->function=function;
-}
-
-void *lookup_symbol_value(void *symbol)
-{
-#ifdef TYPE_CHECKING
-  if (((LispSymbol *)symbol)->value!=l_undefined)
-#endif
-    return ((LispSymbol *)symbol)->value;
-#ifdef TYPE_CHECKING
-  else
-  {
-    lprint(symbol);
-    lbreak(" has no value\n");
-    exit(0);
-  }
-#endif
-  return NULL;
-}
-
-void set_variable_value(void *symbol, void *value)
-{
-  ((LispSymbol *) symbol)->value=value;
+void LispSymbol::SetFunction(void *fun)
+{
+    function = fun;
 }
 
@@ -1002 +965 @@
 {
   need_perm_space("add_sys_function");
-  LispSymbol *s=make_find_symbol(name);
+  LispSymbol *s = LispSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1018 +981 @@
   if (s->value!=l_undefined)
   {
-    lbreak("add_c_object -> symbol %s already has a value\n", lstring_value(symbol_name(s)));
+    lbreak("add_c_object -> symbol %s already has a value\n", lstring_value(s->GetName()));
     exit(0);
   }
@@ -1029 +992 @@
   total_user_functions++;
   need_perm_space("add_c_function");
-  LispSymbol *s=make_find_symbol(name);
+  LispSymbol *s = LispSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1043 +1006 @@
   total_user_functions++;
   need_perm_space("add_c_bool_fun");
-  LispSymbol *s=make_find_symbol(name);
+  LispSymbol *s = LispSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1058 +1021 @@
   total_user_functions++;
   need_perm_space("add_c_bool_fun");
-  LispSymbol *s=make_find_symbol(name);
+  LispSymbol *s = LispSymbol::FindOrCreate(name);
   if (s->function!=l_undefined)
   {
@@ -1286 +1249 @@
       void *cs=new_cons_cell(), *c2=NULL, *tmp;
       p_ref r4(cs), r5(c2);
-      tmp=make_find_symbol("function");
+      tmp = LispSymbol::FindOrCreate("function");
       ((LispList *)cs)->car=tmp;
       c2=new_cons_cell();
@@ -1300 +1263 @@
     }
   } else {
-    ret = make_find_symbol(n);
+    ret = LispSymbol::FindOrCreate(n);
   }
   return ret;
@@ -1587 +1550 @@
     {
       char st[100];
-      sprintf(st, "%20s %f\n", lstring_value(symbol_name(p)), ((LispSymbol *)p)->time_taken);
+      sprintf(st, "%20s %f\n", lstring_value(p->GetName()), p->time_taken);
       out->write(st, strlen(st));
     }
@@ -2149 +2112 @@
     case SYS_FUNC_DEFUN:
     {
-      void *symbol=CAR(arg_list);
+      LispSymbol *symbol = (LispSymbol *)CAR(arg_list);
 #ifdef TYPE_CHECKING
       if (item_type(symbol)!=L_SYMBOL)
@@ -2174 +2137 @@
       LispUserFunction *ufun=new_lisp_user_function(lcar(lcdr(arg_list)), block_list);
 #endif
-      set_symbol_function(symbol, ufun);
+      symbol->SetFunction(ufun);
       ret=symbol;
     } break;
@@ -2279 +2242 @@
     } break;
     case SYS_FUNC_FUNCTION:
-      ret=lookup_symbol_function(eval(CAR(arg_list)));
+      ret = ((LispSymbol *)eval(CAR(arg_list)))->GetFunction();
     break;
     case SYS_FUNC_MAPCAR:
@@ -2402 +2365 @@
             {
                 delete fp;
-                if( DEFINEDP(symbol_value(load_warning)) && symbol_value(load_warning) )
+                if( DEFINEDP(((LispSymbol *)load_warning)->GetValue())
+                     && ((LispSymbol *)load_warning)->GetValue())
                     dprintf("Warning : file %s does not exist\n", st);
                 ret = NULL;
@@ -2560 +2524 @@
     case SYS_FUNC_FOR:
     {
-      void *bind_var=CAR(arg_list); arg_list=CDR(arg_list);
+      LispSymbol *bind_var = (LispSymbol *)CAR(arg_list);
+      arg_list = CDR(arg_list);
       p_ref r1(bind_var);
       if (item_type(bind_var)!=L_SYMBOL)
@@ -2578 +2543 @@
       void *block=NULL, *ret=NULL;
       p_ref r3(block);
-      l_user_stack.push(symbol_value(bind_var));  // save old symbol value
+      l_user_stack.push(bind_var->GetValue());  // save old symbol value
       while (ilist)
       {
-                set_symbol_value(bind_var, CAR(ilist));
+                bind_var->SetValue(CAR(ilist));
                 for (block=arg_list;block;block=CDR(block))
                   ret=eval(CAR(block));
                 ilist=CDR(ilist);
       }
-      set_symbol_value(bind_var, l_user_stack.pop(1));
+      bind_var->SetValue(l_user_stack.pop(1)); // restore symbol value
       ret=ret;
     } break;
@@ -2729 +2694 @@
       p_ref r1(init_var);
       int i, ustack_start=l_user_stack.son;      // restore stack at end
-      void *sym=NULL;
+      LispSymbol *sym = NULL;
       p_ref r2(sym);
 
@@ -2735 +2700 @@
       for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var))
       {
-                sym=CAR(CAR(init_var));
+                sym = (LispSymbol *)CAR(CAR(init_var));
                 if (item_type(sym)!=L_SYMBOL)
                 { lbreak("expecting symbol name for iteration var\n"); exit(0); }
-                l_user_stack.push(symbol_value(sym));
+                l_user_stack.push(sym->GetValue());
       }
 
@@ -2749 +2714 @@
       for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var), do_evaled++)
       {
-                sym=CAR(CAR(init_var));
-                set_symbol_value(sym, *do_evaled);
+                sym = (LispSymbol *)CAR(CAR(init_var));
+                sym->SetValue(*do_evaled);
       }
 
@@ -2771 +2736 @@
       for (init_var=CAR(arg_list);init_var;init_var=CDR(init_var), do_evaled++)
       {
-                sym=CAR(CAR(init_var));
-                set_symbol_value(sym, *do_evaled);
+                sym = (LispSymbol *)CAR(CAR(init_var));
+                sym->SetValue(*do_evaled);
       }
 
@@ -3050 +3015 @@
         else
                 {
-                  ret=lookup_symbol_value(prog);
+                  ret = ((LispSymbol *)prog)->GetValue();
                   if (item_type(ret)==L_OBJECT_VAR)
                     ret=l_obj_get(((LispObjectVar *)ret)->number);
@@ -3162 +3127 @@
 }
 
-void *symbol_name(void *symbol)
-{
-  return ((LispSymbol *)symbol)->name;
-}
-
-
-void *set_symbol_number(void *symbol, long num)
+void *LispSymbol::GetName()
 {
 #ifdef TYPE_CHECKING
-  if (item_type(symbol)!=L_SYMBOL)
-  {
-    lprint(symbol);
-    lbreak("is not a symbol\n");
-    exit(0);
-  }
-#endif
-  if (((LispSymbol *)symbol)->value!=l_undefined &&
-      item_type(((LispSymbol *)symbol)->value)==L_NUMBER)
-    ((LispNumber *)((LispSymbol *)symbol)->value)->num=num;
-  else
-    ((LispSymbol *)(symbol))->value=new_lisp_number(num);
-
-  return ((LispSymbol *)(symbol))->value;
-}
-
-void *set_symbol_value(void *symbol, void *value)
+    if (item_type(this) != L_SYMBOL)
+    {
+        lprint(this);
+        lbreak("is not a symbol\n");
+        exit(0);
+    }
+#endif
+    return name;
+}
+
+void *LispSymbol::SetNumber(long num)
 {
 #ifdef TYPE_CHECKING
-  if (item_type(symbol)!=L_SYMBOL)
-  {
-    lprint(symbol);
-    lbreak("is not a symbol\n");
-    exit(0);
-  }
-#endif
-  ((LispSymbol *)(symbol))->value=value;
-  return value;
-}
-
-void *symbol_function(void *symbol)
+    if (item_type(this) != L_SYMBOL)
+    {
+        lprint(this);
+        lbreak("is not a symbol\n");
+        exit(0);
+    }
+#endif
+    if (value != l_undefined && item_type(value) == L_NUMBER)
+        ((LispNumber *)value)->num = num;
+    else
+        value = new_lisp_number(num);
+
+    return value;
+}
+
+void *LispSymbol::SetValue(void *val)
 {
 #ifdef TYPE_CHECKING
-  if (item_type(symbol)!=L_SYMBOL)
-  {
-    lprint(symbol);
-    lbreak("is not a symbol\n");
-    exit(0);
-  }
-#endif
-  return ((LispSymbol *)symbol)->function;
-}
-
-void *symbol_value(void *symbol)
+    if (item_type(this) != L_SYMBOL)
+    {
+        lprint(this);
+        lbreak("is not a symbol\n");
+        exit(0);
+    }
+#endif
+    value = val;
+    return value;
+}
+
+void *LispSymbol::GetFunction()
 {
 #ifdef TYPE_CHECKING
-  if (item_type(symbol)!=L_SYMBOL)
-  {
-    lprint(symbol);
-    lbreak("is not a symbol\n");
-    exit(0);
-  }
-#endif
-  return ((LispSymbol *)symbol)->value;
-}
-
-
-
-
-
-
+    if (item_type(this) != L_SYMBOL)
+    {
+        lprint(this);
+        lbreak("is not a symbol\n");
+        exit(0);
+    }
+#endif
+    return function;
+}
+
+void *LispSymbol::GetValue()
+{
+#ifdef TYPE_CHECKING
+    if (item_type(this) != L_SYMBOL)
+    {
+        lprint(this);
+        lbreak("is not a symbol\n");
+        exit(0);
+    }
+#endif
+    return value;
+}
+

abuse/trunk/src/lisp/lisp.h

@@ -71 +71 @@
 };
 
+struct LispString : LispObject
+{
+};
+
 struct LispSymbol : LispObject
 {
+    static LispSymbol *Find(char const *name);
+    static LispSymbol *FindOrCreate(char const *name);
+
+    void *GetName();
+    void *GetFunction();
+    void *GetValue();
+
+    void SetFunction(void *fun);
+    void *SetValue(void *value);
+    void *SetNumber(long num);
+
 #ifdef L_PROFILE
     float time_taken;
 #endif
-    void *value, *function, *name;
+    void *value, *function;
+    LispString *name;
     LispSymbol *left, *right; // tree structure
 };
@@ -107 +123 @@
 private:
     LispObject *data[1];
-};
-
-struct LispString : LispObject
-{
 };
 
@@ -147 +159 @@
 void *lisp_eq(void *n1, void *n2);
 void *lisp_equal(void *n1, void *n2);
-LispSymbol *find_symbol(char const *name);
 long list_length(void *i);
 void lprint(void *i);
@@ -155 +166 @@
 void *eval_user_fun(LispSymbol *sym, void *arg_list);
 void *compile(char const *&s);
-void *symbol_value(void *symbol);
-void *symbol_function(void *symbol);
-void *set_symbol_number(void *symbol, long num);
-void *set_symbol_value(void *symbol, void *value);
-void *symbol_name(void *symbol);
 void *assoc(void *item, void *list);
 void resize_tmp(int new_size);
 void resize_perm(int new_size);
-LispSymbol *make_find_symbol(char const *name);
 
 void push_onto_list(void *object, void *&list);
@@ -222 +227 @@
 extern void l_obj_print(long number);  // exten lisp function switches on number
 
-
-
-#endif
+// FIXME: get rid of this later
+static inline void *symbol_value(void *sym) { return ((LispSymbol *)sym)->GetValue(); }
+
+
+
+#endif

abuse/trunk/src/lisp/lisp_gc.cpp

@@ -224 +224 @@
     root->value = collect_object(root->value);
     root->function = collect_object(root->function);
-    root->name = collect_object(root->name);
+    root->name = (LispString *)collect_object(root->name);
     collect_symbols(root->left);
     collect_symbols(root->right);

abuse/trunk/src/lisp/lisp_gc.h

@@ -25 +25 @@
   p_ref(LispObject *&ref) { l_ptr_stack.push((void **)&ref); }
   p_ref(LispArray *&ref) { l_ptr_stack.push((void **)&ref); }
+  p_ref(LispSymbol *&ref) { l_ptr_stack.push((void **)&ref); }
   ~p_ref() { l_ptr_stack.pop(1); }
 } ;

abuse/trunk/src/lisp/lisp_opt.cpp

@@ -91 +91 @@
 }
 
-
 void l_comp_init()
 {
-  l_undefined=make_find_symbol(":UNDEFINED");  // this needs to be defined first
-  ((LispSymbol *)l_undefined)->function=NULL;  // collection problems result if we don't do this
-  ((LispSymbol *)l_undefined)->value=NULL;
+    // This needs to be defined first
+    l_undefined = LispSymbol::FindOrCreate(":UNDEFINED");
 
+    // Collection problems result if we don't do this
+    ((LispSymbol *)l_undefined)->function = NULL;
+    ((LispSymbol *)l_undefined)->value = NULL;
 
-  true_symbol=make_find_symbol("T");
+    true_symbol = LispSymbol::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=make_find_symbol("list");
-  string_symbol=make_find_symbol("string");
-  quote_symbol=make_find_symbol("quote");
-  backquote_symbol=make_find_symbol("backquote");
-  comma_symbol=make_find_symbol("comma");
-  in_symbol=make_find_symbol("in");
-  do_symbol=make_find_symbol("do");
-  aref_symbol=make_find_symbol("aref");
-  colon_initial_contents=make_find_symbol(":initial-contents");
-  colon_initial_element=make_find_symbol(":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=make_find_symbol("if-1progn");
-  if_2progn=make_find_symbol("if-2progn");
-  if_12progn=make_find_symbol("if-12progn");
-  if_symbol=make_find_symbol("if");
-  progn_symbol=make_find_symbol("progn");
-  not_symbol=make_find_symbol("not");
-  eq_symbol=make_find_symbol("eq");
-  zero_symbol=make_find_symbol("0");
-  eq0_symbol=make_find_symbol("eq0");
-  car_symbol=make_find_symbol("car");
-  cdr_symbol=make_find_symbol("cdr");
-  load_warning=make_find_symbol("load_warning");
-}

abuse/trunk/src/loader2.cpp

@@ -367 +367 @@
 
   char const *ff;
-  if (DEFINEDP(symbol_value(make_find_symbol("frame_file"))))
-    ff=lstring_value(symbol_value(make_find_symbol("frame_file")));
+  // FIXME: unnecessary duplicate call
+  if (DEFINEDP(LispSymbol::FindOrCreate("frame_file")->GetValue()))
+    ff = lstring_value(LispSymbol::FindOrCreate("frame_file")->GetValue());
   else
-    ff="art/frame.spe";
+    ff = "art/frame.spe";
 
   ok_button   =      cache.reg(ff,"dev_ok",SPEC_IMAGE);
@@ -415 +416 @@
   {
     if (!strcmp(argv[i],"-ec"))
-      set_symbol_value(l_empty_cache,true_symbol);
+      l_empty_cache->SetValue(true_symbol);
     if (!strcmp(argv[i],"-t"))
     {

abuse/trunk/src/menu.cpp

@@ -377 +377 @@
 void show_sell(int abortable)
 {
-  void *ss=make_find_symbol("sell_screens");
-  if (!DEFINEDP(symbol_value(ss)))
+  LispSymbol *ss = LispSymbol::FindOrCreate("sell_screens");
+  if (!DEFINEDP(ss->GetValue()))
   {
     int sp=current_space;
@@ -385 +385 @@
 //    char *prog="((\"art/endgame.spe\" . \"credit\") (\"art/help.spe\" . \"sell6\"))";
     char const *prog="((\"art/endgame.spe\" . \"credit\"))";
-    set_symbol_value(ss,compile(prog));
+    ss->SetValue(compile(prog));
     current_space=sp;
   }
 
-  if (DEFINEDP(symbol_value(ss)))
+  if (DEFINEDP(ss->GetValue()))
   {
     image blank(2,2); blank.clear();
     wm->set_mouse_shape(blank.copy(),0,0);      // don't show mouse
 
-    ss=symbol_value(ss);
+    LispObject *tmp = (LispObject *)ss->GetValue();
     int quit=0;
-    while (ss && !quit)
-    {
-      int im=cache.reg_object("art/help.spe",CAR(ss),SPEC_IMAGE,1);
+    while (tmp && !quit)
+    {
+      int im=cache.reg_object("art/help.spe",CAR(tmp),SPEC_IMAGE,1);
       fade_in(cache.img(im),16);
 
@@ -409 +409 @@
         quit=1;
       fade_out(16);
-      ss=CDR(ss);
+      tmp = (LispObject *)CDR(tmp);
     }
     wm->set_mouse_shape(cache.img(c_normal)->copy(),1,1);
@@ -469 +469 @@
     case ID_MEDIUM :
     {
-      set_symbol_value(l_difficulty,l_medium);
+      l_difficulty->SetValue(l_medium);
       save_difficulty();
     } break;
     case ID_HARD :
     {
-      set_symbol_value(l_difficulty,l_hard);
+      l_difficulty->SetValue(l_hard);
       save_difficulty();
     } break;
     case ID_EXTREME :
     {
-      set_symbol_value(l_difficulty,l_extreme);
+      l_difficulty->SetValue(l_extreme);
       save_difficulty();
     } break;
     case ID_EASY :
     {
-      set_symbol_value(l_difficulty,l_easy);
+      l_difficulty->SetValue(l_easy);
       save_difficulty();
     } break;
@@ -696 +696 @@
                 if (!current_demo)
                 {
-                    void *d=make_find_symbol("demos");
-                    if (DEFINEDP(symbol_value(d)))
-                        current_demo=symbol_value(d);
+                    LispSymbol *d = LispSymbol::FindOrCreate("demos");
+                    if (DEFINEDP(d->GetValue()))
+                        current_demo = d->GetValue();
                 }
                 if (current_demo)

abuse/trunk/src/objects.cpp

@@ -105 +105 @@
   for (i=0;i<figures[otype]->tiv;i++)
   {
-    if (!strcmp(lstring_value(symbol_name(figures[otype]->vars[i])),name))
+    if (!strcmp(lstring_value(((LispSymbol *)figures[otype]->vars[i])->GetName()),name))
     {
       return lvars[figures[otype]->var_index[i]];
@@ -135 +135 @@
   }
   for (i=0;i<figures[otype]->tiv;i++)
-    if (!strcmp(lstring_value(symbol_name(figures[otype]->vars[i])),name))
+    if (!strcmp(lstring_value(((LispSymbol *)figures[otype]->vars[i])->GetName()),name))
     {
       lvars[figures[otype]->var_index[i]]=value;

abuse/trunk/src/particle.cpp

@@ -70 +70 @@
   int sp=current_space;
   current_space=PERM_SPACE;
-  set_symbol_number(sym,total_pseqs);   // set the symbol value to the object number
+  sym->SetNumber(total_pseqs); // set the symbol value to the object number
   current_space=sp;
   pseqs=(part_sequence **)realloc(pseqs,sizeof(part_sequence *)*(total_pseqs+1));

abuse/trunk/src/statbar.cpp

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

abuse/trunk/src/view.cpp

@@ -453 +453 @@
   if (len>38 || key==JK_ENTER)
   {
-    if (DEFINEDP(symbol_function(l_chat_input)))
+    if (DEFINEDP(l_chat_input->GetFunction()))
     {
       game_object *o=current_object;