//
// $Log: extract_ps.pp,v $
//  Revision 5.5.1.1  1994/08/24  19:31:39  demeter
//  *** empty log message ***
//
//  Revision 5.5  1994/08/24  19:31:38  demeter
//  *** empty log message ***
//
//  Revision 5.4.1.2  1994/02/22  14:45:34  demeter
//  update according to the new semantics
//
// Revision 5.4.1.1  1994/02/20  19:52:39  demeter
// *** empty log message ***
//
// Revision 5.4  1994/02/20  19:52:37  demeter
// *** empty log message ***
//
// Revision 5.3.1.1  1994/01/26  20:07:18  demeter
// *** empty log message ***
//
// Revision 5.3  1994/01/26  20:07:17  demeter
// *** empty log message ***
//
// Revision 5.2.1.1  1994/01/25  17:24:55  demeter
// *** empty log message ***
//
// Revision 5.2  1994/01/25  17:24:54  demeter
// *** empty log message ***
//
// Revision 5.1.1.3  1993/11/16  23:29:18  demeter
// add debugging message
// /
//
//Revision 5.1.1.2  1993/11/15  18:50:17  demeter
//debug
//
//

*operation* void extract_ps(Header *hdr,
                            Vertex_selector* source_port,
                            Propagation_schema* ps)
*wrapper* Cd_graph
*prefix*
(@
    if (hdr->get_access() == NULL)
        ps->set_source_port((Vertex_selector*) source_port->g_copy());
    else
    {
        hdr->get_access()->allInPS(this);
        ps->set_source_port((Vertex_selector*) hdr->get_access());
    }

    ps->set_paths(new Cd_graph());
    ps->get_paths()->set_adjacencies(new Adjacency_Nlist());

    adjacencies->extract_ps(this, ps->get_paths()->get_adjacencies());
#ifdef DEBUG
    cout << "=================" << endl;
    this->g_print();
    cout << "================" << endl;
#endif
@)

*operation* void extract_ps(Cd_graph* schema, Adjacency_Nlist* adjs)
*wrapper* Adjacency_Nlist
*prefix*
(@
   static DemString * mark = new DemString("propagate");
   Adjacency_list_iterator  next(*this);
   Adjacency*               each;

   while (each = next())
   {
      if (mark->g_equal(each->get_propagate()))
      {
         Adjacency *newAdj = new Adjacency();
         adjs->append(newAdj);
         each->extract_ps(schema, newAdj);
      }
   }
@)


*operation* void extract_ps(Cd_graph* schema, Adjacency* adj)
*wrapper* Adjacency
*prefix*
(@
    static DemString * mark = new DemString("call");

    adj->set_source(new Vertex());
    adj->get_source()
         ->set_vertex_name((DemIdent*)source->get_vertex_name()->g_copy());

    adj->set_superclasses(new Vertex_List());
    if (superclasses)
    {
       Vertex_list_iterator next(*superclasses);
       Vertex*              each;

       while (each = next())
       {
   
         if (!mark->g_equal(each->get_call()))
            continue;

         int result = 0;
         schema->allInPS(each,result);
         if (result == 1)
         {
           Vertex* newV = new Vertex();
           adj->get_superclasses()->append(newV);
           newV->set_vertex_name((DemIdent*)each->get_vertex_name()->g_copy());
         }
       }
    }
      
    ns->extract_ps(schema, adj);
@)
*wrapper* Neighbors
*prefix*
(@
@)
*wrapper* Neighbors_wc
*prefix*
(@
@)
*wrapper* Construct_ns
*prefix*
(@
   Construct_ns* ns = new Construct_ns();
   adj->set_ns(ns);

   ns->set_construct_ns(new Any_vertex_List());
   this->get_construct_ns()->extract_ps(ns->get_construct_ns());

@)
*wrapper* Alternat_ns
*prefix*
(@
   Alternat_ns* ns = new Alternat_ns();
   adj->set_ns(ns);

   ns->set_construct_ns(new Any_vertex_List());
   this->get_construct_ns()->extract_ps(ns->get_construct_ns());

   if (alternat_ns)
     alternat_ns->extract_ps(ns);

   ns->set_common(new Common());
@)
*wrapper* Repetit_n
*prefix*
(@
   Repetit_n* ns = new Repetit_n();
   adj->set_ns(ns);

   if (sandwiched)
     sandwiched->extract_ps(ns);
@)

