#include "semcheck.h"

/*****************************************************************
**      File Name : COMMON_EXPANSION.c                          **
*****************************************************************/


/*#include <string.h>*/
#include <ctype.h>

Cd_graph *Cd_graph::COMMON_EXPANSION()
{
 if (adjacencies->containCommonParts()==0) return this;
 adjacencies->FOR_IMM_PARTS();   // for immediate parts
 adjacencies->COMMON_COLLECT();
 return adjacencies->COMMON_EXPANSION(terminal_sets,foreign_classes);
}

int Adjacency_Nlist::containCommonParts()
{
 Adjacency_list_iterator next(*this);
 Adjacency_              each;
 while (each = next())
   if (each->containCommonParts()==1)
      return 1;
 return 0;
}

int Adjacency::containCommonParts()
{
   return ns->containCommonParts();
}

int Neighbors::containCommonParts() 
{
   return 0;
}

int Neighbors_wc::containCommonParts()  
{ 
   return 0;
}

int Alternat_ns::containCommonParts()   
{
   if ((this->get_construct_ns()!=NULL)&&(this->get_construct_ns()->list_length()>0))
      return 1;
   else
      return 0;
}

/*    Adjacency_Nlist ~ Adjacency { Adjacency } .
      DFS traverse by selecting alt. edges.This is top level.
*/
void Adjacency_Nlist::FOR_IMM_PARTS()   // for immediate parts
{
     Adjacency_list_iterator next_Adjacency(*this);
     Adjacency_ each_Adjacency;
     while (each_Adjacency=next_Adjacency())
	if (each_Adjacency->IS_NOT_REP()==1)
	    each_Adjacency->FOR_IMM_PARTS();
        else
	    each_Adjacency->rset_dfs(new DemNumber());
}

int Adjacency::IS_NOT_REP()
{
   return ns->IS_NOT_REP();
}

int Neighbors::IS_NOT_REP()
{
    return 1;
}

int Repetit_n::IS_NOT_REP()
{
    return 0;
}

void Adjacency::FOR_IMM_PARTS()
{
   expanded_common_parts = new Common_parts_List();
   ns->FOR_IMM_PARTS(expanded_common_parts,this);
}

void Neighbors::FOR_IMM_PARTS(Common_parts_List* expanded_common_parts,Adjacency *owner)
{
}

void Construct_ns::FOR_IMM_PARTS(Common_parts_List* expanded_common_parts,Adjacency *owner)
{
    this->get_construct_ns()->
	    COMMON_COLLECT_ITSELF(expanded_common_parts,owner);
}

void Alternat_ns::FOR_IMM_PARTS(Common_parts_List* expanded_common_parts,Adjacency *owner)
{
 if (this->get_construct_ns())
   this->get_construct_ns()->
     COMMON_COLLECT_ITSELF(expanded_common_parts,owner);
}

void Any_vertex_List::COMMON_COLLECT_ITSELF(Common_parts_List* expanded_common_parts,Adjacency *owner)
{
   Common_parts *common_parts = new Common_parts(owner,this);
   expanded_common_parts->append(common_parts);
}

void Adjacency_Nlist::COMMON_COLLECT()
{

 Adjacency *adjacency;

 while (this->COMMON_COLLECT_FIND_UNMARKED()) ;

//find an unmarked vertex which should not be repetition vertex
//(I have marked them at the beginning,and find whether its
//superclasses have been marked, if all are marked,collect parts
//in the order of their occurrence otherwise collect them first.
}

int Adjacency_Nlist::COMMON_COLLECT_FIND_UNMARKED()
{
  Adjacency_list_iterator next_Adjacency(*this);
  Adjacency_ each_Adjacency;
  Adjacency_ adj;

  while (each_Adjacency=next_Adjacency())
    if (!each_Adjacency->get_dfs())
	  break;
  if (each_Adjacency)
  {
     adj = this->FIND_ALL_SUPERS_MARKED(each_Adjacency);
     adj->COMMON_COLLECT(this);
     adj->rset_dfs(new DemNumber());
     return 1;
  }
  return 0;
}

