Restricted interface of current symbol_tablet

Author: NathanJPhillips

src/ansi-c/ansi_c_entry_point.cpp

@@ -212,7 +212,7 @@ bool generate_ansi_c_start_function(
   // build call to initialization function
 
   {
-    symbol_tablet::symbolst::iterator init_it=
+    symbol_tablet::symbolst::const_iterator init_it=
       symbol_table.symbols.find(INITIALIZE_FUNCTION);
 
     if(init_it==symbol_table.symbols.end())
@@ -478,11 +478,11 @@ bool generate_ansi_c_start_function(
   new_symbol.value.swap(init_code);
   new_symbol.mode=symbol.mode;
 
-  if(symbol_table.move(new_symbol))
+  if(!symbol_table.insert(std::move(new_symbol)))
   {
     messaget message;
     message.set_message_handler(message_handler);
-    message.error() << "failed to move main symbol" << messaget::eom;
+    message.error() << "failed to insert main symbol" << messaget::eom;
     return true;
   }
 

src/ansi-c/c_typecheck_base.cpp

@@ -100,7 +100,7 @@ void c_typecheck_baset::typecheck_symbol(symbolt &symbol)
   }
 
   // see if we have it already
-  symbol_tablet::symbolst::iterator old_it=
+  symbol_tablet::symbolst::const_iterator old_it=
     symbol_table.symbols.find(symbol.name);
 
   if(old_it==symbol_table.symbols.end())
@@ -121,10 +121,11 @@ void c_typecheck_baset::typecheck_symbol(symbolt &symbol)
       throw 0;
     }
 
+    symbolt & existing_symbol=symbol_table.get_writeable(symbol.name);
     if(symbol.is_type)
-      typecheck_redefinition_type(old_it->second, symbol);
+      typecheck_redefinition_type(existing_symbol, symbol);
     else
-      typecheck_redefinition_non_type(old_it->second, symbol);
+      typecheck_redefinition_non_type(existing_symbol, symbol);
   }
 }
 
@@ -350,10 +351,10 @@ void c_typecheck_baset::typecheck_redefinition_non_type(
           {
             const irep_idt &identifier=p_it->get_identifier();
 
-            symbol_tablet::symbolst::iterator p_s_it=
+            symbol_tablet::symbolst::const_iterator p_s_it=
               symbol_table.symbols.find(identifier);
             if(p_s_it!=symbol_table.symbols.end())
-              symbol_table.symbols.erase(p_s_it);
+              symbol_table.erase(p_s_it);
           }
         }
         else
@@ -732,10 +733,7 @@ void c_typecheck_baset::typecheck_declaration(
       // add code contract (if any); we typecheck this after the
       // function body done above, so as to have parameter symbols
       // available
-      symbol_tablet::symbolst::iterator s_it=
-        symbol_table.symbols.find(identifier);
-      assert(s_it!=symbol_table.symbols.end());
-      symbolt &new_symbol=s_it->second;
+      symbolt &new_symbol=symbol_table.get_writeable(identifier);
 
       typecheck_spec_expr(contract, ID_C_spec_requires);
 

src/ansi-c/c_typecheck_code.cpp

@@ -287,7 +287,7 @@ void c_typecheck_baset::typecheck_decl(codet &code)
     irep_idt identifier=d_it->get_name();
 
     // look it up
-    symbol_tablet::symbolst::iterator s_it=
+    symbol_tablet::symbolst::const_iterator s_it=
       symbol_table.symbols.find(identifier);
 
     if(s_it==symbol_table.symbols.end())
@@ -298,7 +298,7 @@ void c_typecheck_baset::typecheck_decl(codet &code)
       throw 0;
     }
 
-    symbolt &symbol=s_it->second;
+    const symbolt &symbol=s_it->second;
 
     // This must not be an incomplete type, unless it's 'extern'
     // or a typedef.

src/ansi-c/c_typecheck_expr.cpp

@@ -485,7 +485,7 @@ void c_typecheck_baset::typecheck_expr_builtin_va_arg(exprt &expr)
   symbol.name=ID_gcc_builtin_va_arg;
   symbol.type=symbol_type;
 
-  symbol_table.move(symbol);
+  symbol_table.insert(std::move(symbol));
 }
 
 void c_typecheck_baset::typecheck_expr_cw_va_arg_typeof(exprt &expr)
@@ -704,7 +704,7 @@ void c_typecheck_baset::typecheck_expr_operands(exprt &expr)
       declaration.declarators().front().get_name();
 
     // look it up
-    symbol_tablet::symbolst::iterator s_it=
+    symbol_tablet::symbolst::const_iterator s_it=
       symbol_table.symbols.find(identifier);
 
     if(s_it==symbol_table.symbols.end())