*operation* void extract_ps(Any_vertex_List* avlist)
*wrapper* Any_vertex_List
*prefix*
(@ 
    Any_vertex_list_iterator   next(*this);    
    Any_vertex*                each;
 
    while (each = next()) 
        each->extract_ps(avlist);  
@)
*wrapper* Any_vertex
*prefix*
(@
@)
*wrapper* Optional_term
*prefix*
(@
    static DemString * mark = new DemString("call");
   
    if (!mark->g_equal(opt->get_inner()->get_call()))
      return;

    Optional_term* newTerm = new Optional_term();
    Opt_labeled_term_Sandwich* sand = new Opt_labeled_term_Sandwich();
    sand->set_first(new Syntax_vertex_List());
    sand->set_second(new Syntax_vertex_List());
    newTerm->set_opt(sand);

    avlist->append(newTerm);
    opt->extract_ps(sand);
@)
*wrapper* Opt_labeled_term
*prefix*
(@
@)
*wrapper* Labeled
*prefix*
(@
    static DemString * mark = new DemString("call");
   
    if (!mark->g_equal(this->get_call()))
      return;

    Labeled* newTerm = new Labeled();
    avlist->append(newTerm);

    newTerm->set_label_name((DemIdent*)this->get_label_name()->g_copy());
    this->get_vertex()->extract_ps(newTerm);
@)
*wrapper* Regular
*prefix*
(@
   derror('i',1," unexpected visit at Regular::extract_ps\n");
   exit(-1);
@)

*operation* void extract_ps(Labeled* t)
*wrapper* Term
*prefix*
(@
@)
*wrapper* CppTerm
*prefix*
(@
   derror('i',1," unexpected visit at CppTerm::extract_ps\n");
   exit(-1);
@)
*wrapper* Normal
*prefix*
(@
    Normal* newTerm = new Normal();
    t->set_vertex(newTerm);
    newTerm->set_moduleRef((TermRef*)this->get_moduleRef()->g_copy());
    newTerm->set_vertex((Vertex*)this->get_vertex()->g_copy());
@)

*operation* void extract_ps(Opt_labeled_term_Sandwich* sand)
*wrapper* Opt_labeled_term_Sandwich
*prefix*
(@
    inner->extract_ps(sand);
@)
*wrapper* Opt_labeled_term
*prefix*
(@
@)
*wrapper* Labeled
*prefix*
(@
    Labeled* newTerm = new Labeled();
    sand->set_inner(newTerm);

    newTerm->set_label_name((DemIdent*)this->get_label_name()->g_copy());
    this->get_vertex()->extract_ps(newTerm);
@)
*wrapper* Regular
*prefix*
(@
   derror('i',1," unexpected visit at Regular::extract_ps\n");
   exit(-1);
@)


*operation* void extract_ps(Alternat_ns* ns)
*wrapper* Term_Barlist
*prefix*
(@
    static DemString * mark = new DemString("call");
    Term_list_iterator next(*this);
    Term*              each;

    while (each = next())
    {
       if (mark->g_equal(each->get_call()))
       {
         if (ns->get_alternat_ns() == NULL)
           ns->set_alternat_ns(new Term_Barlist());
         each->extract_ps(ns->get_alternat_ns());
       }
    }
@)

*operation* void extract_ps(Term_Barlist* blist)
*wrapper* Term
*prefix*
(@
@)
*wrapper* CppTerm
*prefix*
(@
   derror('i',1," unexpected visit at CppTerm::extract_ps\n");
   exit(-1);
@)
*wrapper* Normal
*prefix*
(@
    Normal* newTerm = new Normal();
    blist->append(newTerm);
    newTerm->set_moduleRef((TermRef*)this->get_moduleRef()->g_copy());
    newTerm->set_vertex((Vertex*)this->get_vertex()->g_copy());
@)


