/////////////////////////////////////////////////////////////////
// $Log: mapSCC2CDG.pp,v $
//  Revision 5.5.1.4  1995/01/12  02:18:52  demeter
//  bug fix
//
//  Revision 5.5.1.3  1994/09/23  15:52:55  demeter
//  fixed short cut checking
//
//  Revision 5.5.1.2  1994/09/21  13:54:47  demeter
//  *** empty log message ***
//
//  Revision 5.5.1.1  1994/08/24  19:33:01  demeter
//  *** empty log message ***
//
// Revision 5.5  1994/08/24  19:33:00  demeter
// *** empty log message ***
//
// Revision 5.4.1.1  1994/02/20  19:54:14  demeter
// *** empty log message ***
//
// Revision 5.4  1994/02/20  19:54:12  demeter
// *** empty log message ***
//
// Revision 5.3.1.1  1994/01/26  20:08:37  demeter
// *** empty log message ***
//
// Revision 5.3  1994/01/26  20:08:36  demeter
// *** empty log message ***
//
// Revision 5.2.1.1  1994/01/25  17:26:03  demeter
// *** empty log message ***
//
// Revision 5.2  1994/01/25  17:26:02  demeter
// *** empty log message ***
//
// Revision 5.1.1.2  1993/11/16  23:32:00  demeter
// add debugging messages
//
/////////////////////////////////////////////////////////////////
*operation* void markondg(Cd_graph* schema,
                          SCC_component_List*  sccmatrix,
                          Path_constraint_exp* c,
                          Meta_edge *inclEdge)
*wrapper* Cd_graph
*prefix*
(@
#ifdef DEBUG
this->g_print();
cout << endl;
cout << "Matrix " << endl;
sccmatrix->g_print();
cout << endl;
#endif

    adjacencies->markvertices(schema, sccmatrix,this,c);
    adjacencies->markedges(schema, sccmatrix,this,c,inclEdge);
    this->get_adjacencies()->markinhedges(c, schema);

#ifdef DEBUG
this->g_print();
cout << endl;
cout << "Matrix " << endl;
sccmatrix->g_print();
cout << endl;
#endif

@)

*operation* void markvertices(Cd_graph*            schema,
                          SCC_component_List*  sccmatrix,
		          Cd_graph*            workingCopy,
                          Path_constraint_exp* c)
*wrapper* Adjacency_Nlist
*prefix*
(@
   Adjacency_list_iterator  next(*this);
   Adjacency*               each;

   Adjacency_list_iterator  next2(*schema->get_adjacencies());
   Adjacency*               each2;

   while (each = next())
   {
     each2 = next2();
     each->markvertices(each2, sccmatrix, workingCopy, c);
   }
@)


*operation* void markedges(Cd_graph*            schema,
                          SCC_component_List*  sccmatrix,
		          Cd_graph*            workingCopy,
                          Path_constraint_exp* c,
                          Meta_edge *inclEdge)
*wrapper* Adjacency_Nlist
*prefix*
(@
   Adjacency_list_iterator  next(*this);
   Adjacency*               each;

   Adjacency_list_iterator  next2(*schema->get_adjacencies());
   Adjacency*               each2;

   while (each = next())
   {
     each2 = next2();
     each->markedges(each2, sccmatrix, workingCopy, c,inclEdge);
   }
@)


*operation* void markvertices(Adjacency*       tadjacency,
                          SCC_component_List*  sccmatrix,
		          Cd_graph*            workingCopy,
                          Path_constraint_exp* c)
*wrapper* Adjacency
*prefix*
(@
   int resultscc;
   static DemString* mark = new DemString("propagate");

   resultscc = 0;
   sccmatrix->scc_marked(scc->get_val(), resultscc);

   if (resultscc != 0)
   {
      if (propagate)
	propagate->g_delete();
      propagate = (DemString*)mark->g_copy();

      if (tempmark)
	tempmark->g_delete();
      tempmark  = (DemString*)mark->g_copy();

      if (tadjacency->get_propagate())
	 tadjacency->get_propagate()->g_delete();
      tadjacency->set_propagate((DemString*)mark->g_copy());

      if (tadjacency->get_tempmark())
	 tadjacency->get_tempmark()->g_delete();
      tadjacency->set_tempmark((DemString*)mark->g_copy());
   }
@)

