#include "build.h"



void Instantiation::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Instantiation","void Instantiation::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_names)");
  // prefix class wrappers

   comps->inject_components(inst_path,default_path,comp_names);


  // suffix class wrappers

}

void Comps::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Comps","void Comps::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_names)");
  // prefix class wrappers

     if (comp_paths == NULL)
         comp_paths = new Search_path_Nlist();
     char *default_comp_path = new char[strlen(default_path)+1];
     strcpy(default_comp_path,default_path);
     DemString * s = new DemString(default_comp_path);
     Search_path * p = new Search_path();
     p->set_search_path(s);

     comp_paths->insert(p);


     components->inject_components(inst_path,default_path,comp_paths,comp_names);



  // suffix class wrappers

}

//  Component_inst  = "*component*" 
//                 <component > Component_location 
//                  [ <rename > Rename  ] 
//                  [ <meta_def > Meta_def  ] .
void Component_inst::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Component_inst","void Component_inst::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Search_path_Nlist*  comp_names)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

    component->inject_components(inst_path,default_path,comp_paths,rename,meta_def,comp_names);


  // outgoing calls

  // suffix class wrappers

  // assignments for carrying out
}

//  Component_inst_List  ~  { Component_inst  }. .
void Component_inst_List::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Component_inst_List","void Component_inst_List::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Search_path_Nlist*  comp_names)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  Component_inst_list_iterator	next_Component_inst(*this);
  Component_inst*		each_Component_inst;

  while ( each_Component_inst = next_Component_inst() )
  {
  // repetition edge prefix wrappers
    each_Component_inst->inject_components( inst_path ,  default_path ,  comp_paths ,  comp_names  );
  // repetition edge suffix wrappers
  }

  // suffix class wrappers

  // assignments for carrying out
}

//  Component_name  = <name > DemIdent .
void Component_name::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Rename*  comp_ren,Meta_def*  comp_meta,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Component_name","void Component_name::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Rename*  comp_ren,Meta_def*  comp_meta,Search_path_Nlist*  comp_names)");
  // variables for carrying in and out

  // assignments for carrying in


  // prefix class wrappers

    char cn[MAXDIRLEN+1];
    char cpath[MAXDIRLEN+1];
    char org_n[MAXDIRLEN+1];
    Search_path * cname_obj = new Search_path();
    char * cname = new char[strlen(name->get_val())+1];

    cout << "\n\n";

    strcpy(cname,name->get_val());
    cname_obj->set_search_path(new DemString(cname));
    comp_names->append(cname_obj);

    strcpy(cpath,name->get_val());
    
    cout << toolname << ": searching component " << cpath << " ... " << endl;
    comp_paths->search_path(cpath);
    if (cpath[0] == '\0')
    {
         cerr << toolname << ": error: unable to find component"
              << name->get_val() << endl;
         exit(1);
    }

    sprintf(cn,"%s/%s%s",cpath,name->get_val(),comp_suffix);
    cout << toolname << ": parsing component file " << cn << " ... " << endl;

    Component * comp = new Component();
    comp = (Component *)comp->g_parse(cn);

    if (comp == NULL)
      derror('e',1," failed to parse the component file.\n");

    cout << toolname << ": successfully parsed component file " << cn << "." << endl;

     comp->inject_comp(inst_path,cpath,comp_meta,comp_ren);
     delete comp;


  // outgoing calls

  // suffix class wrappers

  // assignments for carrying out

}

//  Component_location  : Component_name   |
//                     Component_file 
//           *common* .
void Component_location::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Rename*  comp_ren,Meta_def*  comp_meta,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Component_location","void Component_location::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Rename*  comp_ren,Meta_def*  comp_meta,Search_path_Nlist*  comp_names)");
#ifndef NOTRACE
   DemTrace demTraceEmptyMethod(__FILE__,__LINE__,"Component_location",form(" at %s , ***  PREMATURELY TERMINATED *** ", this->get_type()));
#endif

}