*operation* void extract_ps(Repetit_n* ns)
*wrapper* Kernel_Sandwich
*prefix*
(@
   inner->extract_ps(ns);
@)
*wrapper* Kernel
*prefix*
(@
    Kernel* knl;
    int r = 0;
    repeated->extract_ps(knl, r);

    if (r == 0)
     return;

    Kernel_Sandwich* sand = new Kernel_Sandwich();
    ns->set_sandwiched(sand);
    sand->set_first(new Syntax_vertex_List());
    sand->set_second(new Syntax_vertex_List());
    sand->set_inner(knl);

    if (nonempty)
      nonempty->extract_ps(knl);
@)

*operation* void extract_ps(Kernel* knl)
*wrapper* Term
*prefix*
(@
@)
*wrapper* CppTerm
*prefix*
(@
   derror('i',1," unexpected visit at CppTerm::extract_ps\n");
   exit(-1);
@)
*wrapper* Normal
*prefix*
(@
    Normal* newTerm = new Normal();
    knl->set_nonempty(newTerm);
    newTerm->set_moduleRef((TermRef*)this->get_moduleRef()->g_copy());
    newTerm->set_vertex((Vertex*)this->get_vertex()->g_copy());
@)


*operation* void extract_ps(Kernel*& knl, int& r)
*wrapper* Term_Sandwich
*prefix*
(@
    inner->extract_ps(knl, r);
@)
*wrapper* Term
*prefix*
(@
@)
*wrapper* CppTerm
*prefix*
(@
   derror('i',1," unexpected visit at CppTerm::extract_ps\n");
   exit(-1);
@)
*wrapper* Normal
*prefix*
(@
    static DemString * mark = new DemString("call");
    if (!mark->g_equal(this->get_call()))
       return;

    r = 1;

    knl = new Kernel();
    Term_Sandwich* sand = new Term_Sandwich();
    sand->set_first(new Syntax_vertex_List());
    sand->set_second(new Syntax_vertex_List());

    Normal* newTerm = new Normal();
    sand->set_inner(newTerm);
    newTerm->set_moduleRef((TermRef*)this->get_moduleRef()->g_copy());
    newTerm->set_vertex((Vertex*)this->get_vertex()->g_copy());
    knl->set_repeated(sand);
@)

*operation* void allInPS(Cd_graph* schema)
*wrapper* Vertex_selector
*prefix*
(@
  derror('i',1," unexpected visit at Vertex_selector::allInPS\n");
  exit(-1);
@)
*wrapper* Any_term
*prefix*
(@
  derror('i',1," unexpected visit at Any_term::allInPS\n");
  exit(-1);
@)
*wrapper* Fixed_term
*prefix*
(@
  derror('i',1," unexpected visit at Fixed_term::allInPS\n");
  exit(-1);
@)
*wrapper* Vertex_set
*prefix*
(@
  derror('i',1," unexpected visit at Vertex_set::allInPS\n");
  exit(-1);
@)
*wrapper* Vertex_set_sim
*prefix*
(@
   terms->allInPS(schema);
@)
*wrapper* Fixed_term_Commalist
*prefix*
(@
   Fixed_term_list_iterator  next(*this);
   Fixed_term*               each;

   while (each = next())
   {
     int result = 0;
     schema->allInPS(each->get_vertex()->get_vertex(),result);
     if (result == 0)
     {
       derror('e',1,
              form(" not in propagation graph: %s\n",
                 each->get_vertex()->get_vertex()->get_vertex_name()->get_val()));
       exit(-1);
     }
     else
     if (result == -1)
     {

        derror('e',1,
            form(" unknow class: %s\n",
               each->get_vertex()->get_vertex()->get_vertex_name()->get_val()));
        exit(-1);

     }
   }
@)


*operation* void allInPS(Vertex *v,int& result)
*wrapper* Cd_graph
*prefix*
(@
   adjacencies->allInPS(v,result);
@)
*wrapper* Adjacency_Nlist
*prefix*
(@
   static DemString * mark = new DemString("propagate");
   Adjacency_list_iterator  next(*this);
   Adjacency*               each;

   while (each = next())
   {
      if (each->get_source()->get_vertex_name()->g_equal(v->get_vertex_name()))
      {
         if (!mark->g_equal(each->get_propagate()))
         {
           result = 0;
           return;
          }
         result = 1;
         return;
      }
   }
   result = -1;
@)