*operation* void markedges(Adjacency*           tadjacency,
                          SCC_component_List*  sccmatrix,
		          Cd_graph*            workingCopy,
                          Path_constraint_exp* c,
                          Meta_edge *inclEdge)
*wrapper* Adjacency
*prefix*
(@
   int resultscc;
   static DemString* mark = new DemString("propagate");

   resultscc = 0;
   sccmatrix->scc_marked(scc->get_val(), resultscc);

#ifdef DEBUG
cout << "at " << source << "  " << scc << "  " << resultscc << endl;
#endif


   if (resultscc != 0)
   {
      /////////////////////////////////////////
      // should not consider bypassing edges
      //////////////////////////////////////////
      ns->check_alt_mark(tadjacency->get_ns(),
                         source,
                         scc->get_val(),
                         sccmatrix,
                         workingCopy,
                         c, inclEdge);
      ns->check_rep_mark(tadjacency->get_ns(),
                         source,
                         scc->get_val(),
                         sccmatrix,
                         workingCopy,
                         c, inclEdge);
   }

   //////////////////////////////////////////////////////////
   // construction edges are special. They can be inherited.
   //////////////////////////////////////////////////////////

   ns->check_cons_mark(tadjacency,
                       this,
                       source,
                       scc->get_val(),
                       sccmatrix,
                       workingCopy,
                       c, inclEdge);
@)

/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void scc_marked(int sccval, int &result)
*wrapper* SCC_component_List
*prefix*
(@
    static DemString* markstr = new DemString("propagate");
    SCC_component_list_iterator  next(*this);
    SCC_component*               each;

    while (each = next())
      if (sccval == each->get_scc()->get_val())
      {
	result = (each->get_mark()->g_equal(markstr));
        return;
      }
@)

/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_alt_mark(Neighbors* tns,
                                Vertex* source,
                                int fromscc,
                                SCC_component_List* sccmatrix,
                                Cd_graph* cd,
                                Path_constraint_exp *c,
                                Meta_edge *inclEdge)
*wrapper* Neighbors
*prefix*
(@
@)
*wrapper* Neighbors_wc
*prefix*
(@
@)
*wrapper* Alternat_ns
*prefix*
(@
   if (alternat_ns)
     alternat_ns->check_alt_mark(((Alternat_ns*)tns)->get_alternat_ns(),
                                 source,fromscc, sccmatrix, cd, c, inclEdge);
@)

*operation* void check_alt_mark(Term_Barlist* tns,
                                Vertex* source,
                                int fromscc,
                                SCC_component_List* sccmatrix,
                                Cd_graph* cd,
                                Path_constraint_exp *c,
                                Meta_edge *inclEdge)
*wrapper* Term_Barlist
*prefix*
(@
   Term_list_iterator      next(*this);
   Term*                   each;

   Term_list_iterator      next2(*tns);
   Term*                   each2;

   /* CHECK WHETHER IT IS EXCLUDING ALT EDGES */
   while (each = next())
   {
     each2 = next2();
#ifdef DEBUG
cout << "before " << source << " => " << each2 << endl;
#endif
     if (c == NULL || !c->isXAltEdgeInTheList(source,each))
     {
#ifdef DEBUG
cout << "after " << source << " => " << each2 << endl;
#endif
        each->get_vertex()->check_alt_mark(each2,source,each,fromscc,sccmatrix,cd,c, inclEdge);
     }
   }
@)

/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_alt_mark(Term* tterm,
                                Vertex * source,
                                Term *aterm,
                                int fromscc,
                                SCC_component_List* sccmatrix,
                                Cd_graph* cd,
                                Path_constraint_exp *c,
                                Meta_edge *inclEdge)
