Updated handling of nested structs.

Author: pkesseli

regression/test_gen/java1/TestGenTest.class

@@ -33,10 +33,8 @@ public C(int c_field_0, B c_field_1)
 
 public class TestGenTest
 {
-  public void f(B param0, C param1, int param2)
+  public static void f(B param0, C param1, int param2)
   {
-    if (param0 == null || param1 == null) return;
-
     int a_field_0=param0.a_field_0;
     int a_field_1=param0.a_field_1;
     int b_field_0=param0.b_field_0;

regression/test_gen/java1/TestGenTest.java

@@ -30,7 +30,10 @@ inputst generate_inputs(const symbol_tablet &st, const goto_functionst &gf,
       {
         const irep_idt &id=to_symbol_expr(lhs).get_identifier();
         if (st.has_symbol(id) && !is_meta(id))
-          result.insert(std::make_pair(id, step.full_lhs_value));
+        {
+          const exprt &value=step.full_lhs_value;
+          result.insert(std::make_pair(id, value));
+        }
       }
     }
   }

src/test_gen/java_test_case_generator.cpp

@@ -12,7 +12,7 @@
 #include <test_gen/java_test_source_factory.h>
 
 #define INDENT_SPACES "  "
-#define ID_value_alias "value-alias"
+#define JAVA_NS_PREFIX_LEN 6u
 
 namespace
 {
@@ -33,49 +33,46 @@ void add_test_class_name(std::string &result, const std::string &func_name)
   result+="() {\n";
 }
 
-void add_decl_with_init_prefix(std::string &result, const symbol_tablet &st,
-    const typet &type)
-{
-  const namespacet ns(st);
-  result+=type2java(type, ns);
-  result+=' ';
-}
-
-void add_decl_with_init_prefix(std::string &result, const symbol_tablet &st,
-    const symbolt &symbol)
-{
-  add_decl_with_init_prefix(result, st, symbol.type);
-}
-
 void add_symbol(std::string &result, const symbolt &s)
 {
   // XXX: Should be expr2java(...) once functional.
   const irep_idt &n=s.pretty_name.empty() ? s.base_name : s.pretty_name;
   result+=id2string(n);
 }
 
-std::string get_symbol(const symbolt &symbol)
+void add_qualified_class_name(std::string &result, const namespacet &ns,
+    const typet &type)
 {
-  std::string result;
-  add_symbol(result, symbol);
-  return result;
+  if (ID_symbol == type.id())
+  {
+    const std::string &id=id2string(to_symbol_type(type).get_identifier());
+    assert(id.size() >= JAVA_NS_PREFIX_LEN);
+    result+=id.substr(JAVA_NS_PREFIX_LEN);
+  } else result+=id2string(to_struct_type(type).get_tag());
 }
 
-void addQualifiedClassName(std::string &result, const namespacet &ns,
-    const typet &type)
+void add_decl_with_init_prefix(std::string &result, const symbol_tablet &st,
+    const symbolt &symbol)
 {
-  result+=type2java(type, ns);
+  const namespacet ns(st);
+  if (ID_pointer != symbol.type.id()) result+=type2java(symbol.type, ns);
+  else add_qualified_class_name(result, ns, symbol.type.subtype());
+  result+=' ';
 }
 
 void add_value(std::string &result, const symbol_tablet &st,
-    const std::string &this_name, const struct_exprt &value);
+    const struct_exprt &value, const std::string &this_name);
 
 void add_value(std::string &result, const symbol_tablet &st, const exprt &value,
     const std::string var_name="")
 {
   const namespacet ns(st);
-  if (ID_struct != value.id()) result+=expr2java(value, ns);
-  else add_value(result, st, var_name, to_struct_expr(value));
+  const irep_idt &id=value.id();
+  if (ID_address_of == id) add_value(result, st,
+      to_address_of_expr(value).object());
+  else if (ID_struct == id) add_value(result, st, to_struct_expr(value),
+      var_name);
+  else result+=expr2java(value, ns);
 }
 
 class member_factoryt