//  Component_file  = <location > File_name .
void Component_file::inject_components( char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Rename*  comp_ren,Meta_def*  comp_meta,Search_path_Nlist*  comp_names )
{
  DEM_TRACE("Component_file","void Component_file::inject_components(char*  inst_path,char*  default_path,Search_path_Nlist*  comp_paths,Rename*  comp_ren,Meta_def*  comp_meta,Search_path_Nlist*  comp_names)");
  // variables for carrying in and out

  // assignments for carrying in


  // prefix class wrappers

    char fn[MAXDIRLEN+1];
    char org_n[MAXDIRLEN+1];
    location->fetch_fname(fn);
    strcpy(org_n,fn);

    cout << "\n\n";

    if (*fn != '/')
    {
      cout << toolname << ": searching component file " << org_n << " ... " << endl;
      comp_paths->search_file(fn);
      if (fn[0] == '\0')
      {
         cerr << toolname << ": error: unable to find " << org_n << endl;
         exit(1);
      }
    }

    cout << toolname << ": parsing component file " << fn << " ... " << endl;

    Component * comp = new Component();
    comp = (Component *)comp->g_parse(fn);

    if (comp == NULL)
      derror('e',1," failed to parse the component file.\n");

    cout << toolname << ": successfully parsed component file " << fn << "." << endl;

    Search_path * cname_obj = new Search_path();
    char * cname = new char[strlen(comp->get_name()->get_name()->get_val())+1];

    strcpy(cname,comp->get_name()->get_name()->get_val());
    cname_obj->set_search_path(new DemString(cname));
    comp_names->append(cname_obj);

    char *p;
    p = fn + strlen(fn)-1;
    while (*p != '/')
      p--;
    *p = '\0';

    comp->inject_comp(inst_path,fn,comp_meta,comp_ren);
    delete comp;


  // outgoing calls

  // suffix class wrappers

  // assignments for carrying out

}

void Component::inject_comp( char*  inst_path,char*  comp_path,Meta_def*  comp_meta,Rename*  comp_ren )
{
  DEM_TRACE("Component","void Component::inject_comp(char*  inst_path,char*  comp_path,Meta_def*  comp_meta,Rename*  comp_ren)");
  // prefix class wrappers

   char *tfile;
   char *compname = name->get_name()->get_val();
   char *compdir = new char[strlen(inst_path)+strlen(compname)+10];

   sprintf(compdir,"%s/%s",inst_path,compname);
   if (mkdir(compdir,0755))
   {    
      if (errno != EEXIST)
      {
        cerr << toolname << ": unable to create directory " << compdir
             << endl;
         exit(1);
      }
   }
   else
     cout << toolname << ": " << compdir << " created." << endl;


    char *tmp = tempnam(tmpdir,compname);
    ofstream comp_h( tmp );
      
    if (!comp_h)
    {
          cerr << toolname << ": unable to open " << tmp << " for output." << endl;
          exit(1);
    }

   if (declared)
   {
     comp_h <<  "#include \"interface.h\"\n";
     comp_h << declared->get_code()->get_val() << "\n\n";
   }
   comp_h.close();

   tfile = new char[MAXDIRLEN+1];
   sprintf(tfile,"%s/%s.h",compdir,compname);
   mv_if_change(mv_interactive,tmp,tfile);
   delete tmp;

   tmp = tempnam(tmpdir,compname);
   ofstream comp_c( tmp );
      
   if (!comp_c)
   {
          cerr << toolname << ": unable to open " << tmp << " for output." << endl;
          exit(1);
   }

   if (defined)
   {
     comp_c <<  "#include \"interface.h\"\n";
     comp_c << defined->get_code()->get_val() << "\n\n";
   }
   comp_c.close();

   sprintf(tfile,"%s/%s.C",compdir,compname);
   mv_if_change(mv_interactive,tmp,tfile);
   delete tmp;
   delete tfile;


    tmp = tempnam(tmpdir,"comp_inst.meta");
    ofstream inst_meta( tmp );
      
    if (!inst_meta)
    {
          cerr << toolname << ": unable to open " << tmp << " for output." << endl;
          exit(1);
     }

    if (this->get_meta_def())
    {
       this->get_meta_def()->g_print(inst_meta);
       inst_meta << "\n";
    }

    if (comp_meta)
    {
       comp_meta->g_print(inst_meta);
       inst_meta  << "\n\n";
    }
    inst_meta.close();
    tfile = new char[MAXDIRLEN+1];
    sprintf(tfile,"%s/comp_inst.meta",compdir);
    mv_if_change(mv_interactive,tmp,tfile);
    delete tmp;
    delete tfile;


    tmp = tempnam(tmpdir,"comp_inst.ren");
    ofstream inst_ren( tmp );
      
    if (!inst_ren)
    {
          cerr << toolname << ": unable to open " << tmp << " for output." << endl;
          exit(1);
     }

    if (comp_ren)
    {
       comp_ren->g_print(inst_ren);
       inst_ren  << "\n\n";
    }
    inst_ren.close();
    tfile = new char[MAXDIRLEN+1];
    sprintf(tfile,"%s/comp_inst.ren",compdir);
    mv_if_change(mv_interactive,tmp,tfile);
    delete tmp;
    delete tfile;


   int file_count = 1;

   provides->inject_comp(compdir,compname,comp_path,file_count);

   delete compdir;


  // suffix class wrappers

}