*wrapper* Vertex
*prefix*
(@
  int vertexscc;
  int isForced;
  static DemString *mark = new DemString("call");
  int isThruAltEdge;
  int result;

  if (!this->isPropagated(cd))
     return;

//  if (inclEdge && !inclEdge->passed(source,this,cd,sccmatrix,ALTERNATIONEDGE,NULL))
//     return;


  isThruAltEdge = 0;
  if (c)
    isThruAltEdge = c->isThruAltEdgeInTheList(source,aterm);

  vertexscc = 0;
  cd->get_vert_scc(this, vertexscc);

  isForced = 0;
  if (c)
    c->isSCCEdgeForcedByThru(cd,fromscc,vertexscc,isForced);

  result = 0;
  sccmatrix->check_edge(fromscc, vertexscc, result);

  if (result ==1)
  {
     if (isForced==0)
     {
       if (aterm->get_call())
	 aterm->get_call()->g_delete();
       aterm->set_call((DemString*)mark->g_copy());

       if (tterm->get_call())
	 tterm->get_call()->g_delete();
       tterm->set_call((DemString*)mark->g_copy());
     }
     else
     if (isThruAltEdge)
     {
       if (aterm->get_call())
	 aterm->get_call()->g_delete();
        aterm->set_call((DemString*)mark->g_copy());

       if (tterm->get_call())
	 tterm->get_call()->g_delete();
        tterm->set_call((DemString*)mark->g_copy());
     }
  }
  else
  if (fromscc == vertexscc)
  {
      sccmatrix->scc_marked(vertexscc,result);
      if (result ==1)
      {
       if (aterm->get_call())
	 aterm->get_call()->g_delete();
        aterm->set_call((DemString*)mark->g_copy());

       if (tterm->get_call())
	 tterm->get_call()->g_delete();
        tterm->set_call((DemString*)mark->g_copy());
      }
  }
@)

/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_cons_mark(Adjacency*           tadj,
                                 Adjacency*           adj,
                                 Vertex*              source,
                                 int                  fromscc,
                                 SCC_component_List*  sccmatrix,
                                 Cd_graph*            cd,
	                         Path_constraint_exp* c,
                                 Meta_edge *inclEdge)
*wrapper* Neighbors
*prefix*
(@
@)
*wrapper* Neighbors_wc
*prefix*
(@
   construct_ns->check_cons_mark(tadj, ((Neighbors_wc*)tadj->get_ns())->get_construct_ns(),
                                 adj, source, fromscc, sccmatrix, cd, c, inclEdge);
@)

*operation* void check_cons_mark(Adjacency*           tadj,
				 Any_vertex_List*     tns,
                                 Adjacency*           adj,
                                 Vertex*              source,
                                 int                  fromscc,
                                 SCC_component_List*  sccmatrix,
                                 Cd_graph*            cd,
	                         Path_constraint_exp* c,
                                 Meta_edge *inclEdge)
*wrapper* Any_vertex_List
*prefix*
(@
    Any_vertex_list_iterator  next(*this);
    Any_vertex*               each;

    Any_vertex_list_iterator  next2(*tns);
    Any_vertex*               each2;

    while (each = next())
    {
       each2 = next2();
       each->check_cons_mark(tadj, adj, each2, source, fromscc, sccmatrix, cd, c, inclEdge);
    }
@)

*operation* void check_cons_mark(Adjacency*           tadj,
                                 Adjacency*           adj,
				 Opt_labeled_term_Sandwich*  tav,
                                 Vertex*              source,
                                 int                  fromscc,
                                 SCC_component_List*  sccmatrix,
                                 Cd_graph*            cd,
	                         Path_constraint_exp* c,
                                 Meta_edge *inclEdge)
*wrapper* Opt_labeled_term_Sandwich
*prefix*
(@
   inner->check_cons_mark(tadj, adj, tav->get_inner(), source, fromscc, sccmatrix, cd, c, inclEdge);
@)

*operation* void check_cons_mark(Adjacency*           tadj,
                                 Adjacency*           adj,
				 Any_vertex*          tav,
                                 Vertex*              source,
                                 int                  fromscc,
                                 SCC_component_List*  sccmatrix,
                                 Cd_graph*            cd,
	                         Path_constraint_exp* c,
                                 Meta_edge *inclEdge)