@@ -97,79 +94,64 @@ class member_factoryt
   void operator()(const exprt &value)
   {
     assert(comp_index < comps.size());
-    result+="Reflector.setInstanceField(";
-    result+=this_name;
-    const struct_typet::componentt &comp=comps[comp_index++];
-    result+=",\"";
-    result+=id2string(comp.get_pretty_name());
-    add_value(result, st, value);
-    result+=");\n";
+    if (ID_struct == value.id())
+    {
+      member_factoryt mem_fac(result, st, this_name, value.type());
+      const struct_exprt::operandst &ops=value.operands();
+      std::for_each(ops.begin(), ops.end(), mem_fac);
+      if (comp_index < comps.size() - 1) result+=";\n";
+    } else
+    {
+      const struct_typet::componentt &comp=comps[comp_index];
+      if (ID_symbol != comp.type().id())
+      {
+        indent(result, 2u)+="Reflector.setInstanceField(";
+        result+=this_name;
+        result+=",\"";
+        result+=id2string(comp.get_pretty_name());
+        result+="\",";
+        add_value(result, st, value);
+        result+=")";
+        if (comp_index < comps.size() - 1) result+=";\n";
+      }
+    }
+    ++comp_index;
   }
 };
 
 void add_value(std::string &result, const symbol_tablet &st,
-    const std::string &this_name, const struct_exprt &value)
+    const struct_exprt &value, const std::string &this_name)
 {
-  const std::string &alias=value.get_string(ID_value_alias);
-  if (!alias.empty())
-  {
-    result+=alias;
-    return;
-  }
   const namespacet ns(st);
   result+='(';
   const typet &type=value.type();
-  result+=type2java(value.type(), ns);
+  add_qualified_class_name(result, ns, type);
   result+=") Reflector.forceInstance(\"";
-  addQualifiedClassName(result, ns, type);
+  add_qualified_class_name(result, ns, type);
   result+="\");\n";
   member_factoryt mem_fac(result, st, this_name, type);
   const struct_exprt::operandst &ops=value.operands();
   std::for_each(ops.begin(), ops.end(), mem_fac);
 }
 
 void add_assign_value(std::string &result, const symbol_tablet &st,
-    const std::string &symbol, const exprt &value)
+    const symbolt &symbol, const exprt &value)
 {
-  result+=symbol;
+  std::string symbol_name;
+  add_symbol(symbol_name, symbol);
+  result+=symbol_name;
   result+='=';
-  add_value(result, st, value);
+  add_value(result, st, value, symbol_name);
   result+=";\n";
 }
 
-void add_assign_value(std::string &result, const symbol_tablet &st,
-    const symbolt &symbol, const exprt &value)
-{
-  add_assign_value(result, st, get_symbol(symbol), value);
-}
-
-void add_nested_objects(std::string &result, const symbol_tablet &st,
-    const std::string &this_name, exprt &value)
-{
-  if (ID_struct != value.id()) return;
-  size_t i=0;
-  struct_exprt::operandst &ops=value.operands();
-  for (struct_exprt::operandst::value_type &op : ops)
-  {
-    if (ID_struct != op.id()) continue;
-    std::string name(this_name);
-    name+='_';
-    name+=std::to_string(i);
-    add_nested_objects(result, st, this_name, op);
-    add_decl_with_init_prefix(result, st, op.type());
-    add_assign_value(result, st, name, op);
-    op.set(ID_value_alias, name);
-  }
-}
-
 void add_global_state_assignments(std::string &result, const symbol_tablet &st,
     inputst &inputs)
 {
   for (inputst::value_type &input : inputs)
   {
     const symbolt &symbol=st.lookup(input.first);
     if (!symbol.is_static_lifetime) continue;
-    add_nested_objects(result, st, get_symbol(symbol), input.second);
     add_assign_value(indent(result, 2u), st, symbol, input.second);
   }
 }
@@ -194,7 +176,6 @@ void add_func_call_parameters(std::string &result, const symbol_tablet &st,
     const symbolt &symbol=st.lookup(param);
     const inputst::iterator value=inputs.find(param);
     assert(inputs.end() != value);
-    add_nested_objects(result, st, get_symbol(symbol), value->second);
     add_decl_with_init_prefix(indent(result, 2u), st, symbol);
     add_assign_value(result, st, symbol, value->second);
   }
@@ -203,7 +184,7 @@ void add_func_call_parameters(std::string &result, const symbol_tablet &st,
 std::string &add_func_call(std::string &result, const symbol_tablet &st,
     const irep_idt &func_id)
 {
-// XXX: Should be expr2java(...) once functional.
+  // XXX: Should be expr2java(...) once functional.
   const symbolt &s=st.lookup(func_id);
   const std::string func_name_with_brackets(id2string(s.pretty_name));
   const size_t sz=func_name_with_brackets.size();
@@ -216,7 +197,7 @@ std::string &add_func_call(std::string &result, const symbol_tablet &st,
     add_symbol(result, st.lookup(param));
     result+=',';
   }
-  (*result.rbegin())=')';
+  *result.rbegin()=')';
   result+=";\n";
   indent(result)+="}\n";
   return result+="}\n";