Adjacency * Adjacency_Nlist::FIND_ALL_SUPERS_MARKED(Adjacency *adj)
{
  Adjacency_list_iterator next_Adjacency(*this);
  Adjacency * each_Adjacency;

  while (each_Adjacency=next_Adjacency())
    if ((!each_Adjacency->get_dfs()) &&
        (each_Adjacency->LL1_SUPERCLASS(this,(Vertex*)adj->get_source())))
         return this->FIND_ALL_SUPERS_MARKED(each_Adjacency);
  return adj;
}

void Adjacency::COMMON_COLLECT(Adjacency_Nlist *adj_Nlist)
{
 Adjacency_list_iterator next_Adjacency(*adj_Nlist);
 Adjacency * each_Adjacency;

 while (each_Adjacency=next_Adjacency())
  if (each_Adjacency->AS_AN_ALTERNATIVE((Vertex*)this->get_source()))
   this->COMMON_COLLECT_PASS_PARTS((Common_parts_List *)each_Adjacency->get_expanded_common_parts());
}




void Adjacency::COMMON_COLLECT_PASS_PARTS(Common_parts_List* passed_parts)
{
   Common_parts_List * result = new Common_parts_List();
   Common_parts_list_iterator next_for_copy(*expanded_common_parts);
   Common_parts_ each_for_copy;
   while (each_for_copy= next_for_copy())
       result->append(new Common_parts((Adjacency *)each_for_copy->get_owner(),
				       each_for_copy->get_common()));

   Common_parts_list_iterator n_parts(*passed_parts);
   Common_parts_ each_parts;

   while (each_parts = n_parts())
   {
      Common_parts_list_iterator next(*expanded_common_parts);
      Common_parts_ each;
      while (each= next())
        if (((char*)each_parts->get_owner()->get_source())==
              ((char*)g_equal(each->get_owner()->get_source())))
   	   break;
      if (!each)
         result->append(each_parts);
   }
   expanded_common_parts = result;

}

int Adjacency::AS_AN_ALTERNATIVE(Vertex * avertex)
{
    return ns->AS_AN_ALTERNATIVE(avertex);
}

int Neighbors::AS_AN_ALTERNATIVE(Vertex * avertex)
{
    return 0;
}

int Alternat_ns::AS_AN_ALTERNATIVE(Vertex * avertex)
{
 return alternat_ns->AS_AN_ALTERNATIVE(avertex);
}

int Term_Bar_list::AS_AN_ALTERNATIVE(Vertex * avertex)
{
   Term_list_iterator next_term(*this);
   Term_ each_term;

   while (each_term = next_term())
      if (each_term->get_vertex()->g_equal(avertex))
	 return 1;
   return 0;
}

Cd_graph *Adjacency_Nlist::COMMON_EXPANSION(Vertex_Comma_list *terminals,Term_Comma_list *fclasses)
{

   Cd_graph * expanded_cd = new Cd_graph();
   expanded_cd->set_terminal_sets(terminals);
   expanded_cd->set_foreign_classes(fclasses);
   expanded_cd->COMMON_EXPANSION(this);
   return expanded_cd;
}

void Cd_graph::COMMON_EXPANSION(Adjacency_Nlist *adj_Nlist)
{
    adjacencies = new Adjacency_Nlist();
    adjacencies->COMMON_EXPANSION(adj_Nlist);
}

void Adjacency_Nlist::COMMON_EXPANSION(Adjacency_Nlist *adj_Nlist)
{
  Adjacency_list_iterator next_Adjacency(*adj_Nlist);
  Adjacency_ each_Adjacency;
  Adjacency_ new_Adjacency;
  while (each_Adjacency=next_Adjacency())
  {
     new_Adjacency = each_Adjacency->COMMON_EXPANSION();
     this->append(new_Adjacency);
  }
}