*wrapper* Any_vertex
*prefix*
(@
@)
*wrapper* Opt_labeled_term
*prefix*
(@
@)
*wrapper* Optional_term
*prefix*
(@
   opt->check_cons_mark(tadj, adj, ((Optional_term*)tav)->get_opt(),
                        source, fromscc, sccmatrix, cd, c, inclEdge);
@)
*wrapper* Regular
*prefix*
(@
    derror('i',1," unexpected visit at Regular::check_cons_mark\n");
    abort();
@)
*wrapper* Labeled
*prefix*
(@
   int isThruConsEdge = 0;

   if (c)
      isThruConsEdge = c->isThruConsEdgeInTheList(source,
                                                  this->get_label_name(),
                                                  this->get_vertex());

   int isXConsEdge = 0;
  
   if (c)
      isXConsEdge = c->isXConsEdgeInTheList(source,
                                            this->get_label_name(),
                                            this->get_vertex());
#ifdef DEBUG
cout << source << ": " << this->get_label_name() << ": " << this->get_vertex() << endl;
cout << "isXConsEdge = " << isXConsEdge << endl;
#endif

   if (!isXConsEdge)
      this->check_cons_mark(tadj,
                            adj,
                            (Labeled*)tav,
                            source,
                            this,
                            fromscc,
                            sccmatrix,
                            cd,
                            isThruConsEdge,
                            c,
                            inclEdge);
@)


*operation* int isPropagated(Cd_graph* cd)
*wrapper* Vertex
*prefix*
(@
  static DemString* markp = new DemString("propagate");

  Adjacency_list_iterator nextadj(*cd->get_adjacencies());
  Adjacency*              eachadj;
  while (eachadj = nextadj())
    if (eachadj->get_source()->get_vertex_name()->g_equal(this->get_vertex_name()))
       break;

  if (eachadj)
  {
     if (!eachadj->get_propagate()->g_equal(markp))
       return_val = 0;
     else
       return_val = 1;
  }
  else
  {
    derror('e',1,form(" undefined class: '%s'\n",this->get_vertex_name()->get_val()));
    cout << endl;
    exit(-1);
  }
@)

/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_cons_mark(
            Adjacency*          tadj,
            Adjacency*          adj,
            Labeled*            tav,
            Vertex*             source,
            Any_vertex*         anyvertex,
            int                 fromscc,
            SCC_component_List* sccmatrix,
            Cd_graph* cd,
            int isThruConsEdge,
            Path_constraint_exp* c,
            Meta_edge *inclEdge)
*wrapper* Labeled
*prefix*
(@
    if (this->get_vertex()->isTerminal())
       return;

    this->get_vertex()
        ->get_vertex()
            ->check_cons_mark(tadj,
                              adj,
                              tav,
                              source,
                              anyvertex,
                              fromscc,
                              sccmatrix,
                              cd,
                              isThruConsEdge,
                              c,
                              inclEdge,
                              this->get_label_name());
@)

*operation* void check_cons_mark(
            Adjacency*          tadj,
            Adjacency*          adj,
            Labeled*            tav,
            Vertex*             source,
            Any_vertex*         anyvertex,
            int                 fromscc,
            SCC_component_List* sccmatrix,
            Cd_graph* cd,
            int isThruConsEdge,
            Path_constraint_exp* c,
            Meta_edge *inclEdge,
            DemIdent* edgelabel)