@@ -715,7 +715,7 @@ void c_typecheck_baset::typecheck_expr_operands(exprt &expr)
       throw 0;
     }
 
-    symbolt &symbol=s_it->second;
+    const symbolt &symbol=s_it->second;
 
     if(symbol.is_type || symbol.is_extern || symbol.is_static_lifetime ||
        !is_complete_type(symbol.type) || symbol.type.id()==ID_code)

src/ansi-c/c_typecheck_type.cpp

@@ -208,12 +208,7 @@ void c_typecheck_baset::typecheck_type(typet &type)
       {
         const irep_idt &tag_name=
           to_c_enum_tag_type(type.subtype()).get_identifier();
-
-        symbol_tablet::symbolst::iterator entry=
-          symbol_table.symbols.find(tag_name);
-        assert(entry!=symbol_table.symbols.end());
-
-        entry->second.type.subtype()=result;
+        symbol_table.get_writeable(tag_name).type.subtype()=result;
       }
 
       type=result;
@@ -736,7 +731,7 @@ void c_typecheck_baset::typecheck_compound_type(struct_union_typet &type)
     identifier=type.find(ID_tag).get(ID_identifier);
 
     // does it exist already?
-    symbol_tablet::symbolst::iterator s_it=
+    symbol_tablet::symbolst::const_iterator s_it=
       symbol_table.symbols.find(identifier);
 
     if(s_it==symbol_table.symbols.end())
@@ -787,7 +782,7 @@ void c_typecheck_baset::typecheck_compound_type(struct_union_typet &type)
           type.set(ID_tag, base_name);
 
           typecheck_compound_body(type);
-          s_it->second.type.swap(type);
+          symbol_table.get_writeable(s_it->first).type.swap(type);
         }
       }
       else if(have_body)
@@ -1213,19 +1208,19 @@ void c_typecheck_baset::typecheck_c_enum_type(typet &type)
   enum_tag_symbol.type.subtype()=underlying_type;
 
   // is it in the symbol table already?
