home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / sos3-2.lha / src / genCC / genCC.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-23  |  52.5 KB  |  1,886 lines
  1. /* --------------------------------------------------------------------------
  2.  * Copyright 1992 by Forschungszentrum Informatik (FZI)
  3.  *
  4.  * You can use and distribute this software under the terms of the licence
  5.  * you should have received along with this program.
  6.  * If not or if you want additional information, write to
  7.  * Forschungszentrum Informatik, "STONE", Haid-und-Neu-Strasse 10-14,
  8.  * D-7500 Karlsruhe 1, Germany.
  9.  * --------------------------------------------------------------------------
  10.  */
  11. // **************************************************************************
  12. // Module genCC                                              Juergen Uhl (ju)
  13. //
  14. // **************************************************************************
  15. // SOS interface generator for C++ 
  16. // **************************************************************************
  17.  
  18. #include <stream.h>
  19. #include "sys.h"
  20. #include "smg.h"
  21. #include "genCC_err.h"
  22. #include "trc_genCC.h"
  23. #include "mta_use.h"
  24. #include "cci_use.h"
  25.  
  26. #include "genCC.h"
  27.  
  28. const sos_Cstring U_SUFFIX    = "_use.h";
  29. const sos_Cstring I_SUFFIX    = "_sos.h";
  30. const sos_Cstring X_SUFFIX    = "_ext.h";
  31. const sos_Cstring C_SUFFIX    = "_sos.c";
  32. const sos_Cstring _ID        = "_";
  33. const sos_Cstring CCI        = "cci_Schema_impl";
  34.  
  35. const sos_Cstring INT1        = "sos_Char";
  36. const sos_Cstring INT2        = "sos_Short";
  37. const sos_Cstring INT4        = "sos_Int";
  38.  
  39. sos_Bool gen_inline;
  40.  
  41. static void imports_out (sos_Imports);
  42. static void typedef_type_out (sos_Typedef_type);
  43. static void enum_type_out (sos_Enum_type,sos_Bool);
  44. static void scalar_type_out (sos_Schema_type);
  45. static void union_type_out (sos_Union_type);
  46. static void class_type_out (sos_Class_type);
  47. static void type_type_out (sos_Schema_type);
  48. static void inits_out (sos_Schema_module);
  49.  
  50. static void id_class_out (sos_Class_type, sos_Super_class_List);
  51. static void id_super_classes_out (sos_Type_name_List);
  52. static void id_cc_methods_out (sos_Class_type);
  53. static void id_predefined_methods_out (sos_Class_type);
  54. static sos_Method_kind id_method_kind;
  55. static void id_methods_out (sos_Class_type, sos_Method_List);
  56. static void id_method_out (sos_Class_type, sos_Method);
  57. static void id_comp_method_out (sos_Class_type, sos_Comp_method);
  58. enum Method_class {MC_REGULAR, MC_COMP, MC_STATIC};
  59. static void id_univ_methods_out (sos_Class_type  ct,
  60.                  sos_Method_List ml,
  61.                  Method_class    mc,
  62.                  sos_Bool        only_predefined);
  63. static void id_univ_method_out (sos_Class_type ct,
  64.                 sos_Method     m,
  65.                 sos_Bool       is_static);
  66.  
  67. static void class_out (sos_Class_type, sos_Super_class_List);
  68. static void init_out (sos_Class_type, sos_Super_class_List);
  69. static void friends_out (sos_Class_type);
  70. static void ccc_methods_out (sos_Class_type);
  71. static void cc_methods_out (sos_Class_type);
  72. static sos_Method_kind method_kind;
  73. static void inherited_methods_out (sos_Class_type);
  74. static void method_out (sos_Class_type, sos_Method);
  75. static void params_out (ostream&,
  76.             sos_Param_List,
  77.             sos_Bool no_param_names,
  78.             sos_Bool impl,
  79.             sos_Bool actual,
  80.             sos_Bool first = TRUE,
  81.             sos_Int start = 1);
  82. static void type_conversion_out (ostream&, sos_Type_name, sos_Type_name, sos_Bool);
  83. static void params_and_type_conversion_out
  84.            (ostream&, sos_Param_List, sos_Param_List, sos_Bool);
  85. static void exprs_out (ostream&, sos_Expr_List, sos_Bool);
  86.  
  87. static ostream& operator<< (ostream&, sos_String_List);
  88. static ostream& operator<< (ostream&, sos_Type_name);
  89. static ostream& operator<< (ostream&, sos_Param_List);
  90. static ostream& operator<< (ostream&, sos_Param);
  91. static ostream& operator<< (ostream&, sos_Expr);
  92. static ostream& operator<< (ostream&, sos_Expr_List);
  93. static ostream& operator<< (ostream&, sos_Typed_id);
  94. static ostream& operator<< (ostream&, sos_Method_kind);
  95.  
  96. static sos_Bool is_root_type (sos_Type);
  97. static sos_Bool is_generic_parameter (sos_Type_name);
  98. static sos_Bool is_ccc_method (sos_Method);
  99. static sos_Schema_type get_void_type();
  100. static sos_Schema_type get_scalar_object_type();
  101. static sos_Schema_module generated_schema;
  102.  
  103. filebuf fb_h;
  104. filebuf fb_i;
  105. filebuf fb_c;
  106. ostream out_h(&fb_h);
  107. ostream out_i(&fb_i);
  108. ostream out_c(&fb_c);
  109.  
  110. #define out_I (gen_inline?out_h:out_i)
  111.  
  112. void gen_module_out (sos_Schema_module mdl)
  113. {
  114.    T_PROC ("gen_module_out");
  115.    TT (genCC_H, T_ENTER);
  116.  
  117.    generated_schema = mdl;
  118.  
  119.    sos_Container ct = mdl.container();
  120.    ct.open (WRITING, WAITING);
  121.    cci_Schema_impl::make_impl (mdl);
  122.  
  123.    sos_Schema_type_List type_decls = mdl.get_types();
  124.    smg_String m_name = mdl.get_name();
  125.    smg_String u_name = m_name + U_SUFFIX;
  126.    smg_String i_name = m_name + I_SUFFIX;
  127.    smg_String c_name = m_name + C_SUFFIX;
  128.  
  129.    if (fb_h.open(u_name.make_Cstring (SMG_BORROW), output) == 0 || 
  130.        fb_i.open(i_name.make_Cstring (SMG_BORROW), output) == 0 ||
  131.        fb_c.open(c_name.make_Cstring (SMG_BORROW), output) == 0)
  132.    {  err_raise (err_USE, err_GEN_OUTPUT_ERROR, NULL, FALSE);
  133.       return;
  134.    }
  135.  
  136.    out_h << "#ifndef " << m_name << "_SOSH\n"
  137.          << "#define " << m_name << "_SOSH 1\n\n";
  138.  
  139.    out_i << "#ifndef " << m_name << "_SOSI\n"
  140.          << "#define " << m_name << "_SOSI 1\n\n"
  141.      << "#include \"" << m_name << U_SUFFIX << "\"\n";
  142.  
  143.    out_c << "#include \"" << m_name << I_SUFFIX << "\"\n";
  144.  
  145.    out_c << "#include \"err.h\"\n";    // for 'err_raise_abstract_method'
  146.  
  147.    imports_out (mdl.get_imports());
  148.  
  149.    out_c << "#include \"cci" << U_SUFFIX << "\"\n";
  150.  
  151.    agg_iterate (type_decls, sos_Schema_type td)
  152.    {  if (td.has_type(sos_Enum_type_type))
  153.          enum_type_out (sos_Enum_type::make(td),TRUE);
  154.       else if (td.has_type(sos_Class_type_type))
  155.       {  if (is_root_type (td))
  156.         out_I << "class " << _ID << td.make_type_name() << ";\n";
  157.          out_h << "class " << td.make_type_name() << ";\n";
  158.       }
  159.       else if (td.has_type(sos_Typedef_type_type))
  160.          typedef_type_out (sos_Typedef_type::make(td)); 
  161.    }
  162.    agg_iterate_end (type_decls, td);
  163.  
  164.    if (mdl.get_has_external_types() OR mdl.get_has_external_import())
  165.       out_h << "#include \"" << m_name << X_SUFFIX << "\"\n";
  166.  
  167.    agg_iterate (type_decls, sos_Schema_type td)
  168.    {  if (td.has_type(sos_Enum_type_type))
  169.          enum_type_out (sos_Enum_type::make(td),FALSE);
  170.       else if (td.has_type(sos_Extern_type_type))
  171.       {
  172. #ifdef ATT
  173.      if (td.operator!=(get_void_type ()))
  174. #else
  175.      if (td != get_void_type ())
  176. #endif
  177.         scalar_type_out (td);
  178.       }
  179.       else if (td.has_type(sos_Union_type_type))
  180.          union_type_out (sos_Union_type::make(td));
  181.       else if (td.has_type(sos_Class_type_type))
  182.          class_type_out (sos_Class_type::make(td));
  183.       else if (NOT td.has_type(sos_Typedef_type_type))
  184.       // predefined or forward type: do nothing
  185.          continue;
  186.       
  187.       type_type_out (td);
  188.    }
  189.    agg_iterate_end (type_decls, td);
  190.  
  191.    inits_out (mdl);
  192.  
  193.    out_h << "#endif\n";
  194.    out_i << "#endif\n";
  195.  
  196.    fb_h.close();
  197.    fb_i.close();
  198.    fb_c.close();
  199.  
  200.    ct.close ();
  201.  
  202.    TT (genCC_H, T_LEAVE);
  203. }
  204.  
  205. static void imports_out (sos_Imports imports)
  206. {
  207.    T_PROC ("imports_out");
  208.    TT (genCC_H, T_ENTER);
  209.  
  210.    agg_iterate (imports, sos_Schema_module mdl)
  211.    {  out_h << "#include \"" << mdl.get_name() << U_SUFFIX << "\"\n";
  212.       out_I << "#include \"" << mdl.get_name() << I_SUFFIX << "\"\n";
  213.    }
  214.    agg_iterate_end (imports, mdl);
  215.  
  216.    TT (genCC_H, T_LEAVE);
  217. }
  218.  
  219. static void typedef_type_out (sos_Typedef_type tdt)
  220. {
  221.    T_PROC ("typedef_type_out");
  222.    TT (genCC_H, T_ENTER);
  223.  
  224.    sos_Type_name tn = tdt.get_type_name();
  225.    sos_String n = tdt.get_name();
  226.    out_h << "typedef ";
  227.    if (tn.make_base_type().has_type (sos_Class_type_type))
  228.       out_h << "class ";
  229.  
  230.    out_h << tn << " " << n << ";\n";
  231.    if (tn.make_type().is_scalar ())
  232.    {  sos_String bn = tn.make_base_type().make_type_name ();
  233.       out_h << "#define make_" << n << "_object make_" << bn << "_object\n";
  234.       out_h << "#define make_" << n << " make_" << bn << "\n";
  235.    }
  236.  
  237.    TT (genCC_H, T_LEAVE);
  238. }
  239.  
  240. static void enum_type_out (sos_Enum_type et,sos_Bool declare_type)
  241. {
  242.    T_PROC ("enum_type_out");
  243.    TT (genCC_H, T_ENTER);
  244.  
  245.    sos_String n = et.get_name();
  246.    
  247.    if (declare_type)
  248.       out_h << "enum " << n << " { " << et.get_literals() << " };\n";
  249.    else
  250.    {
  251.       sos_Int    size = et.get_object_size ();
  252.       smg_String ht;
  253.       
  254.       if (size == 1)
  255.          ht = INT1;
  256.       else
  257.       {  err_assert (size == 2, "enum_type_out");
  258.          ht = INT2;
  259.       }
  260.    
  261.       out_h << "inline void bcopy_from_" << n << " (void *e,void *c)\n"
  262.         << "{  *(" << ht << "*)c = (" << ht << ")*(" << n << "*)e; }\n"
  263.         << "inline void bcopy_to_"   << n << " (void *e,void *c)\n"
  264.         << "{  *(" << n  << "*)e = (" << n  << ")*(" << ht << "*)c; }\n";
  265.       
  266.       scalar_type_out (et);
  267.    }
  268.  
  269.    TT (genCC_H, T_LEAVE);
  270. }
  271.  
  272. static void scalar_type_out (sos_Schema_type tp)
  273. {
  274.    T_PROC ("scalar_type_out");
  275.    TT (genCC_H, T_ENTER);
  276.  
  277.    sos_String n = tp.get_name();
  278.  
  279.    out_h << "sos_Object" << " make_" << n << "_object(" << n << ");\n";
  280.    out_c << "sos_Object" << " make_" << n << "_object(" << n << " x)\n"
  281.      << "{  return sos_object_from_extern (&x,bcopy_from_" << n << ","
  282.      << _ID << n << "_type); }\n";
  283.  
  284.    out_h << n << " make_" << n << "(" << "sos_Object" << ");\n";
  285.    out_c << n << " make_" << n << "(" << "sos_Object" << " o)\n"
  286.      << "{  " << n << " x;\n"
  287.      << "   sos_extern_from_object (&x,o,bcopy_to_" << n << ","
  288.      << _ID << n << "_type);\n"
  289.      << "   return x; }\n";
  290.  
  291.    TT (genCC_H, T_LEAVE);
  292. }
  293.  
  294. static void union_type_out (sos_Union_type ut)
  295. {
  296.    T_PROC ("union_type_out");
  297.    TT (genCC_H, T_ENTER);
  298.  
  299.    sos_String n = ut.get_name();
  300.    sos_Type_name_List uniteds = ut.get_uniteds();
  301.  
  302.    out_h << "class " << n << " : public " << "sos_Object" << "\n"
  303.          << "{\n"
  304.          << "public:\n   " << n << "() {}\n";
  305.  
  306.    agg_iterate (uniteds, sos_Type_name tn)
  307.    {  out_h << "   " << n << "(" << tn << ");\n";
  308.       out_c << n << "::" << n << "(" << tn << " p) { *(sos_Object*)this=";
  309.       if (tn.make_type().is_scalar ())
  310.          out_c << "make_"
  311.            << tn.make_base_type().make_type_name () << "_object (p)";
  312.       else
  313.          out_c << "p";
  314.       out_c << "; }\n";
  315.    }
  316.    agg_iterate_end (uniteds, tn);
  317.  
  318.    out_h << "   static " << n << " make(" << "sos_Object);\n";
  319.    out_c << n << " " << n << "::make(" << "sos_Object" << " o)\n"
  320.          << "   { " << n << " x; *(sos_Object*)&x=o; return x; }\n";
  321.  
  322.    out_h << "};\n";
  323.  
  324.    TT (genCC_H, T_LEAVE);
  325. }
  326.  
  327. static void class_type_out (sos_Class_type ct)
  328. {
  329.    T_PROC ("class_type_out");
  330.    TT (genCC_H, T_ENTER);
  331.  
  332.    sos_Super_class_List super_closure = ct.get_super_closure();
  333.  
  334.    if (is_root_type (ct))
  335.       id_class_out (ct, super_closure);
  336.    else
  337.       id_univ_methods_out (ct, ct.get_static_methods(), MC_STATIC, TRUE);
  338.    class_out (ct, super_closure);
  339.  
  340.    TT (genCC_H, T_LEAVE);
  341. }
  342.  
  343. static void type_type_out (sos_Schema_type t)
  344. {
  345.    T_PROC ("type_type_out");
  346.    TT (genCC_H, T_ENTER);
  347.  
  348.    sos_String tn = t.make_type_name();
  349.    sos_Typed_id tpid = t.base().typed_id();
  350.    sos_Id id = tpid.get_id();
  351.    sos_Id tp = tpid.get_tp();
  352.  
  353.    out_h << "#define " << _ID << tn
  354.          << "_type sos_Id::make(sos_Container::make(" << sos_Int(id.container())
  355.      << ")," << id.offset() << ")\n"
  356.      << "#define " << tn << "_type sos_type_object("
  357.      << _ID << tn << "_type,sos_Id::make(sos_Container::make("
  358.      << sos_Int(tp.container()) << ")," << tp.offset() << "))\n";
  359.  
  360.    TT (genCC_H, T_LEAVE);
  361. }
  362.  
  363. static void inits_out (sos_Schema_module mdl)
  364. {
  365.    T_PROC ("inits_out");
  366.    TT (genCC_H, T_ENTER);
  367.  
  368.    sos_Schema_type_List type_decls = mdl.get_types();
  369.    sos_String schema_name = mdl.get_name();
  370.  
  371.    out_I << "extern void _" << schema_name << "_init_sos();\n";
  372.  
  373.         // Call module initialization using a constructor.
  374.         // The destructor ensures that each object module added during
  375.         // incremental loading contains at least one destructor.
  376.         // (A missing destructor list '___DTOR_LIST__' caused a
  377.         //  bus error in gcc-ld.)
  378.    out_c << "static struct _sos_init_dummy {\n"
  379.      << "   _sos_init_dummy() {_" << schema_name << "_init_sos();}"
  380.      << "   ~_sos_init_dummy(){}\n   } _sos_dummy;\n";
  381.  
  382.    out_c << "static int _sos_initialized=0;\n"
  383.      << "void _" << schema_name << "_init_sos(){\n"
  384.      << "   if (_sos_initialized) return;\n"
  385.      << "   _sos_initialized=1;\n";
  386.  
  387.    sos_Imports imports = mdl.get_imports();
  388.  
  389.    agg_iterate (imports, sos_Schema_module imported)
  390.    {  out_c << "   _" << imported.get_name() << "_init_sos();\n";
  391.    }
  392.    agg_iterate_end (imports, imported);
  393.   
  394.    agg_iterate (type_decls, sos_Type tp)
  395.    {  if (tp.has_type (sos_Class_type_type))
  396.       {  sos_String tn = sos_Class_type::make(tp).make_type_name();
  397.      sos_Typed_id tpid = tp.typed_id();
  398.      if (is_root_type (tp))
  399.      {  out_c << "   _" << _ID << tn << "_obj=new " << _ID << tn << ";\n"
  400.           << "   _init_meth_" << tpid << "();\n"
  401.           << "   _init_comp_" << tpid << "();\n";
  402.      }
  403.      out_c << "   _init_stat_" << tpid << "();\n"
  404.            << "   _init_new_" << tpid << "();\n";
  405.       }
  406.       else if ((tp.has_type (sos_Extern_type_type) OR
  407.            tp.has_type (sos_Enum_type_type)) AND
  408. #ifdef ATT
  409.            tp.operator!=(get_void_type ())
  410. #else
  411.            tp != get_void_type ()
  412. #endif
  413.           )
  414.       {  sos_String tn = tp.get_name();
  415.      sos_Super_class_List scl = 
  416.         sos_Class_type::make (get_scalar_object_type()).get_super_closure();
  417.  
  418.      agg_iterate (scl, sos_Super_class sc)
  419.      {  sos_Class_type tp = sc.get_super_class();
  420.         out_c << "   " << CCI << "::enter_make_obj("
  421.           << _ID << tp.get_name() << "_type,"
  422.           << _ID << tn << "_type,("
  423.           << _ID << tp.get_name() << "*) new "
  424.           << _ID << "sos_Scalar_object" << ");\n";
  425.      }
  426.      agg_iterate_end (scl, sc);
  427.  
  428.      if (tp.has_type (sos_Extern_type_type))
  429.         out_c << "   " << CCI << "::enter_string_io ("
  430.               << _ID << tn << "_type,(cci_IO_fun)make_string_from_"
  431.                      << tn << "_object,(cci_IO_fun)make_"
  432.                << tn << "_object_from_string);\n";
  433.       }
  434.    }
  435.    agg_iterate_end (type_decls, tp);
  436.  
  437.    out_c << "}\n";
  438.  
  439.    TT (genCC_H, T_LEAVE);
  440. }
  441.  
  442. static void id_class_out (sos_Class_type ct, sos_Super_class_List super_closure)
  443. {
  444.    T_PROC ("id_class_out");
  445.    TT (genCC_H, T_ENTER);
  446.  
  447.    sos_String cn = ct.make_type_name();
  448.    sos_Type_name stn;        // super class
  449.  
  450.    out_I << "class " << _ID << cn;
  451.    id_super_classes_out (ct.get_super_classes());
  452.    out_I << "\n{  friend class " << cn << ";\n";
  453.  
  454.    // sos_Offset-operations:
  455.    agg_iterate (super_closure, sos_Super_class sc)
  456.    {  sos_Int os = sc.get_offset();
  457.       stn = sc.get_super_class().make_root_type();
  458.  
  459.       out_I << "   virtual sos_Offset _offset_" << stn
  460.         << " () { return " << os << "; }\n";
  461.    }
  462.    agg_iterate_end (super_closure, sc);
  463.  
  464.    out_I << "public:\n";
  465.  
  466.    id_cc_methods_out (ct);
  467.    id_predefined_methods_out (ct);
  468.  
  469.    id_method_kind = sos_PUBLIC;
  470.    id_methods_out (ct, ct.get_methods());
  471.    id_methods_out (ct, ct.get_comp_methods());
  472.    id_methods_out (ct, ct.get_static_methods());
  473.  
  474.    out_I << "};\n";
  475.  
  476.    id_univ_methods_out (ct, ct.get_methods(), MC_REGULAR, FALSE);
  477.    id_univ_methods_out (ct, ct.get_comp_methods(), MC_COMP, FALSE);
  478.    id_univ_methods_out (ct, ct.get_static_methods(), MC_STATIC, FALSE);
  479.  
  480.    out_I << "extern " << _ID << cn << " *_" << _ID << cn << "_obj;\n";
  481.    out_c << _ID << cn << " *_" << _ID << cn << "_obj;\n";
  482.  
  483.    TT (genCC_H, T_LEAVE);
  484.  
  485. } 
  486.  
  487.  
  488. static void id_super_classes_out (sos_Type_name_List super_classes)
  489. {
  490.    T_PROC ("id_super_classes_out");
  491.    TT (genCC_H, T_ENTER);
  492.  
  493.    sos_Bool first = TRUE;
  494.    agg_iterate (super_classes, sos_Type_name sc)
  495.    {  if (first)
  496.       {  first = FALSE;
  497.          out_I << ":";
  498.       }
  499.       else
  500.          out_I << ",";
  501.  
  502.       out_I << "virtual public " << _ID << sc.make_root_type();
  503.    }
  504.    agg_iterate_end (super_classes, sc);
  505.  
  506.    TT (genCC_H, T_LEAVE);
  507. } 
  508.  
  509. static void id_cc_methods_out (sos_Class_type ct)
  510. {
  511.    T_PROC ("id_cc_methods_out");
  512.    TT (genCC_H, T_ENTER);
  513.  
  514.    sos_String cn = ct.make_type_name();
  515.  
  516.    // make
  517.    out_I << "   static " << _ID << cn << "* _make(sos_Typed_id&);\n";
  518.    out_c << _ID << cn << "* " << _ID << cn
  519.      << "::_make(sos_Typed_id &tpid)\n"
  520.      << "{  return (" << _ID << cn << "*)" << CCI << "::get_make_obj("
  521.      << _ID << cn << "_type,tpid.get_tp());\n}\n";
  522.  
  523.    // _size
  524.    out_I << "   virtual sos_Offset _size();\n";
  525.    out_c << "sos_Offset " << _ID << cn << "::_size(){return "
  526.      << ct.get_object_size() << ";}\n";
  527.  
  528.    TT (genCC_H, T_LEAVE);
  529. }
  530.  
  531.  
  532. sos_Super_class_List remove_redefined_locals (sos_Super_class_List scl,
  533.                           sos_String  str,
  534.                           sos_Bool    &removed)
  535. {
  536.    T_PROC ("remove_redefined_locals");
  537.    TT (genCC_H, T_ENTER);
  538.  
  539.    sos_Super_class_List result;
  540.    sos_Super_class_List totals;
  541.  
  542.    removed = FALSE;
  543.    result = sos_Super_class_List::create (TEMP_CONTAINER, FALSE);
  544.    totals = sos_Super_class_List::create (TEMP_CONTAINER, FALSE);
  545.  
  546.    agg_iterate_reverse (scl, sos_Super_class sc)
  547.    {  sos_Bool remove = FALSE;
  548.       sos_Class_type sct = sc.get_super_class();
  549.       agg_iterate (totals, sos_Super_class sc1)
  550.       {  if (sc1.get_super_class().is_derived_from (sct))
  551.      {  remove = TRUE;
  552.         break;
  553.      }
  554.       }
  555.       agg_iterate_end (totals, sc1);
  556.       if (remove)
  557.      removed = TRUE;
  558.       else
  559.      result.insert (1, sc);
  560.       if (sct.get_inherited_methods()[str] != NO_OBJECT)
  561.      totals.append (sc);
  562.    }
  563.    agg_iterate_reverse_end (scl, sc);
  564.    totals.destroy();
  565.  
  566.    TT (genCC_H, T_LEAVE);
  567.  
  568.    return result;
  569. }
  570.  
  571. sos_Bool defines_method (sos_Class_type ct, sos_String str)
  572. {
  573.    T_PROC ("defines_method");
  574.    TT (genCC_H, T_ENTER);
  575.  
  576.    sos_Bool result;
  577.    sos_Method_table mt = ct.get_inherited_methods();
  578.    sos_Method_List ml = mt [str];
  579.    result = (sos_Bool)(ml != NO_OBJECT AND NOT ml.get_nth(1).get_is_predefined());
  580.  
  581.    TT (genCC_H, T_LEAVE);
  582.  
  583.    return result;
  584. }
  585.  
  586. static void id_predefined_methods_out (sos_Class_type ct)
  587. {
  588.    T_PROC ("id_predefined_methods_out");
  589.    TT (genCC_H, T_ENTER);
  590.  
  591.    sos_String cn = ct.make_type_name();
  592.    sos_Param_List create_params = ct.get_create_params();
  593.    sos_Super_class_List super_closure = ct.get_super_closure();
  594.    sos_String str;
  595.    sos_Super_class_List total_closure;
  596.    sos_Bool removed;
  597.  
  598.    // _create
  599.    out_I << "   void _create(sos_Typed_id&";
  600.    if (create_params != NO_OBJECT)
  601.       params_out (out_I, create_params, /* no_param_names */ FALSE, 
  602.           /*impl*/ FALSE, /*actual*/ FALSE, /*is_first*/ FALSE);
  603.    out_I << ");\n";
  604.  
  605.    out_c << "void " << _ID << cn << "::_create(sos_Typed_id&_tpid";
  606.    if (create_params != NO_OBJECT)
  607.       params_out (out_c, create_params, /* no_param_names */ FALSE, 
  608.           /*impl*/ TRUE, /*actual*/ FALSE, /*is_first*/ FALSE);
  609.    out_c << "){\n"
  610.      << "   " << cn << " _x=" << cn << "::make(_tpid,this);\n";
  611.  
  612.    agg_iterate (super_closure, sos_Super_class sc)
  613.    {  sos_Class_type sct = sc.get_super_class();
  614.       if (sct.get_has_init_comps())
  615.       {  sos_Expr_List cpl = sc.get_create_params();
  616.  
  617.      out_c << _ID << sct.make_root_type() << "::_create_comps(_x";
  618.      if (cpl != NO_OBJECT)
  619.         exprs_out (out_c, cpl, /*is_first*/ FALSE);
  620.      out_c << ");\n";
  621.       }
  622.    }
  623.    agg_iterate_end (super_closure, sc);
  624.  
  625.    str = smg_String ("local_initialize").make_String (TEMP_CONTAINER);
  626.    agg_iterate (super_closure, sos_Super_class sc)
  627.    {  sos_Class_type sct = sc.get_super_class();
  628.  
  629.       if (sct.get_inherited_methods() [str] != NO_OBJECT)
  630.       {  out_c << _ID << sct.make_root_type()
  631.            << "::local_initialize(_x);\n";
  632.       }
  633.    }
  634.    agg_iterate_end (super_closure, sc);
  635.    str.destroy();
  636.  
  637.    out_c << "}\n";
  638.  
  639.    // _create_comps
  640.    if (ct.get_has_init_comps())
  641.    {  sos_Method_List ml = ct.get_comp_methods();
  642.  
  643.       out_I << "protected:\n"
  644.         << "   static void _create_comps(" << cn;
  645.       if (create_params != NO_OBJECT)
  646.      params_out (out_I, create_params, /* no_param_names */ FALSE,
  647.              /*impl*/ FALSE, /*actual*/ FALSE, /*is_first*/ FALSE);
  648.       out_I << ");\n"
  649.         << "public:\n";
  650.  
  651.       out_c << "void " << _ID << cn << "::_create_comps(" << cn << " _x";
  652.       if (create_params != NO_OBJECT)
  653.      params_out (out_c, create_params, /* no_param_names */ FALSE,
  654.              /*impl*/ TRUE, /*actual*/ FALSE, /*is_first*/ FALSE);
  655.       out_c << "){\n   ";
  656.  
  657.       agg_iterate (ml, sos_Method m)
  658.       {  sos_Comp_method cm = sos_Comp_method::make (m);
  659.      if (cm.get_is_set())
  660.      {  sos_Expr e = cm.get_init_expr();
  661.         if (e != NO_OBJECT)
  662.         {  out_c << "   _x." << cm.get_name() << "(";
  663.            if (e.has_type (sos_Identifier_type))
  664.               if (smg_String (sos_Identifier::make (e).get_id()).
  665.               equal ("NO_OBJECT"))
  666.              out_c << cm.get_params().get_nth(1).get_type_name()
  667.                << "::make(NO_OBJECT)";
  668.      
  669.               else
  670.              out_c << e;
  671.            else
  672.           out_c << e;
  673.            out_c << ");\n";
  674.         }
  675.      }
  676.       }
  677.       agg_iterate_end (ml, m);
  678.       out_c << "}\n";
  679.    }
  680.  
  681.    // _copy
  682.    out_I << "   void _copy(sos_Typed_id&," << cn << ");\n";
  683.  
  684.    out_c << "void " << _ID << cn << "::_copy(sos_Typed_id&_tpid,"
  685.      << cn << " y){\n"
  686.      << "   " << cn << " x=" << cn << "::make(_tpid,this);\n";
  687.  
  688.    agg_iterate (super_closure, sos_Super_class sc)
  689.    {  sos_Class_type sct = sc.get_super_class();
  690.       if (sct.get_has_init_comps())
  691.       {  sos_Expr_List cpl = sc.get_create_params();
  692.  
  693.      out_c << _ID << sct.make_root_type() << "::_copy_comps(x,y);\n";
  694.       }
  695.    }
  696.    agg_iterate_end (super_closure, sc);
  697.  
  698.    str = smg_String ("local_initialize").make_String (TEMP_CONTAINER);
  699.    agg_iterate (super_closure, sos_Super_class sc)
  700.    {  sos_Class_type sct = sc.get_super_class();
  701.  
  702.       if (sct.get_inherited_methods() [str] != NO_OBJECT)
  703.       {  out_c << _ID << sct.make_root_type()
  704.            << "::local_initialize(x);\n";
  705.       }
  706.    }
  707.    agg_iterate_end (super_closure, sc);
  708.    str.destroy();
  709.  
  710.    out_c << "}\n";
  711.  
  712.    // _copy_comps
  713.    if (ct.get_has_init_comps())
  714.    {  sos_Method_List ml = ct.get_comp_methods();
  715.  
  716.       out_I << "protected:\n"
  717.         << "   static void _copy_comps(" << cn << "," << cn << ");\n"
  718.         << "public:\n";
  719.  
  720.       out_c << "void " << _ID << cn << "::_copy_comps("
  721.         << cn << " x," << cn << " y){\n";
  722.  
  723.       agg_iterate (ml, sos_Method m)
  724.       {  sos_Comp_method cm = sos_Comp_method::make (m);
  725.      if (cm.get_is_set())
  726.      {  sos_Expr e = cm.get_init_expr();
  727.         if (e != NO_OBJECT)
  728.         {  sos_Cstring mn = cm.get_name().make_Cstring();
  729.            out_c << "   x." << mn << "(y.";
  730.            mn[0] = 'g';
  731.            out_c << mn << "());\n";
  732.            delete mn;
  733.         }
  734.      }
  735.       }
  736.       agg_iterate_end (ml, m);
  737.       out_c << "}\n";
  738.    }
  739.  
  740.    // _clone
  741.    out_I << "   virtual sos_Object _clone(sos_Typed_id&,sos_Container);\n";
  742.  
  743.    out_c << "sos_Object " << _ID << cn
  744.         << "::_clone(sos_Typed_id&_tpid,sos_Container cnt){\n"
  745.      << "   " << cn << " _x=" << cn << "::make(_tpid,this);\n"
  746.      << "   return " << cn << "::copy(_x,cnt);}\n";
  747.  
  748.    // destroy
  749.    out_I << "   virtual void destroy(sos_Typed_id&);\n";
  750.  
  751.    out_c << "void " << _ID << cn << "::destroy(sos_Typed_id&_tpid){\n";
  752.  
  753.    str = smg_String ("local_finalize").make_String (TEMP_CONTAINER);
  754.    agg_iterate_reverse (super_closure, sos_Super_class sc)
  755.    {  sos_Class_type sct = sc.get_super_class();
  756.  
  757.       if (sct.get_inherited_methods() [str] != NO_OBJECT)
  758.       {  sos_Type_name stn = sct.make_root_type();
  759.      out_c << "   " << _ID << stn
  760.            << "::local_finalize(" << stn << "::make(_tpid,this));\n";
  761.       }
  762.    }
  763.    agg_iterate_reverse_end (super_closure, sc);
  764.    str.destroy();
  765.  
  766.    out_c << "   _tpid.container().deallocate(_tpid.offset(),"
  767.      << ct.get_object_size() << ");}\n";
  768.  
  769.    // assign
  770.    out_I << "   virtual void assign(sos_Typed_id&,sos_Object);\n";
  771.  
  772.    out_c << "void " << _ID << cn
  773.          << "::assign(sos_Typed_id&_tpid,sos_Object o){\n   "
  774.      << cn << " x=" << cn << "::make(_tpid,this);\n";
  775.  
  776.    str = smg_String ("total_assign").make_String (TEMP_CONTAINER);
  777.    total_closure = remove_redefined_locals (super_closure, str, removed);
  778.    agg_iterate (total_closure, sos_Super_class sc)
  779.    {  sos_Class_type sct = sc.get_super_class().root_class();
  780.       out_c << "   " << _ID << sct.make_type_name() << "::";
  781.       if (removed AND sct.get_inherited_methods()[str] != NO_OBJECT)
  782.      out_c << "total";
  783.       else
  784.      out_c << "local";
  785.       out_c << "_assign(x,o);\n";
  786.    }
  787.    agg_iterate_end (total_closure, sc);
  788.    out_c << "}\n";
  789.    str.destroy();
  790.    total_closure.destroy();
  791.  
  792.    str = smg_String ("local_assign").make_String (TEMP_CONTAINER);
  793.    if (NOT defines_method (ct, str))
  794.    {  out_I << "   static void local_assign(" << cn << ",sos_Object);\n";
  795.  
  796.       out_c << "void " << _ID << cn << "::local_assign(" << cn
  797.         << " x,sos_Object o){\n";
  798.       if (ct.get_local_size() > 0)
  799.       {  out_c << "   " << cn << " y=" << cn << "::make(o);\n"
  800.            << "   y.container().copy(y.offset()+y._ref->_offset_" << cn
  801.            << "()," << ct.get_local_size()
  802.            << ",x.container(),x.offset()+x._ref->_offset_" << cn << "());";
  803.       }
  804.       out_c << "}\n";
  805.    }
  806.    str.destroy();
  807.  
  808.    // equal
  809.    out_I << "   virtual sos_Bool equal(sos_Typed_id&,sos_Object,sos_Eq_kind=EQ_STRONG);\n";
  810.  
  811.    out_c << "sos_Bool " << _ID << cn
  812.         << "::equal(sos_Typed_id&_tpid,sos_Object o,sos_Eq_kind eq_kind){\n   "
  813.      << cn << " x=" << cn << "::make(_tpid,this);\n";
  814.  
  815.    str = smg_String ("total_equal").make_String (TEMP_CONTAINER);
  816.    total_closure = remove_redefined_locals (super_closure, str, removed);
  817.    agg_iterate (total_closure, sos_Super_class sc)
  818.    {  sos_Class_type sct = sc.get_super_class().root_class();
  819.       out_c << "   if (! " << _ID << sct.make_type_name() << "::";
  820.       if (removed AND sct.get_inherited_methods()[str] != NO_OBJECT)
  821.      out_c << "total";
  822.       else
  823.      out_c << "local";
  824.       out_c << "_equal(x,o,eq_kind)) return FALSE;\n";
  825.    }
  826.    agg_iterate_end (total_closure, sc);
  827.    out_c << "   return TRUE;}\n";
  828.    str.destroy();
  829.    total_closure.destroy();
  830.  
  831.    str = smg_String ("local_equal").make_String (TEMP_CONTAINER);
  832.    if (NOT defines_method (ct, str))
  833.    {  out_I << "   static sos_Bool local_equal(" << cn << ",sos_Object,sos_Eq_kind);\n";
  834.  
  835.       out_c << "sos_Bool " << _ID << cn << "::local_equal(" << cn;
  836.  
  837.       if (ct.get_local_size() > 0)
  838.       {  sos_Bool is_generic_class = (sos_Bool)
  839.                            (ct.get_gen_params() != NO_OBJECT);
  840.          out_c << " x,sos_Object o,sos_Eq_kind eq_kind){\n"
  841.            << "   if (eq_kind==EQ_STRONG) {if (!o.has_type(";
  842.      
  843.      if (is_generic_class)
  844.         out_c << "x.type()";
  845.      else
  846.         out_c << cn << "_type";
  847.  
  848.      out_c << ")) return FALSE;}\n   else if (!o.isa(";
  849.  
  850.      if (is_generic_class)
  851.         out_c << "x.type()";
  852.      else
  853.         out_c << cn << "_type";
  854.  
  855.      out_c << ")) return FALSE;\n"
  856.            << "   " << cn << " y=" << cn << "::make(o);\n"
  857.            << "   return (sos_Bool)x.container().equal("
  858.            << "x.offset()+x._ref->_offset_" << cn << "()," 
  859.            << ct.get_local_size()
  860.            << ",y.container(),y.offset()+y._ref->_offset_" << cn << "());";
  861.       }
  862.       else
  863.      out_c << ",sos_Object,sos_Eq_kind) { return TRUE;";
  864.       out_c << "}\n";
  865.    }
  866.    str.destroy();
  867.  
  868.    // hash_value
  869.    out_I << "   virtual sos_Int hash_value(sos_Typed_id&);\n";
  870.  
  871.    out_c << "sos_Int " << _ID << cn << "::hash_value(sos_Typed_id&_tpid){\n   "
  872.      << cn << " x=" << cn << "::make(_tpid,this);\n   sos_Int result=0;\n";
  873.  
  874.    str = smg_String ("total_hash_value").make_String (TEMP_CONTAINER);
  875.    total_closure = remove_redefined_locals (super_closure, str, removed);
  876.    agg_iterate (total_closure, sos_Super_class sc)
  877.    {  sos_Class_type sct = sc.get_super_class().root_class();
  878.       out_c << "   result ^= " << _ID << sct.make_type_name() << "::";
  879.       if (removed AND sct.get_inherited_methods()[str] != NO_OBJECT)
  880.      out_c << "total";
  881.       else
  882.      out_c << "local";
  883.       out_c << "_hash_value(x);\n";
  884.    }
  885.    agg_iterate_end (total_closure, sc);
  886.    out_c << "   return result;}\n";
  887.    str.destroy();
  888.    total_closure.destroy();
  889.  
  890.    str = smg_String ("local_hash_value").make_String (TEMP_CONTAINER);
  891.    if (NOT defines_method (ct, str))
  892.    {  out_I << "   static sos_Int local_hash_value(" << cn << ");\n";
  893.  
  894.       out_c << "sos_Int " << _ID << cn << "::local_hash_value(" << cn << " x){\n"
  895.         << "   return x.container().hash_value(x.offset()+x._ref->_offset_"
  896.         << cn << "()," << ct.get_local_size() << ");}\n";
  897.    }
  898.    str.destroy();
  899.  
  900.    TT (genCC_H, T_LEAVE);
  901. }
  902.  
  903. static void id_methods_out (sos_Class_type ct, sos_Method_List ml)
  904. {
  905.    T_PROC ("id_methods_out");
  906.    TT (genCC_H, T_ENTER);
  907.  
  908.    agg_iterate (ml, sos_Method m1)
  909.    {  sos_Method m = m1.get_generated_from();
  910.       if (m == NO_OBJECT) m = m1;
  911.  
  912.       sos_Method_kind mk = m.get_kind();
  913.       if (mk != id_method_kind)
  914.       {  id_method_kind = mk;
  915.      out_I << id_method_kind << ":\n";
  916.       }
  917.  
  918.       if (m.has_type (sos_Comp_method_type))
  919.      id_comp_method_out (ct, sos_Comp_method::make (m));
  920.       else
  921.      id_method_out (ct, m);
  922.    }
  923.    agg_iterate_end (ml, m);
  924.    TT (genCC_H, T_LEAVE);
  925. }
  926.  
  927. static void id_method_out (sos_Class_type, sos_Method m)
  928. { 
  929.    T_PROC ("id_method_out");
  930.    TT (genCC_H, T_ENTER);
  931.  
  932.    sos_String     cn;
  933.    sos_String      mn          = m.get_name();
  934.    sos_Param_List params      = m.get_params();
  935.    sos_Type_name  result_type = m.get_result_type();
  936.    sos_Bool      is_abstract = m.get_is_abstract();
  937.    sos_Bool      is_static   = m.get_is_static();
  938.    sos_Bool      is_operator = m.get_is_operator();
  939.  
  940.    TT(genCC_L, TsS (mn));
  941.  
  942.    if (NOT m.get_is_predefined())
  943.    {  if (is_static)
  944.      out_I << "   static ";
  945.       else
  946.      out_I << "   virtual ";
  947.  
  948.       if (is_operator)
  949.          mn = cci_Method_impl::operator_string (mn);
  950.  
  951.       out_I << result_type << " " << mn << "(";
  952.       if (is_abstract)
  953.       {  
  954.      cn = m.get_defined_in().make_root_type().make_type_name();
  955.      out_c << result_type << " "
  956.            << _ID << cn << "::" << mn << "(";
  957.       }
  958.  
  959.       sos_Bool is_first;
  960.       if (is_static)
  961.      is_first = TRUE;
  962.       else
  963.       {  is_first = FALSE;
  964.      out_I << "sos_Typed_id&";
  965.      if (is_abstract)
  966.         out_c << "sos_Typed_id&";
  967.       }
  968.  
  969.       params_out (out_I, params, /* no_param_names */ FALSE, 
  970.           /*impl*/ FALSE, /*actual*/ FALSE, is_first); 
  971.       out_I << ");\n";
  972.  
  973.       if (is_abstract)
  974.       {
  975.      params_out (out_c, params, /* no_param_names */ TRUE,
  976.              /*impl*/ FALSE, /*actual*/ FALSE, is_first);
  977.      out_c << ") ";
  978.  
  979.      // now create function body
  980.      out_c << "{\n   err_raise_abstract_method (\"" << cn << "::" << mn
  981.            << "\"); ";
  982. #ifdef ATT
  983.      if (result_type.operator!= (get_void_type()))
  984. #else
  985.      if (result_type != get_void_type())
  986. #endif
  987.      {
  988.         out_c << "\n   return ";
  989.         // Now check if result type is scalar type. If so, cast 0 into
  990.         // the according type.
  991.         if (result_type.make_base_type().has_type (sos_Extern_type_type) OR
  992.              result_type.make_base_type().has_type (sos_Enum_type_type))
  993.            out_c << "(" << result_type << ") 0; ";
  994.         else
  995.            out_c << result_type << "::make(NO_OBJECT); ";
  996.      }
  997.      out_c << "}\n";
  998.       }
  999.       if (is_operator)
  1000.      mn.destroy();
  1001.    }
  1002.  
  1003.    TT (genCC_H, T_LEAVE);
  1004. }
  1005.  
  1006. static void id_comp_method_out (sos_Class_type ct, sos_Comp_method cm)
  1007. {  
  1008.    T_PROC ("id_comp_method_out");
  1009.    TT (genCC_H, T_ENTER);
  1010.  
  1011.    sos_String     cn    = ct.make_type_name();
  1012.    sos_String     n    = cm.get_name();
  1013.    sos_Bool     is_set = cm.get_is_set();
  1014.    sos_Type_name tn     = (is_set) ? cm.get_params().get_nth(1).get_type_name()
  1015.                    : cm.get_result_type();
  1016.    sos_Int     size;
  1017.  
  1018.    sos_Schema_type bt = tn.make_base_type ();
  1019.    sos_Bool is_scalar = bt.is_scalar ();
  1020.    sos_Bool is_local  = cm.get_is_local();
  1021.    smg_String ht;
  1022.  
  1023.    if (is_scalar)
  1024.    {  size = bt.get_object_size();
  1025.       ht   = bt.get_name();
  1026.    }
  1027.    else if (is_local)
  1028.    {  size = SOS_OFFSET_SIZE;
  1029.       ht   = "sos_Offset";
  1030.    }
  1031.    else
  1032.    {  size = SOS_TYPED_ID_SIZE;
  1033.       ht   = "sos_Typed_id";
  1034.    }
  1035.    // ???
  1036.    // Added the keywords 'virtual' to set_.../get_... declarations
  1037.    // 15/8/91, Dietmar
  1038.  
  1039.    if (is_set)
  1040.    {  out_I << "   virtual void " << n << "(sos_Typed_id&," << tn << ");\n";
  1041.       out_c << "void " << _ID << cn << "::" << n
  1042.         << "(sos_Typed_id&_tpid," << tn
  1043.         << " a){\n   union {" << ht << " x; char c[" << size << "];} u;\n";
  1044.       if (is_scalar)
  1045.      out_c << "   bcopy_from_" << ht << "(&a,&u);\n";
  1046.       else if (is_local)
  1047.      out_c << "   " << ht << " x=sos_local_offset(a,_tpid.container());\n"
  1048.            << "   bcopy_from_" << ht << "(&x,&u);\n";
  1049.       else
  1050.      out_c << "   " << ht << " x=a.typed_id();\n"
  1051.            << "   bcopy_from_" << ht << "(&x,&u);\n";
  1052.       out_c << "   _tpid.container().write(_tpid.offset() + _offset_" << cn
  1053.         << "() + " << cm.get_offset() << "," << size << ",&u);\n}\n";
  1054.    }
  1055.    else
  1056.    {  out_I << "   virtual " << tn << " " << n << "(sos_Typed_id&);\n";
  1057.  
  1058.       out_c << tn << " " << _ID << cn << "::" << n
  1059.         << "(sos_Typed_id&_tpid)\n"
  1060.         << "{  union {" << ht << " x; char c[" << size << "];} u; "
  1061.         << ht << " a;\n"
  1062.         << "   _tpid.container().read(_tpid.offset()+_offset_" << cn
  1063.         << "()+" << cm.get_offset() << "," << size << ",&u);\n"
  1064.         << "   bcopy_to_" << ht << "(&a,&u);\n";
  1065.       if (is_scalar)
  1066.      out_c << "   return a;"; 
  1067.       else if (is_local)
  1068.      out_c << "   return " << bt.make_type_name()
  1069.            << "::make(sos_make_local_typed_id(a,_tpid.container()));";
  1070.       else
  1071.      out_c << "   return " << bt.make_type_name() << "::make(a);";
  1072.       out_c << "}\n"; 
  1073.    }
  1074.  
  1075.    TT (genCC_H, T_LEAVE);
  1076. }
  1077.  
  1078. static void id_univ_method_out (sos_Class_type ct,
  1079.                 sos_Method     m,
  1080.                 sos_Bool       is_static)
  1081. // modified: 13.08.91 (bs)
  1082. // to avoid the effects of a GNU (1.37 & 1.39) compiler error
  1083. {
  1084.    T_PROC ("id_univ_method_out");
  1085.    TT (genCC_H, T_ENTER);
  1086.  
  1087.    sos_String     cn          = ct.make_type_name();
  1088.    sos_String     mn          = m.get_name();
  1089.    sos_Param_List params      = m.get_params();
  1090.    sos_Type_name  result_type = m.get_result_type();
  1091.    sos_Bool       is_operator = m.get_is_operator();
  1092.    sos_Int        card        = params.card();
  1093.  
  1094. #ifdef ATT
  1095.    sos_Bool is_void_result = result_type.operator==(get_void_type());
  1096. #else
  1097.    sos_Bool is_void_result = result_type == get_void_type();
  1098. #endif
  1099.                                               // out Header
  1100.    out_c << "static sos_Object _univ_"
  1101.         << cci_Method_impl::make_impl (m).typed_id()
  1102.         << "(sos_Object";
  1103.    
  1104.    if (NOT is_static)
  1105.       out_c << " o";
  1106.   
  1107.    out_c << ",sos_Object_Array";
  1108.    if (params.card() > 0)
  1109.       out_c << " p";
  1110.  
  1111.    out_c << "){\n   ";                        // out Implementation
  1112.  
  1113.    sos_Int ref_params = 0;
  1114.  
  1115.    if (card > 0)
  1116.    {
  1117.       out_c << "sos_Object ";
  1118.       for (sos_Int j=1; j <= card; j++)
  1119.       { 
  1120.         if (params.get_nth(j).get_is_ref())
  1121.        ref_params++;
  1122.         out_c << "o" << j << "=p[" << j-1;
  1123.            // The storing of the value of 'p' would only
  1124.            // be necessary for parameters passed by reference.
  1125.            // It is done here for all parameters, to avoid a 
  1126.            // GNU(1.39) compiler error. (bs)
  1127.          if (j < card)
  1128.             out_c << "], ";
  1129.          else
  1130.             out_c << "];\n   ";
  1131.       }
  1132.    }
  1133.    TT (genCC_L, TXT ("No. of reference parameters"); TI(ref_params));
  1134.  
  1135.    if (NOT is_void_result)
  1136.    {  
  1137.       if (ref_params NEQ 0) // (bs)
  1138.      out_c << "sos_Object r=";
  1139.       else
  1140.          out_c << "return ";
  1141.       
  1142.       if (result_type.make_type().is_scalar())
  1143.          out_c << "::make_" << result_type << "_object";
  1144.       else
  1145.       {
  1146. #ifdef ATT
  1147.          if (result_type.make_type().operator!= (sos_Object_type))
  1148. #else
  1149.          if (result_type.make_type() != sos_Object_type) // (bs)
  1150. #endif
  1151.             out_c << "sos_Object::make";
  1152.       }
  1153.       out_c << "(";
  1154.    }  
  1155.  
  1156.    if (is_static)
  1157.       out_c << cn << "::";
  1158.    else
  1159.       out_c << cn << "::make (o).";
  1160.    if (is_operator)
  1161.       out_c << "operator";
  1162.  
  1163.    out_c << mn << "(";
  1164.  
  1165.    sos_Bool first = TRUE;
  1166.  
  1167.    for (sos_Int i=1; i<=card; i++)
  1168.    {  sos_Param       p   = params.get_nth(i);
  1169.       sos_Schema_type pt  = p.get_type_name().make_base_type();
  1170.       sos_String      ptn = pt.make_type_name();
  1171.  
  1172.       if (NOT first)
  1173.      out_c << ",";
  1174.       else
  1175.      first = FALSE;
  1176.  
  1177.       if (pt.is_scalar ())
  1178.      out_c << "::make_" << ptn;
  1179.       else
  1180.      out_c << ptn << "::make";
  1181.          out_c << "(o" << i << ")"; 
  1182.       // out_c << "(p[" << i-1 << "])"; replaced 13.08.91 (bs)
  1183.    }
  1184.    out_c << ")";
  1185.  
  1186.    if (NOT is_void_result)
  1187.       out_c << ")";
  1188.  
  1189.    if (ref_params NEQ 0)
  1190.    {
  1191.       out_c << ";\n   ";
  1192.       sos_Int done_ref_params = 0;
  1193.       for (sos_Int k = 1; k <= card; k++)  // write back reference params
  1194.       { 
  1195.         if (params.get_nth(k).get_is_ref())
  1196.         {
  1197.            out_c << "p.set_nth(" << k-1 << ",o" << k << ")";
  1198.        done_ref_params++;
  1199.            if (done_ref_params NEQ ref_params)
  1200.           out_c << "; ";
  1201.         }
  1202.       }
  1203.    }
  1204.  
  1205.    if (is_void_result)
  1206.       out_c << ";\n   return NO_OBJECT";
  1207.    else
  1208.       if (ref_params NEQ 0)
  1209.          out_c << ";\n   return r";
  1210.  
  1211.    out_c << ";}\n";
  1212.  
  1213.    TT (genCC_H, T_LEAVE);
  1214. }
  1215.  
  1216.  
  1217. static void id_univ_methods_out (sos_Class_type   ct,
  1218.                  sos_Method_List  ml,
  1219.                  Method_class     mc,
  1220.                  sos_Bool         only_predefined)
  1221. {
  1222.    T_PROC ("id_univ_methods_out");
  1223.    TT (genCC_H, T_ENTER; TB (only_predefined));
  1224.  
  1225.    sos_String cn = ct.make_type_name();
  1226.  
  1227.    agg_iterate (ml, sos_Method m)
  1228.    {  if (m.get_kind() == sos_PUBLIC AND
  1229.       (NOT only_predefined OR m.get_is_predefined()))
  1230.      id_univ_method_out (ct, m, (sos_Bool)(mc == MC_STATIC));
  1231.    }
  1232.    agg_iterate_end (ml, m);
  1233.    sos_Typed_id tpid = ct.typed_id();
  1234.  
  1235.    out_c << "static void _init_";
  1236.    switch (mc)
  1237.    {  case MC_REGULAR: out_c << "meth_";  break;
  1238.       case MC_COMP:    out_c << "comp_";  break;
  1239.       case MC_STATIC:  out_c << "stat_";  break;
  1240.    }
  1241.    out_c << tpid << "(){\n";
  1242.  
  1243.    if (NOT only_predefined)
  1244.    {  agg_iterate (ml, sos_Method m)
  1245.       {  sos_Typed_id mtpid = cci_Method_impl::make_impl (m).typed_id();
  1246.      if (m.get_kind() == sos_PUBLIC AND
  1247.          (NOT only_predefined OR m.get_is_predefined()))
  1248.         out_c << "   " << CCI
  1249.               << "::enter_fun(sos_Id::make(sos_Container::make("
  1250.               << sos_Int(mtpid.container()) << "),"
  1251.               << mtpid.offset() << "),(cci_Fun)_univ_" << mtpid << ");\n";
  1252.       }
  1253.       agg_iterate_end (ml, m);
  1254.    }
  1255.  
  1256.    out_c << "}\n";
  1257.  
  1258.    TT (genCC_H, T_LEAVE);
  1259. }
  1260.  
  1261. static void class_out (sos_Class_type ct, sos_Super_class_List super_closure) 
  1262. {
  1263.    T_PROC ("class_out");
  1264.    TT (genCC_H, T_ENTER);
  1265.  
  1266.    sos_String cn = ct.make_type_name();
  1267.    sos_Type_name rtn = ct.make_root_type();
  1268.  
  1269.    init_out (ct, super_closure);
  1270.  
  1271.    out_h << "class " << cn << ": public sos_Root_class \n"
  1272.      << "{  friend class " << _ID << rtn << ";\n"
  1273.      << "   class " << _ID << rtn << "* " << "_ref;\n";
  1274.  
  1275.    // conversion to super classes
  1276.    out_h << "public:\n";
  1277.    agg_iterate (super_closure, sos_Super_class sc)
  1278.    {  sos_Class_type sct = sc.get_super_class();
  1279. #ifdef ATT
  1280.       if (ct.operator!=(sct))
  1281. #else
  1282.       if (ct != sct)
  1283. #endif
  1284.       {  sos_String scn = sct.make_type_name();
  1285.      out_h << "   operator " << scn << " ()";
  1286.      if (gen_inline)
  1287.         out_h << "{return(" << scn << "::make(_tpid,_ref));}";
  1288.      else
  1289.         out_c << cn << "::operator " << scn << "()"
  1290.           << "{return(" << scn << "::make(_tpid,_ref));}\n";
  1291.      out_h << ";\n";
  1292.       }
  1293.       if (NOT is_root_type (sct))
  1294.       {  sos_Type_name scrtn = sct.make_root_type();
  1295.  
  1296.      out_h << "   operator " << scrtn << " ()";
  1297.      if (gen_inline)
  1298.         out_h << "{return(" << scrtn << "::make(_tpid,_ref));}";
  1299.      else
  1300.         out_c << cn << "::operator " << scrtn << "()"
  1301.           << "{return(" << scrtn << "::make(_tpid,_ref));}\n";
  1302.      out_h << ";\n";
  1303.       }
  1304.    }
  1305.    agg_iterate_end (super_closure, sc);
  1306.  
  1307.    friends_out (ct);
  1308.  
  1309.    method_kind = sos_PUBLIC;
  1310.    cc_methods_out (ct);
  1311.    ccc_methods_out (ct);
  1312.    inherited_methods_out (ct);
  1313.    out_h << "};\n";
  1314.  
  1315.    TT (genCC_H, T_LEAVE);
  1316. }
  1317.  
  1318. static void init_out (sos_Class_type ct, sos_Super_class_List super_closure) 
  1319. {
  1320.    T_PROC ("init_out");
  1321.    TT (genCC_H, T_ENTER);
  1322.  
  1323.    sos_String cn = ct.make_type_name();
  1324.    sos_Type_name gtn = ct.make_root_type();
  1325.    sos_Typed_id tpid = ct.typed_id();
  1326.  
  1327.    out_c << "static void _init_new_" << tpid << "(){\n";
  1328.    agg_iterate (super_closure, sos_Super_class sc)
  1329.    {  sos_Type_name sgtn = sc.get_super_class().make_root_type();
  1330.  
  1331.       out_c << "   " << CCI << "::enter_make_obj("
  1332.             << _ID << sgtn << "_type,"
  1333.             << _ID << cn << "_type,("
  1334.         << _ID << sgtn << "*)_" << _ID << gtn << "_obj);\n";
  1335.    }
  1336.    agg_iterate_end (super_closure, sc)
  1337.    out_c << "}\n";
  1338.  
  1339.    TT (genCC_H, T_LEAVE);
  1340. }
  1341.  
  1342. static void friends_out (sos_Class_type ct)
  1343. {
  1344.    T_PROC ("friends_out");
  1345.    TT (genCC_H, T_ENTER);
  1346.  
  1347.    sos_Type_name_List tnl = ct.get_friends();
  1348.    agg_iterate (tnl, sos_Type_name tn)
  1349.    {  out_h << "   friend class " << _ID << tn.make_type_name()  << ";\n";
  1350.    }
  1351.    agg_iterate_end (tnl, tn);
  1352.  
  1353.    TT (genCC_H, T_LEAVE);
  1354. }
  1355.  
  1356. static void ccc_methods_out (sos_Class_type ct)
  1357. {
  1358.    T_PROC ("ccc_method_out");
  1359.    TT (genCC_H, T_ENTER);
  1360.  
  1361.    sos_Param_List create_params = ct.get_create_params();
  1362.    sos_String cn = ct.make_type_name();
  1363.    sos_Type_name rtn = ct.make_root_type();
  1364.  
  1365.    // create
  1366.    out_h << "   static " << cn << " create(sos_Container";
  1367.    if (create_params != NO_OBJECT)
  1368.       params_out (out_h, create_params, /* no_param_names */ FALSE, 
  1369.               /*impl*/ FALSE, /*actual*/ FALSE, /*is_first*/ FALSE);
  1370.    out_h << ");\n";
  1371.  
  1372.    out_c << cn << " " << cn << "::create(sos_Container _cnt";
  1373.    if (create_params != NO_OBJECT)
  1374.       params_out (out_c, create_params, /* no_param_names */ FALSE, 
  1375.               /*impl*/ TRUE, /*actual*/ FALSE, /*is_first*/ FALSE);
  1376.    out_c << "){\n"
  1377.      << "   " << cn << " _x=" << cn
  1378.      << "::make(sos_Typed_id::allocate(" << cn << "_type,_cnt,"
  1379.      << ct.get_object_size() << "));\n"
  1380.      << "   _x._ref->_create(_x._tpid";
  1381.    if (create_params != NO_OBJECT)
  1382.       params_out (out_c, create_params, /* no_param_names */ FALSE, 
  1383.               /*impl*/ TRUE, /*actual*/ TRUE, /*is_first*/ FALSE);
  1384.    out_c << ");\n"
  1385.      << "   return _x;\n}\n";
  1386.  
  1387.    // copy
  1388.    out_h << "   static " << cn << " copy(" << cn << ",sos_Container);\n";
  1389.    out_c << cn << " " << cn << "::copy(" << cn << " y,sos_Container cnt){\n   "
  1390.      << cn << " x=" << cn
  1391.      << "::make(sos_Typed_id::allocate(" << cn << "_type,cnt,"
  1392.      << ct.get_object_size() << "));\n"
  1393.      << "   x._ref->_copy(x._tpid,y);\n   x.assign(y);\n   return x;\n}\n";
  1394.  
  1395.    // clone
  1396.    out_h << "   static " << cn << " clone(" << cn << ",sos_Container);\n";
  1397.    out_c << cn << " " << cn << "::clone(" << cn << " o,sos_Container cnt){\n"
  1398.      << "   return " << cn << "::make (o._ref->_clone(o._tpid,cnt));\n}\n";
  1399.  
  1400.    TT (genCC_H, T_LEAVE);
  1401. }
  1402.  
  1403. static void cc_methods_out (sos_Class_type ct)
  1404. {
  1405.    T_PROC ("cc_methods_out");
  1406.    TT (genCC_H, T_ENTER);
  1407.  
  1408.    sos_String cn = ct.make_type_name();
  1409.    sos_Type_name rtn = ct.make_root_type();
  1410.  
  1411.  
  1412.    // composition
  1413.  
  1414.    out_h << "   static " << cn << " make(sos_Typed_id&);\n";
  1415.    out_c << cn << " " << cn << "::make(sos_Typed_id&p){\n   "
  1416.      << cn << " o; o._tpid=p;\n   "
  1417.      << "o._ref=" << _ID << rtn << "::_make(p); return o;}\n";
  1418.  
  1419.    out_h << "   static " << cn << " make(sos_Typed_id&p,"
  1420.         << _ID << rtn << "*r){\n   "
  1421.      << cn << " o; o._tpid = p; o._ref=r; return o;}\n";
  1422.  
  1423.    // make
  1424.    out_h << "   static " << cn << " make(sos_Root_class&);\n";
  1425.    out_c << cn << " " << cn << "::make(sos_Root_class& o)" 
  1426.          << "{return " << cn << "::make(o.typed_id());}\n";
  1427.  
  1428.    // _size
  1429.    out_h << "   sos_Offset _size();\n";
  1430.    out_c << "   sos_Offset " << cn << "::_size(){return _ref->_size();}\n";
  1431.  
  1432.    TT (genCC_H, T_LEAVE);
  1433. }
  1434.  
  1435. static void inherited_methods_out (sos_Class_type ct)
  1436. {
  1437.    T_PROC ("inherited_methods_out");
  1438.    TT (genCC_H, T_ENTER);
  1439.  
  1440.    sos_Method_table mt = ct.get_inherited_methods();
  1441.    sos_Bool is_root = is_root_type (ct);
  1442.  
  1443.    agg_iterate_association (mt, sos_String name, sos_Method_List ml)
  1444.    {  agg_iterate (ml, sos_Method m)
  1445.       {  sos_Method_kind mk = m.get_kind();
  1446.      if ((is_root OR mk == sos_PUBLIC) AND NOT is_ccc_method (m))
  1447.      {  if (mk != method_kind)
  1448.         {  method_kind = mk;
  1449.            out_h << method_kind << ":\n";
  1450.         }
  1451.         method_out (ct, m);
  1452.      }
  1453.       }
  1454.       agg_iterate_end (ml, m);
  1455.    }
  1456.    agg_iterate_association_end (mt, name, ml);
  1457.  
  1458.    TT (genCC_H, T_LEAVE);
  1459. }
  1460.  
  1461. void method_out (sos_Class_type ct, sos_Method m)
  1462. {
  1463.    sos_String cn = ct.make_type_name();
  1464.    sos_String mn = m.get_name();
  1465.    sos_Type_name rtn = m.get_result_type();
  1466.    sos_Param_List params = m.get_params();
  1467.    sos_Bool is_static = m.get_is_static();
  1468.    sos_Bool is_operator = m.get_is_operator();
  1469.    sos_Type_name gtn = ct.make_root_type();
  1470.    sos_Method gm = m.get_generated_from();
  1471.    sos_Bool is_generated = gm != NO_OBJECT;
  1472.  
  1473.    if (is_static)
  1474.       out_h << "   static ";
  1475.    else
  1476.       out_h << "   ";
  1477.    out_h << rtn << " ";
  1478.    if (is_operator)
  1479.       out_h << "operator";
  1480.    out_h << mn << "(";
  1481.    params_out (out_h, params, /* no_param_names */ FALSE, 
  1482.            /*impl*/ FALSE, /*actual*/ FALSE); out_h << ");\n";
  1483.  
  1484.    out_c << rtn << " " << cn << "::";
  1485.    if (is_operator)
  1486.       out_c << "operator";
  1487.    out_c << mn << "(";
  1488.    params_out (out_c, params, /* no_param_names */ FALSE, 
  1489.            /*impl*/ TRUE, /*actual*/FALSE); out_c << ")";
  1490.  
  1491.    out_c << "{";
  1492. #ifdef ATT
  1493.    if (rtn.operator!=(get_void_type()))
  1494. #else
  1495.    if (rtn != get_void_type())
  1496. #endif
  1497.    {  out_c << "return ";
  1498.       if (is_generated)
  1499.      type_conversion_out (out_c, gm.get_result_type(), rtn, TRUE);
  1500.    }
  1501.    out_c << "(";
  1502.  
  1503.    if (is_static)
  1504.       out_c << _ID << gtn << "::";
  1505.    else
  1506.       out_c << "_ref->";
  1507.  
  1508.    if (is_operator)
  1509.    {  sos_String on = cci_Method_impl::operator_string (mn);
  1510.       out_c << on;
  1511.       on.destroy();
  1512.    }
  1513.    else
  1514.       out_c << mn;
  1515.    out_c << "(";
  1516.  
  1517.    sos_Bool is_first;
  1518.    if (is_static)
  1519.       is_first = TRUE;
  1520.    else
  1521.    {  is_first = FALSE;
  1522.       out_c << "_tpid";
  1523.    }
  1524.  
  1525.    if (is_generated)
  1526.       params_and_type_conversion_out
  1527.      (out_c, gm.get_params(), params, is_first);
  1528.    else
  1529.       params_out (out_c, params, /* no_param_names */ FALSE,
  1530.           /*impl*/ TRUE, /*actual*/ TRUE, is_first);
  1531.    out_c << "));}\n";
  1532. }
  1533.  
  1534. static void type_conversion_out (ostream& out_f,
  1535.                  sos_Type_name generic_tn,
  1536.                  sos_Type_name replaced_tn,
  1537.                  sos_Bool from_gen)
  1538. {
  1539.    T_PROC ("type_conversion_out");
  1540.    TT (genCC_H, T_ENTER);
  1541.  
  1542.    sos_Type gt = generic_tn.make_type();
  1543.    sos_Type rt = replaced_tn.make_type();
  1544.  
  1545.    if (NOT gt.equal (rt))
  1546.    {  if (from_gen)
  1547.       {  if (is_generic_parameter (generic_tn))
  1548.         if (rt.is_scalar ())
  1549.            out_f << "::make_" << replaced_tn;
  1550.         else
  1551.            out_f << replaced_tn << "::make";
  1552.       }
  1553.       else
  1554.       {  if (is_generic_parameter (generic_tn))
  1555.         if (rt.is_scalar ())
  1556.            out_f << "::make_" << replaced_tn << "_object";
  1557.         else
  1558.         {  
  1559. #ifdef ATT
  1560.            if (rt.is_derived_from (gt) OR rt.root().operator==(gt))
  1561. #else
  1562.            if (rt.is_derived_from (gt) OR rt.root() == gt)
  1563. #endif
  1564.           out_f << generic_tn;
  1565.            else
  1566.           out_f << generic_tn << "::make";
  1567.         }
  1568.       }
  1569.    }
  1570.  
  1571.    TT (genCC_H, T_LEAVE);
  1572. }
  1573.  
  1574. static void params_and_type_conversion_out (ostream& out_f,
  1575.                                             sos_Param_List generic_pl,
  1576.                                             sos_Param_List replaced_pl, 
  1577.                                             sos_Bool first) 
  1578. {
  1579.    T_PROC ("params_and_type_conversion_out");
  1580.    TT (genCC_H, T_ENTER);
  1581.  
  1582.    sos_Int i = 1;
  1583.    agg_iterate_double (generic_pl, sos_Param gen_p,
  1584.                replaced_pl, sos_Param repl_p, sos_Int comp)
  1585.    {  sos_String pn = repl_p.get_name();
  1586.  
  1587.       if (NOT first)
  1588.          out_f << ",";
  1589.       else
  1590.          first = FALSE;
  1591.  
  1592.       type_conversion_out (out_c, gen_p.get_type_name(),
  1593.                            repl_p.get_type_name(), FALSE);
  1594.  
  1595.       if (pn != NO_OBJECT)
  1596.          out_f << "(" << pn << ")";
  1597.       else
  1598.          out_f << "(_p" << i << ")";
  1599.       i++;
  1600.    }
  1601.    agg_iterate_double_end (generic_pl, gen_p, replaced_pl, repl_p, comp);
  1602.    TT (genCC_H, T_LEAVE);
  1603. }
  1604.  
  1605. static void params_out (ostream& out_f,
  1606.             sos_Param_List pl,
  1607.             sos_Bool no_param_names,
  1608.             sos_Bool impl,
  1609.             sos_Bool actual,
  1610.             sos_Bool first,
  1611.             sos_Int start)
  1612. {
  1613.    T_PROC ("params_out");
  1614.    TT (genCC_H, T_ENTER);
  1615.  
  1616.    sos_Int i, c;
  1617.    c = pl.card();
  1618.  
  1619.    for (i=start; i<=c; i++)
  1620.    {  sos_Param p = pl.get_nth(i);
  1621.       sos_String    pn = p.get_name();
  1622.       sos_Type_name tn = p.get_type_name();
  1623.       sos_Expr e = p.get_default_expr();
  1624.  
  1625.       if (NOT first)
  1626.          out_f << ",";
  1627.       else
  1628.          first = FALSE;
  1629.  
  1630.       if (NOT actual)
  1631.       {  out_f << tn;
  1632.          if (p.get_is_ref())
  1633.             out_f << "& ";
  1634.          else
  1635.             out_f << " ";
  1636.       }
  1637.  
  1638.       if (NOT no_param_names)
  1639.       {
  1640.      if (pn != NO_OBJECT)
  1641.         out_f << pn;
  1642.      else
  1643.         out_f << "_p" << i;
  1644.  
  1645.      if (NOT impl AND NOT actual AND e != NO_OBJECT)
  1646.         out_f << " = " << e;
  1647.       }
  1648.    }
  1649.  
  1650.    TT (genCC_H, T_LEAVE);
  1651. }
  1652.  
  1653. static void exprs_out (ostream& out_f, sos_Expr_List el, sos_Bool is_first)
  1654. {
  1655.    T_PROC ("ostream& operator<<");
  1656.    TT (genCC_H, T_ENTER);
  1657.  
  1658.    agg_iterate (el, sos_Expr e)
  1659.    {  if (is_first)
  1660.      is_first = FALSE;
  1661.       else
  1662.          out_f << ",";
  1663.       out_f << e;
  1664.    }
  1665.    agg_iterate_end (el, e);
  1666.  
  1667.    TT (genCC_H, T_LEAVE);
  1668. }
  1669.  
  1670. static ostream& operator<< (ostream& out_f, sos_String_List sl)
  1671. {
  1672.    T_PROC ("ostream& operator<<");
  1673.    TT (genCC_H, T_ENTER);
  1674.  
  1675.    sos_Bool is_first = TRUE;
  1676.    agg_iterate (sl, sos_String s)
  1677.    {  if (is_first)
  1678.      is_first = FALSE;
  1679.       else
  1680.          out_f << ",";
  1681.       out_f << s;
  1682.    }
  1683.    agg_iterate_end (sl, s);
  1684.  
  1685.    TT (genCC_H, T_LEAVE);
  1686.    return out_f;
  1687. }
  1688.  
  1689. static ostream& operator<< (ostream& out_f, sos_Type_name tn)
  1690. {
  1691.    T_PROC ("ostream& operator<<");
  1692.    TT (genCC_H, T_ENTER);
  1693.  
  1694.    err_assert (NOT tn.has_type(sos_String_type), "operator<<");
  1695.  
  1696.    out_f << tn.make_type_name ();
  1697.  
  1698.    TT (genCC_H, T_LEAVE);
  1699.    return out_f;
  1700. }
  1701.  
  1702. static ostream& operator<< (ostream& out_f, sos_Param_List pl)
  1703. {
  1704.    T_PROC ("ostream& operator<<");
  1705.    TT (genCC_H, T_ENTER);
  1706.  
  1707.    sos_Bool is_first = TRUE;
  1708.    agg_iterate (pl, sos_Param p)
  1709.    {  if (is_first)
  1710.      is_first = FALSE;
  1711.       else
  1712.          out_f << ",";
  1713.       out_f << p;
  1714.    }
  1715.    agg_iterate_end (pl, p);
  1716.  
  1717.    TT (genCC_H, T_LEAVE);
  1718.    return (out_f);
  1719. }
  1720.  
  1721. static ostream& operator<< (ostream& out_f, sos_Param p)
  1722. {
  1723.    T_PROC ("ostream& operator<<");
  1724.    TT (genCC_H, T_ENTER);
  1725.  
  1726.    sos_Expr expr = p.get_default_expr();
  1727.    sos_String name = p.get_name();
  1728.  
  1729.    out_f << p.get_type_name();
  1730.    if (name != NO_OBJECT)
  1731.       out_f << " " << name;
  1732.    if (expr != NO_OBJECT)
  1733.       out_f << " = " << expr;
  1734.  
  1735.    TT (genCC_H, T_LEAVE);
  1736.    return (out_f);
  1737. }
  1738.  
  1739. static ostream& operator<< (ostream& out_f, sos_Expr_List el)
  1740. {
  1741.    T_PROC ("ostream& operator<<");
  1742.    TT (genCC_H, T_ENTER);
  1743.  
  1744.    exprs_out (out_f, el, TRUE);
  1745.  
  1746.    TT (genCC_H, T_LEAVE);
  1747.    return (out_f);
  1748. }
  1749.  
  1750. static ostream& operator<< (ostream& out_f, sos_Expr e)
  1751. {
  1752.    T_PROC ("ostream& operator<<");
  1753.    TT (genCC_H, T_ENTER);
  1754.  
  1755.    if (e.has_type(sos_Identifier_type))
  1756.       out_f << sos_Identifier::make(e).get_id();
  1757.    else // e has_type sos_Int_expr_type
  1758.    {  sos_Int_expr i;
  1759.       i = sos_Int_expr::make(e);
  1760.       out_f << i.get_value();
  1761.    }
  1762.  
  1763.    TT (genCC_H, T_LEAVE);
  1764.    return (out_f);
  1765. }
  1766.  
  1767. static ostream& operator<< (ostream& out_f, sos_Typed_id tpid)
  1768. {
  1769.    T_PROC ("ostream& operator<<");
  1770.    TT (genCC_H, T_ENTER);
  1771.  
  1772.    out_f << sos_Int(tpid.container()) << "_" << tpid.offset();
  1773.  
  1774.    TT (genCC_H, T_LEAVE);
  1775.    return (out_f);
  1776. }
  1777.  
  1778. static ostream& operator<< (ostream& out_f, sos_Method_kind mk)
  1779. {
  1780.    T_PROC ("ostream& operator<<");
  1781.    TT (genCC_H, T_ENTER);
  1782.  
  1783.    switch (mk)
  1784.    {  case sos_PRIVATE:        out_f << "private"; break;
  1785.       case sos_PROTECTED:    out_f << "protected"; break;
  1786.       case sos_PUBLIC:        out_f << "public"; break;
  1787.    }
  1788.  
  1789.    TT (genCC_H, T_LEAVE);
  1790.    return (out_f);
  1791. }
  1792.  
  1793. static sos_Bool is_root_type (sos_Type tp)
  1794. {
  1795. #ifdef ATT
  1796.    return tp.operator==(tp.root());
  1797. #else
  1798.    return tp == tp.root();
  1799. #endif
  1800. }
  1801.  
  1802. static sos_Bool is_generic_parameter (sos_Type_name tn)
  1803. {
  1804.    if (tn.has_type(sos_Gen_param_type))
  1805.       return TRUE;
  1806.    else if (tn.has_type(sos_Generic_instantiation_type))
  1807.    {  sos_Type_name_List gpl =
  1808.      sos_Generic_instantiation::make(tn).get_gen_params();
  1809.  
  1810.       sos_Bool is_gen_par = FALSE;
  1811.       agg_iterate (gpl, sos_Type_name gp)
  1812.       {  is_gen_par = is_generic_parameter (gp);
  1813.      if (is_gen_par) break;
  1814.       }       
  1815.       agg_iterate_end (gpl, gp);
  1816.  
  1817.       return (is_gen_par);
  1818.    }
  1819.    else return FALSE;
  1820. }
  1821.  
  1822. static sos_Bool is_ccc_method (sos_Method m)
  1823. {  smg_String mn = m.get_name().make_Cstring();
  1824.    return (sos_Bool) (m.get_is_predefined() AND
  1825.               (mn.equal ("create") OR mn.equal ("copy") 
  1826.                        OR mn.equal ("clone")));
  1827. }
  1828.  
  1829. static sos_Schema_type *the_void_type;
  1830.  
  1831. // *************************************************************************
  1832. sos_Schema_type get_void_type()
  1833. // *************************************************************************
  1834. {
  1835.    T_PROC ("get_void_type");
  1836.    TT (genCC_H, T_ENTER);
  1837.  
  1838.    sos_Schema_type result;
  1839.    if (the_void_type)
  1840.       result = *the_void_type;
  1841.    else
  1842.    {
  1843. #ifdef BOOT
  1844.       result = generated_schema.lookup_type (
  1845.          smg_String ("void").make_String (TEMP_CONTAINER));
  1846. #else
  1847.       result = sos_Schema_type::make (void_type);
  1848. #endif
  1849.       the_void_type  = new sos_Schema_type;
  1850.       *the_void_type = result;
  1851.    }
  1852.  
  1853.    TT (genCC_H, T_LEAVE);
  1854.  
  1855.    return (result);
  1856. }
  1857.  
  1858. static sos_Schema_type *the_scalar_object_type;
  1859.  
  1860. // *************************************************************************
  1861. static sos_Schema_type get_scalar_object_type()
  1862. // *************************************************************************
  1863. {
  1864.    T_PROC ("get_scalar_object_type");
  1865.    TT (genCC_H, T_ENTER);
  1866.  
  1867.    sos_Schema_type result;
  1868.    if (the_scalar_object_type)
  1869.       result = *the_scalar_object_type;
  1870.    else
  1871.    {
  1872. #ifdef BOOT
  1873.       result = generated_schema.lookup_type (
  1874.          smg_String ("sos_Scalar_object").make_String (TEMP_CONTAINER));
  1875. #else
  1876.       result = sos_Schema_type::make (sos_Scalar_object_type);
  1877. #endif
  1878.       the_scalar_object_type  = new sos_Schema_type;
  1879.       *the_scalar_object_type = result;
  1880.    }
  1881.  
  1882.    TT (genCC_H, T_LEAVE);
  1883.  
  1884.    return (result);
  1885. }
  1886.