*wrapper* Vertex
*prefix*
(@

  static DemString *mark = new DemString("call");
  static DemString* markp = new DemString("propagate");
  int result;
  int vertexscc;
  int isForced = 0;

  if (!this->isPropagated(cd))
     return;

//  if (inclEdge && !inclEdge->passed(source,this,cd,sccmatrix,CONSTRUCTIONEDGE,edgelabel))
//     return;

  vertexscc = 0;
  cd->get_vert_scc(this, vertexscc);
  if (fromscc == vertexscc)
  {
     result = 0;
     sccmatrix->scc_marked(vertexscc,result);
     if (result ==1)
     {
	if (anyvertex->get_call())
	   anyvertex->get_call()->g_delete();
	anyvertex->set_call((DemString*)mark->g_copy());

        if (tav->get_call())
	  tav->get_call()->g_delete();
	tav->set_call((DemString*)mark->g_copy());
     }
      return;
  }

  isForced = 0;
  if (c)
    c->isSCCEdgeForcedByThru(cd,fromscc, vertexscc,isForced);
 
   result = 0;
   sccmatrix->check_edge(fromscc, vertexscc, result);

   if (result ==1) 
   {
     if (isForced == 0)
     {
	if (anyvertex->get_call())
	   anyvertex->get_call()->g_delete();
	anyvertex->set_call((DemString*)mark->g_copy());

        if (tav->get_call())
	  tav->get_call()->g_delete();
	tav->set_call((DemString*)mark->g_copy());
     }
     else
     if (isThruConsEdge)
     {
	if (anyvertex->get_call())
	   anyvertex->get_call()->g_delete();
	anyvertex->set_call((DemString*)mark->g_copy());

        if (tav->get_call())
	  tav->get_call()->g_delete();
	tav->set_call((DemString*)mark->g_copy());
     }
     return;
   }

   result = 0;
   sccmatrix->scc_marked(vertexscc,result);
   if (result == 0)
      return;

  if (source->isPropagated(cd))
     return;

   Vertex_List * alternatives = new Vertex_List();
   cd->collect_alternatives(c, source, alternatives); /* It should be renamed as collect subclasses */
   Vertex_list_iterator  next(*alternatives);
   Vertex*               each;
   while (each = next())
   {
      cd->get_vert_scc(each,fromscc);
      result = 0;
      sccmatrix->check_edge(fromscc, vertexscc, result);

      if (result ==1)
      {
	  if (adj->get_propagate())
	     adj->get_propagate()->g_delete();
          adj->set_propagate((DemString*)markp->g_copy());

	  if (adj->get_tempmark())
	     adj->get_tempmark()->g_delete();
          adj->set_tempmark((DemString*)markp->g_copy());

	  if (anyvertex->get_call())
	     anyvertex->get_call()->g_delete();
          anyvertex->set_call((DemString*)mark->g_copy());

	  if (tadj->get_propagate())
	     tadj->get_propagate()->g_delete();
          tadj->set_propagate((DemString*)markp->g_copy());

	  if (tadj->get_tempmark())
	     tadj->get_tempmark()->g_delete();
          tadj->set_tempmark((DemString*)markp->g_copy());

	  if (tav->get_call())
	     tav->get_call()->g_delete();
          tav->set_call((DemString*)mark->g_copy());

          return;
      }
   }
@)


/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void get_vert_scc(Vertex* vert, int& sccval)
*wrapper* Cd_graph
*prefix*
(@
   adjacencies->get_vert_scc(vert, sccval);
@)
*wrapper* Adjacency_Nlist
*prefix*
(@
    Adjacency_list_iterator next(*this);
    Adjacency*              each;

    while (each = next())
      if ((each->get_source()->equal(vert)) == 1)
	 sccval = each->get_scc()->get_val();
@)


/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_edge(int fromscc,
                            int toscc,
                            int &result)
*wrapper* SCC_component_List
*prefix*
(@
   SCC_component_list_iterator  next(*this);
   SCC_component*               each;

   while (each = next())
     each->check_edge(fromscc, toscc, result);
@)
*wrapper* SCC_component
*prefix*
(@
    if (fromscc == scc->get_val() )
	edges->check_edge(fromscc, toscc, result);

@)
*wrapper* SCC_component_Edges_List
*prefix*
(@
    static DemString* markstr = new DemString("propagate");
    SCC_component_Edges_list_iterator next(*this);
    SCC_component_Edges*              each;

    while (each = next())
      if (toscc == each->get_scc()->get_val())
      {
	 result = (each->get_mark()->g_equal(markstr));
         return;
      }
@)


/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_rep_mark(Neighbors*           tns,
                                Vertex*              source,
                                int                  fromscc,
                                SCC_component_List*  sccmatrix,
                                Cd_graph*            cd,
                                Path_constraint_exp* c,
                                Meta_edge *inclEdge)
*wrapper* Neighbors
*prefix*
(@
@)
*wrapper* Repetit_n
*prefix*
(@
    if (sandwiched)
        sandwiched->check_rep_mark(((Repetit_n*)tns)->get_sandwiched(),
                                   source, fromscc, sccmatrix, cd, c, inclEdge);
@)