-  symbol_tablet::symbolst::iterator s_it=
+  symbol_tablet::symbolst::const_iterator s_it=
     symbol_table.symbols.find(identifier);
 
   if(s_it!=symbol_table.symbols.end())
   {
     // Yes.
-    symbolt &symbol=s_it->second;
+    const symbolt &symbol=s_it->second;
 
     if(symbol.type.id()==ID_incomplete_c_enum)
     {
       // Ok, overwrite the type in the symbol table.
       // This gives us the members and the subtype.
-      symbol.type=enum_tag_symbol.type;
+      symbol_table.get_writeable(symbol.name).type=enum_tag_symbol.type;
     }
     else if(symbol.type.id()==ID_c_enum)
     {

src/cpp/cpp_declarator_converter.cpp

@@ -98,10 +98,7 @@ symbolt &cpp_declarator_convertert::convert(
     }
 
     // try static first
-    symbol_tablet::symbolst::iterator c_it=
-      cpp_typecheck.symbol_table.symbols.find(final_identifier);
-
-    if(c_it==cpp_typecheck.symbol_table.symbols.end())
+    if(!cpp_typecheck.symbol_table.has_symbol(final_identifier))
     {
       // adjust type if it's a non-static member function
       if(final_type.id()==ID_code)
@@ -111,9 +108,7 @@ symbolt &cpp_declarator_convertert::convert(
       get_final_identifier();
 
       // try again
-      c_it=cpp_typecheck.symbol_table.symbols.find(final_identifier);
-
-      if(c_it==cpp_typecheck.symbol_table.symbols.end())
+      if(!cpp_typecheck.symbol_table.has_symbol(final_identifier))
       {
         cpp_typecheck.error().source_location=
           declarator.name().source_location();
@@ -125,9 +120,7 @@ symbolt &cpp_declarator_convertert::convert(
       }
     }
 
-    assert(c_it!=cpp_typecheck.symbol_table.symbols.end());
-
-    symbolt &symbol=c_it->second;
+    symbolt &symbol=cpp_typecheck.symbol_table.get_writeable(final_identifier);
 
     combine_types(declarator.name().source_location(), final_type, symbol);
     enforce_rules(symbol);
@@ -194,13 +187,10 @@ symbolt &cpp_declarator_convertert::convert(
     }
 
     // already there?
-    symbol_tablet::symbolst::iterator c_it=
-      cpp_typecheck.symbol_table.symbols.find(final_identifier);
-
-    if(c_it==cpp_typecheck.symbol_table.symbols.end())
+    if(!cpp_typecheck.symbol_table.has_symbol(final_identifier))
       return convert_new_symbol(storage_spec, member_spec, declarator);
 
-    symbolt &symbol=c_it->second;
+    symbolt &symbol=cpp_typecheck.symbol_table.get_writeable(final_identifier);
 
     if(!storage_spec.is_extern())
       symbol.is_extern = false;

src/cpp/cpp_instantiate_template.cpp

@@ -372,7 +372,7 @@ const symbolt &cpp_typecheckt::instantiate_template(
   // been instantiated using these arguments
   {
     // need non-const handle on template symbol
-    symbolt &s=symbol_table.symbols.find(template_symbol.name)->second;
+    symbolt &s=symbol_table.get_writeable(template_symbol.name);
     irept &instantiated_with=s.value.add("instantiated_with");
     instantiated_with.get_sub().push_back(specialization_template_args);
   }
@@ -451,12 +451,7 @@ const symbolt &cpp_typecheckt::instantiate_template(
 
   if(is_template_method)
   {
-    symbol_tablet::symbolst::iterator it =
-      symbol_table.symbols.find(class_name);
-
-    assert(it!=symbol_table.symbols.end());
-
-    symbolt &symb = it->second;
+    symbolt &symb=symbol_table.get_writeable(class_name);
 
     assert(new_decl.declarators().size() == 1);
 

src/cpp/cpp_typecheck.cpp

@@ -151,9 +151,9 @@ void cpp_typecheckt::static_and_dynamic_initialization()
 
   disable_access_control = true;
 
-  for(const auto &d_it : dynamic_initializations)
+  for(const irep_idt &d_it : dynamic_initializations)
   {
-    symbolt &symbol=symbol_table.symbols.find(d_it)->second;
+    const symbolt &symbol=symbol_table.lookup(d_it);
 
     if(symbol.is_extern)
       continue;
@@ -178,7 +178,7 @@ void cpp_typecheckt::static_and_dynamic_initialization()
 
       // Make it nil to get zero initialization by
       // __CPROVER_initialize
-      symbol.value.make_nil();
+      symbol_table.get_writeable(d_it).value.make_nil();
     }
     else
     {
@@ -210,7 +210,7 @@ void cpp_typecheckt::static_and_dynamic_initialization()
   init_symbol.is_type=false;
   init_symbol.is_macro=false;
 
-  symbol_table.move(init_symbol);
+  symbol_table.insert(std::move(init_symbol));
 
   disable_access_control=false;
 }
@@ -223,14 +223,15 @@ void cpp_typecheckt::do_not_typechecked()
   {
     cont = false;
 
-    Forall_symbols(s_it, symbol_table.symbols)
+    for(const auto &named_symbol : symbol_table.symbols)
     {
-      symbolt &symbol=s_it->second;
+      const symbolt &symbol=named_symbol.second;
 
       if(symbol.value.id()=="cpp_not_typechecked" &&
          symbol.value.get_bool("is_used"))
       {
         assert(symbol.type.id()==ID_code);
+        symbolt &symbol=symbol_table.get_writeable(named_symbol.first);
 
         if(symbol.base_name=="operator=")
         {
@@ -256,37 +257,36 @@ void cpp_typecheckt::do_not_typechecked()
   }
   while(cont);
 
-  Forall_symbols(s_it, symbol_table.symbols)
+  for(const auto &named_symbol : symbol_table.symbols)
   {
-    symbolt &symbol=s_it->second;
-    if(symbol.value.id()=="cpp_not_typechecked")
-      symbol.value.make_nil();
+    if(named_symbol.second.value.id()=="cpp_not_typechecked")
+      symbol_table.get_writeable(named_symbol.first).value.make_nil();
   }
 }
 
 void cpp_typecheckt::clean_up()
 {
-  symbol_tablet::symbolst::iterator it=symbol_table.symbols.begin();
+  symbol_tablet::symbolst::const_iterator it=symbol_table.symbols.begin();
 
   while(it!=symbol_table.symbols.end())
   {
-    symbol_tablet::symbolst::iterator cur_it = it;
+    symbol_tablet::symbolst::const_iterator cur_it = it;
     it++;
 
-    symbolt &symbol = cur_it->second;
+    const symbolt &symbol=cur_it->second;
 
     // erase templates
     if(symbol.type.get_bool(ID_is_template))
     {
-      symbol_table.symbols.erase(cur_it);
+      symbol_table.erase(cur_it);
       continue;
     }
     else if(symbol.type.id()==ID_struct ||
             symbol.type.id()==ID_union)
     {
       // remove methods from 'components'
       struct_union_typet &struct_union_type=
-        to_struct_union_type(symbol.type);
+        to_struct_union_type(symbol_table.get_writeable(cur_it->first).type);
 
       const struct_union_typet::componentst &components=
         struct_union_type.components();