//  Meta_macro_def  =  [ <classes > Term_Commalist  ] 
//                  [ <relations > Meta_edge_Commalist  ] 
//                  [ <class_sets > Class_set_def_Amplist  ] 
//                  [ <dirs > Dir_meta_def_Amplist  ] 
//                  [ <macros > PCP_def_Amplist  ] .
void Meta_macro_def::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Meta_macro_def","void Meta_macro_def::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  if ( this->get_macros() != NULL )
  {
  // construction edge prefix wrappers
    this->get_macros()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge prefix wrappers
  }

  // suffix class wrappers

  // assignments for carrying out
}

//  PCP_def  = <pcp_def_name > PCP_def_name 
//          "=" 
//          <pcp > PCP 
//          ";" .
void PCP_def::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("PCP_def","void PCP_def::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  // construction edge prefix wrappers
  this->get_pcp()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge suffix wrappers

  // suffix class wrappers

  // assignments for carrying out
}

//  PCP  : Propagation_directive_exp   |
//      Propagation_pattern 
//           *common* .
void PCP::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("PCP","void PCP::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
#ifndef NOTRACE
   DemTrace demTraceEmptyMethod(__FILE__,__LINE__,"PCP",form(" at %s , ***  PREMATURELY TERMINATED *** ", this->get_type()));
#endif

}

//  Asset  : Provided_asset   |
//        Required_asset 
//           *common* <asset > Asset_declaration .
void Asset::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Asset","void Asset::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
#ifndef NOTRACE
   DemTrace demTraceEmptyMethod(__FILE__,__LINE__,"Asset",form(" at %s , ***  PREMATURELY TERMINATED *** ", this->get_type()));
#endif

}

//  Provided_asset  = .
void Provided_asset::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Provided_asset","void Provided_asset::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in


  // prefix class wrappers

  // outgoing calls
  // inheritance edge prefix wrappers
  // construction edge prefix wrappers
  this->get_asset()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge suffix wrappers
  // inheritance edge prefix wrappers

  // suffix class wrappers

  // assignments for carrying out

}

//  Asset_declaration  = <members > Pp_with_qualifier_List .
void Asset_declaration::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Asset_declaration","void Asset_declaration::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  // construction edge prefix wrappers
  this->get_members()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge suffix wrappers

  // suffix class wrappers

  // assignments for carrying out
}

//  Pp_with_qualifier  =  [ <access_spec > Access_specifier  ] 
//                    <operation > Propagation_pattern .
void Pp_with_qualifier::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Pp_with_qualifier","void Pp_with_qualifier::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  // construction edge prefix wrappers
  this->get_operation()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge suffix wrappers

  // suffix class wrappers

  // assignments for carrying out
}

//  Meta_def  = +
//           "*constraints*" 
//           *l
//           <meta_def > Meta_macro_def 
//           "*end*" 
//           -
//           *l.
void Meta_def::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Meta_def","void Meta_def::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  // construction edge prefix wrappers
  this->get_meta_def()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge suffix wrappers

  // suffix class wrappers

  // assignments for carrying out
}

//  Propagation_pattern  = <header > Header 
//                       [ <rename > Rename  ] 
//                       [ <meta_def > Meta_def  ] 
//                      <impl_or_loc > Impl_or_loc .
void Propagation_pattern::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Propagation_pattern","void Propagation_pattern::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in


  // prefix class wrappers


  impl_or_loc->inject_comp(compdir,compname,comp_path,file_count,meta_def,rename,header);
  file_count++;


  // outgoing calls
  if ( this->get_meta_def() != NULL )
  {
  // construction edge prefix wrappers
    this->get_meta_def()->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // construction edge prefix wrappers
  }

  // suffix class wrappers

  // assignments for carrying out

}

//  PCP_def_Amplist  ~ PCP_def  { PCP_def  }. .
void PCP_def_Amplist::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("PCP_def_Amplist","void PCP_def_Amplist::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  PCP_def_list_iterator	next_PCP_def(*this);
  PCP_def*		each_PCP_def;

  while ( each_PCP_def = next_PCP_def() )
  {
  // repetition edge prefix wrappers
    each_PCP_def->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // repetition edge suffix wrappers
  }

  // suffix class wrappers

  // assignments for carrying out
}