*operation* void check_rep_mark(Kernel_Sandwich*     tns,
                                Vertex*              source,
                                int                  fromscc,
                                SCC_component_List*  sccmatrix,
                                Cd_graph*            cd,
                                Path_constraint_exp* c,
                                Meta_edge *inclEdge)
*wrapper* Kernel_Sandwich
*prefix*
(@
   inner->check_rep_mark(tns->get_inner(), source, fromscc, sccmatrix, cd, c, inclEdge);
@)

*operation* void check_rep_mark(Kernel*              tns,
                                Vertex*              source,
                                int                  fromscc,
                                SCC_component_List*  sccmatrix,
                                Cd_graph*            cd,
                                Path_constraint_exp* c,
                                Meta_edge *inclEdge)
*wrapper* Kernel
*prefix*
(@
   repeated->check_rep_mark(tns->get_repeated(), source, fromscc, sccmatrix, cd, c, inclEdge);
@)

*operation* void check_rep_mark(Term_Sandwich*       tns,
                                Vertex*              source,
                                int                  fromscc,
                                SCC_component_List*  sccmatrix,
                                Cd_graph*            cd,
                                Path_constraint_exp* c,
                                Meta_edge *inclEdge)
*wrapper* Term_Sandwich
*prefix*
(@
   if (inner->isTerminal())
      return;
   if ( c == NULL || !c->isXRepEdgeInTheList(source,inner))
     inner->get_vertex()->check_rep_mark(tns->get_inner(), 
                                         source, inner, fromscc, sccmatrix, cd, c, inclEdge);
@)


/////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////
*operation* void check_rep_mark(Term*     tterm,
                                Vertex*   source,
                                Term*     aterm,
                                int       fromscc,
                                SCC_component_List* sccmatrix,
                                Cd_graph* cd,
                                Path_constraint_exp* c,
                                Meta_edge *inclEdge)
*wrapper* Vertex
*prefix*
(@
  int vertexscc;
  int isForced;
  int isThruRepEdge;
  static DemString *mark = new DemString("call");
  int result;

  if (!this->isPropagated(cd))
     return;

//  if (inclEdge && !inclEdge->passed(source,this,cd,sccmatrix,REPETITIONEDGE,NULL))
//     return;

  isThruRepEdge = 0;
  if (c)
     isThruRepEdge = c->isThruRepEdgeInTheList(source,aterm);

  vertexscc = 0;
  cd->get_vert_scc(this, vertexscc);

  isForced = 0;
  if (c)
    c->isSCCEdgeForcedByThru(cd,fromscc,vertexscc,isForced);

  result = 0;
  sccmatrix->check_edge(fromscc, vertexscc, result);

   if (result == 1)
   {
     if (isForced == 0)
     {
	if (aterm->get_call())
	   aterm->get_call()->g_delete();
        aterm->set_call((DemString*)mark->g_copy());

        if (tterm->get_call())
	   tterm->get_call()->g_delete();
        tterm->set_call((DemString*)mark->g_copy());
     }
     else
     if (isThruRepEdge)
     {
	if (aterm->get_call())
	   aterm->get_call()->g_delete();
        aterm->set_call((DemString*)mark->g_copy());

        if (tterm->get_call())
	   tterm->get_call()->g_delete();
        tterm->set_call((DemString*)mark->g_copy());
     }
     return;
   }

  if (fromscc == vertexscc)
  {
     result = 0;
     sccmatrix->scc_marked(vertexscc,result);
     if (result ==1)
     {
	if (aterm->get_call())
	   aterm->get_call()->g_delete();
        aterm->set_call((DemString*)mark->g_copy());

        if (tterm->get_call())
	   tterm->get_call()->g_delete();
        tterm->set_call((DemString*)mark->g_copy());
     }
  }
@)

*operation* int passed(Vertex* sourcev,
                       Vertex* targetv,
                       Cd_graph* cd,
                       SCC_component_List* sccmatrix,
                       int flag,
                       DemIdent* edgeLabel)