Adjacency * Adjacency::COMMON_EXPANSION()
{
   Adjacency_ adj = new Adjacency();
   adj->rset_ns(ns->COMMON_EXPANSION(expanded_common_parts));
   adj->rset_source((Vertex*)source->g_copy());
   if (parameters)
      adj->rset_parameters((Vertex_Comma_list*)parameters->g_copy());
   else
      adj->rset_parameters((Vertex_Comma_list*)NULL);
   return adj;
}

Neighbors* Neighbors::COMMON_EXPANSION(Common_parts_List *expanded_common_parts)
{
	return NULL;
}


Neighbors* Repetit_n::COMMON_EXPANSION(Common_parts_List *expanded_common_parts)
{
    return (Neighbors*) this->g_copy();
}

Neighbors* Neighbors_wc::COMMON_EXPANSION(Common_parts_List *expanded_common_parts)
{
	return NULL;
}



Neighbors* Construct_ns::COMMON_EXPANSION(Common_parts_List *expanded_common_parts)
{

  Construct_ns * new_adj = new Construct_ns();
  new_adj->rset_construct_ns(expanded_common_parts->COMMON_EXPANSION());
  return (Neighbors*)new_adj;
}


Neighbors* Alternat_ns::COMMON_EXPANSION(Common_parts_List *expanded_common_parts)
{
 Alternat_ns *adj = new Alternat_ns();
 adj->rset_alternat_ns((Term_Bar_list*)alternat_ns->g_copy());
 //adj->rset_construct_ns(new Any_vertex_List());
 adj->rset_construct_ns(expanded_common_parts->COMMON_EXPANSION());
 adj->rset_common(new Common());
 return (Neighbors* ) adj;
}


Any_vertex_List * Common_parts_List::COMMON_EXPANSION()
{
   Any_vertex_List *expanded = new Any_vertex_List();

   Common_parts_list_iterator next(*this);
   Common_parts_ each;
   while (each = next())
      expanded->COMMON_EXPANSION_APPEND(each);
   return expanded;
}



void Any_vertex_List::COMMON_EXPANSION_APPEND(Common_parts *each_parts)
{
    each_parts->COMMON_EXPANSION_APPEND(this);
}


void Common_parts::COMMON_EXPANSION_APPEND(Any_vertex_List *result)
{
     if (owner==NULL)
     {
	cerr << "System Error : from common expansion." << endl;
	exit(1);
     }
     Any_vertex_list_iterator next_av(*common);
     Any_vertex_ each_av;
     while (each_av = next_av())
     {
	 each_av->rset_origin(owner);
	 result->append(each_av);
     }
}


Any_vertex_List * Any_vertex_List::ALLOW_OVERRIDE()
{
    Any_vertex_List *reversed = new Any_vertex_List();
    Any_vertex_List *result   = new Any_vertex_List();

    Any_vertex_list_iterator next_av(*this);
    Any_vertex_ each_av;
    while (each_av = next_av())
	reversed->insert(each_av);


    Any_vertex_list_iterator next_any_vertex(*reversed);
    Any_vertex_ each_any_vertex;
    while (each_any_vertex = next_any_vertex())
    {
       if (each_any_vertex->NOT_SYN_INH())
	 if (result->OCCURR_IN_SUB(each_any_vertex))
	    continue;
       result->insert(each_any_vertex);
    }
    return result;
}


int Any_vertex_List::OCCURR_IN_SUB(Any_vertex *each_av)
{
    Any_vertex_list_iterator next_any_vertex(*this);
    Any_vertex_ each_any_vertex;
    while (each_any_vertex = next_any_vertex())
    {
       if (each_any_vertex->NOT_SYN_INH())
           if (strcmp(each_any_vertex->UNIQUE_LABELS_partname(),
			each_av->UNIQUE_LABELS_partname())==0)
             return 1;
    }
    return 0;
}

int Any_vertex::NOT_SYN_INH()
{
   return 1;
}

int Syntax_vertex::NOT_SYN_INH() 
{ 
   return 0; 
}
int Inherit_term::NOT_SYN_INH() 
{ 
   return 0; 
}