//  Pp_with_qualifier_List  ~  { Pp_with_qualifier  }. .
void Pp_with_qualifier_List::inject_comp( char*  compdir,char*  compname,char*  comp_path,int&  file_count )
{
  DEM_TRACE("Pp_with_qualifier_List","void Pp_with_qualifier_List::inject_comp(char*  compdir,char*  compname,char*  comp_path,int&  file_count)");
  // variables for carrying in and out

  // assignments for carrying in

  // prefix class wrappers

  // outgoing calls
  Pp_with_qualifier_list_iterator	next_Pp_with_qualifier(*this);
  Pp_with_qualifier*		each_Pp_with_qualifier;

  while ( each_Pp_with_qualifier = next_Pp_with_qualifier() )
  {
  // repetition edge prefix wrappers
    each_Pp_with_qualifier->inject_comp( compdir ,  compname ,  comp_path ,  file_count  );
  // repetition edge suffix wrappers
  }

  // suffix class wrappers

  // assignments for carrying out
}

//  Impl_or_loc  : Implementation   |
//              Pp_location 
//           *common* .
void Impl_or_loc::inject_comp( char*  compdir,char*  compname,char*  comp_path,int file_count,Meta_def*  meta,Rename*  ren,Header*  header )
{
  DEM_TRACE("Impl_or_loc","void Impl_or_loc::inject_comp(char*  compdir,char*  compname,char*  comp_path,int file_count,Meta_def*  meta,Rename*  ren,Header*  header)");
#ifndef NOTRACE
   DemTrace demTraceEmptyMethod(__FILE__,__LINE__,"Impl_or_loc",form(" at %s , ***  PREMATURELY TERMINATED *** ", this->get_type()));
#endif

}

//  Pp_location  = +
//              <pp_file > File_name 
//              -
//              *l.
void Pp_location::inject_comp( char*  compdir,char*  compname,char*  comp_path,int file_count,Meta_def*  meta,Rename*  ren,Header*  header )
{
  DEM_TRACE("Pp_location","void Pp_location::inject_comp(char*  compdir,char*  compname,char*  comp_path,int file_count,Meta_def*  meta,Rename*  ren,Header*  header)");
  // variables for carrying in and out

  // assignments for carrying in


  // prefix class wrappers

   struct stat buf;
   Propagation_pattern * prop;
   char ppfile[MAXDIRLEN+1];
   char org_n[MAXDIRLEN+1];
   char *tmp,*targetfile;


   pp_file->fetch_fname(org_n);

   if (*org_n != '/')
      sprintf(ppfile,"%s/%s",comp_path,org_n);
   else
      strcpy(ppfile,org_n);

   cout << toolname << ": searching " << ppfile << " for ";
   header->g_print(cout);
   cout << " ... " << endl;

   if (lstat(ppfile,&buf) && (access(ppfile, R_OK) != 0))
   {
        cerr << toolname << ": error: unable to open "
             << ppfile << " for input." << endl;
        exit(1);
   }

   cout << toolname << ": reading " << ppfile << " ... " << endl;

   Propagation_patterns *pps = new Propagation_patterns();
   pps = (Propagation_patterns *) pps->g_parse(ppfile);

   if (pps == NULL)
      derror('e',1," failed to parse the propagation pattern file.\n");

   Propagation_pattern_List * props = pps->get_pps();

   targetfile = cppfname(compdir,compname,header,file_count);
   tmp = tmpfname();
   ofstream tfile(tmp);
   if (pps->get_text() != NULL)
       tfile << "\n" << pps->get_text()->get_code()->get_val() << "\n\n";
   else
       tfile << "\n";
   tfile.close();
   mv_if_change(mv_interactive,tmp,targetfile);
   unlink(tmp);
   free(targetfile);
   free(tmp);

   /* find the propagation pattern */
    
   Propagation_pattern_list_iterator next_p(*props);
   Propagation_pattern *             each_p;

   prop = NULL;
   while (each_p = next_p())
      if (each_p->get_header()->get_signature()->g_equal(header->get_signature()))
      {
        prop = each_p;
        break;
      }

   if (prop == NULL)
     derror('e',1," unable to find this operation.\n");

   if (prop->get_rename())
      derror('e',1,"renaming is not allowed with known implementation.");

   /* prop coannot contain another file name */
   prop->no_filename(ppfile,header);
  
   targetfile = renfname(compdir,compname,header,file_count);
   tmp = tmpfname();
   tfile.open(tmp);

   if (!tfile)
   {
      cerr << toolname << ": unable to open " << tmp << " for output.\n";
      exit(1); 
   }

   if (ren)
   {
      ren->g_print(tfile);
      tfile << "\n";
   }
   tfile.close();
   
   mv_if_change(mv_interactive,tmp,targetfile);
   unlink(tmp);
   free(targetfile);
   free(tmp);


   targetfile = metafname(compdir,compname,header,file_count);
   tmp = tmpfname();
   tfile.open(tmp);

   if (!tfile)
   {
      cerr << toolname << ": unable to open " << tmp << " for output.\n";
      exit(1); 
   }

   if (prop->get_meta_def())
   {
     prop->get_meta_def()->g_print(tfile);
     tfile << "\n";
   }

   if (meta)
   {
      meta->g_print(tfile);
      tfile << "\n";
   }
   tfile.close();
   
   mv_if_change(mv_interactive,tmp,targetfile);
   unlink(tmp);
   free(targetfile);
   free(tmp);


   targetfile = ppfname(compdir,compname,header,file_count);
   tmp = tmpfname();


   cout << toolname << ": generating " << targetfile << " for ";
   header->g_print(cout);
   cout << " ... " << endl;

   tfile.open(tmp);
   if (!tfile)
   {
      cerr << toolname << ": unable to open " << tmp << " for output.\n";
      exit(1); 
   }
   /* print the pp */
   prop->set_meta_def(NULL);
   prop->g_print(tfile);

   tfile << "\n";
   tfile.close();
   
   mv_if_change(mv_interactive,tmp,targetfile);
   unlink(tmp);
   free(tmp);

  delete props;


  // outgoing calls

  // suffix class wrappers

  // assignments for carrying out

}