*wrapper* Meta_edge
*prefix*
(@
   return_val = 1;
@)
*wrapper* Meta_inheritance_edge
*prefix*
(@
   int sourcescc = 0;
   cd->get_vert_scc(sourcev, sourcescc);
   int targetscc = 0;
   cd->get_vert_scc(targetv, targetscc);

   Vertex* fromv = NULL;
   Vertex* tov = NULL;

   from->get_single_vertex(fromv);
   to->get_single_vertex(tov);

   int fromscc = 0;
   cd->get_the_scc(fromv, fromscc);

   int toscc = 0;
   cd->get_the_scc(tov, toscc);

   int result = 0;
   cd->reachable(toscc,sourcescc,result);
   if (result)
      return_val = 1;
   else
     {
       result = 0;
       cd->reachable(targetscc,fromscc,result);
       return_val = result;
     }
@)
*wrapper* Meta_construction_edge
*prefix*
(@
   int sourcescc = 0;
   cd->get_vert_scc(sourcev, sourcescc);
   int targetscc = 0;
   cd->get_vert_scc(targetv, targetscc);

   Vertex* fromv = NULL;
   Vertex* tov = NULL;

   from->get_single_vertex(fromv);
   to->get_single_vertex(tov);

   int fromscc = 0;
   cd->get_the_scc(fromv, fromscc);

   int toscc = 0;
   cd->get_the_scc(tov, toscc);

   if (flag == CONSTRUCTIONEDGE && sourcescc == fromscc && targetscc == toscc)
     {
         int matched = 0;
         edge_label->match_label(edgeLabel,matched);
         if (matched)
           return_val = 1;
         else
	   return_val = 0;
      }
   else
     {
       int result = 0;
       cd->reachable(toscc,sourcescc,result);
       if (result)
          return_val = 1;
       else
         {
           result = 0;
           cd->reachable(targetscc,fromscc,result);
           if (result)
              return_val = 1;
           else
           {
              if (cd->inherits(cd,targetv,fromv))
                 return_val = 1;
              else
                 return_val = 0;
           }
         }
     }
@)
*wrapper* Meta_alternation_edge
*prefix*
(@
   int sourcescc = 0;
   cd->get_vert_scc(sourcev, sourcescc);
   int targetscc = 0;
   cd->get_vert_scc(targetv, targetscc);

   Vertex* fromv = NULL;
   Vertex* tov = NULL;

   from->get_single_vertex(fromv);
   to->get_single_vertex(tov);

   int fromscc = 0;
   cd->get_the_scc(fromv, fromscc);

   int toscc = 0;
   cd->get_the_scc(tov, toscc);


   if (flag == ALTERNATIONEDGE && sourcescc == fromscc && targetscc == toscc)
     {
           return_val = 1;
     }
   else
     {
       int result = 0;
       cd->reachable(toscc,sourcescc,result);
       if (result)
          return_val = 1;
       else
         {
           result = 0;
           cd->reachable(targetscc,fromscc,result);
           return_val = result;
         }
     }
@)
*wrapper* Meta_repetition_edge
*prefix*
(@
   int sourcescc = 0;
   cd->get_vert_scc(sourcev, sourcescc);
   int targetscc = 0;
   cd->get_vert_scc(targetv, targetscc);

   Vertex* fromv = NULL;
   Vertex* tov = NULL;

   from->get_single_vertex(fromv);
   to->get_single_vertex(tov);

   int fromscc = 0;
   cd->get_the_scc(fromv, fromscc);

   int toscc = 0;
   cd->get_the_scc(tov, toscc);

   if (flag == REPETITIONEDGE && sourcescc == fromscc && targetscc == toscc)
     {
       return_val = 1;
     }
   else
     {
       int result = 0;
       cd->reachable(toscc,sourcescc,result);
       if (result)
          return_val = 1;
       else
         {
           result = 0;
           cd->reachable(targetscc,fromscc,result);
           return_val = result;
         }
     }
@)

*C*
(@
#define CONSTRUCTIONEDGE 1
#define REPETITIONEDGE 2
#define INHERITANCEEDGE 3
#define ALTERNATIONEDGE 4
@)