//  Implementation  =  [ <pde > Propagation_directive_exp  ] 
//                 <carry_or_wrapper > Carry_or_wrapper_List .
void Implementation::inject_comp( char*  compdir,char*  compname,char*  comp_path,int file_count,Meta_def*  meta,Rename*  ren,Header*  header )
{
  DEM_TRACE("Implementation","void Implementation::inject_comp(char*  compdir,char*  compname,char*  comp_path,int file_count,Meta_def*  meta,Rename*  ren,Header*  header)");
  // variables for carrying in and out

  // assignments for carrying in


  // prefix class wrappers

    char *tmp;
    char *targetfile;

    /* get target and temporary file names */

    targetfile = ppfname(compdir,compname,header,file_count);
    tmp        = tmpfname();

    cout << toolname << ": generating " << targetfile << " for ";
    header->g_print(cout);
    cout << " ... " << endl;

    ofstream tfile(tmp);

   if (!tfile)
   {
      cerr << toolname << ": unable to open " << tmp << " for output.\n";
      exit(1); 
   }

   Propagation_pattern * tmp_pp = new Propagation_pattern();
   tmp_pp->set_header(header);
   tmp_pp->set_impl_or_loc(this);
   tmp_pp->g_print(tfile);
   tfile << "\n";
   tfile.close();
   
   mv_if_change(mv_interactive,tmp,targetfile);
   unlink(tmp);
   free(targetfile);
   free(tmp);



   targetfile = metafname(compdir,compname,header,file_count);
   tmp = tmpfname();
   tfile.open(tmp);

   if (!tfile)
   {
      cerr << toolname << ": unable to open " << tmp << " for output.\n";
      exit(1); 
   }

   if (meta)
   {
      meta->g_print(tfile);
      tfile << "\n";
   }
   tfile.close();
   
   mv_if_change(mv_interactive,tmp,targetfile);
   unlink(tmp);
   free(targetfile);
   free(tmp);


   if (ren)
      derror('e',1,"renaming is not allowed with known implementation.");



  // outgoing calls

  // suffix class wrappers

  // assignments for carrying out

}

void Search_path_Nlist::search_path( char*  fpath )
{
  DEM_TRACE("Search_path_Nlist","void Search_path_Nlist::search_path(char*  fpath)");
  // prefix class wrappers

   char tmp[MAXDIRLEN+1];
   struct stat buf;
   Search_path_list_iterator next(*this);
   Search_path *             each;
   
   assert( fpath != NULL );

   while (each = next())
   {
      each->fetch_fname(tmp);
      sprintf(tmp,"%s/%s",tmp,fpath);
      if (lstat(tmp,&buf))
      {
         if (errno == ENOENT)
           continue;
         else
         {
            cerr << toolname << ": error: unable to open "
                 << tmp << endl;
            perror(tmp);
            fpath[0] = '\0';
            return;
         }
      }
      else
      if (access(tmp, X_OK | R_OK) != 0)
      {
        cerr << toolname << ": error: unable to open "
             << tmp << endl;
        fpath[0] = '\0';
        return;
      }
      else
      {
         strcpy(fpath,tmp);
         return;
      }
   }
   fpath[0] = '\0';


  // suffix class wrappers

}