#include "semcheck.h"

/*
 * ASSIGNMENT I-III   PARAMETERS EXPANDMENT
 *
 * Tong Liu (246-59-5620)
 * 
 */

/* 
 * 1.This programe will travsers all Adjacency_List,
 *    Recusively find the all function call,
 * 2.and  call function DO_exp_param to expand the the parameters
 *    in the definition
 */


#define LEN_PART_NAME 100

Cd_graph * Demeter_in::exp_param( )
{
    return input->exp_param();
}

Cd_graph * Input::exp_param()
{
	return NULL;
}

Cd_graph * Cd_graph::exp_param()
{
   Cd_graph * expanded_cd = (Cd_graph *)this->g_copy();
   expanded_cd->exp_param_ON_COPY();
   expanded_cd->rset_terminal_sets(terminal_sets);
   return expanded_cd;
}

Cd_graph * Cd_graph::exp_param_ON_COPY()
{
   adjacencies->exp_param(this);
   Adjacency_list_iterator next_arg(*adjacencies);
   Adjacency_   each_arg;
   Adjacency_Nlist * deleted = new Adjacency_Nlist();
   while (each_arg = next_arg())
      if (!each_arg->get_parameters())
	 deleted->append(each_arg);
   adjacencies = deleted;
   return NULL;
}

//Adjacency-nlist ~ Adjacency { Adjacency } .
void Adjacency_Nlist::exp_param(Cd_graph *cdgraph)
{

  while (1)
  {
    Adjacency_list_iterator next_arg(*this);
    Adjacency_   each_arg;
    while (each_arg = next_arg())
      if (each_arg->CONTAIN_PAR_INT()) break;
    if (each_arg) each_arg->exp_param(cdgraph);
    else
	 break;
  }

}

void Adjacency::exp_param(Cd_graph *cdgraph)
{
    ns->exp_param(cdgraph);
}

void Neighbors::exp_param(Cd_graph *cdgraph)
{
}          

void Neighbors_wc::exp_param(Cd_graph *cdgraph)
{
}

void Repetit_n::exp_param(Cd_graph *cdgraph)
{
}

void Construct_ns::exp_param(Cd_graph *cdgraph)
{
  this->get_construct_ns()->exp_param(cdgraph);
}

void Alternat_ns::exp_param(Cd_graph *cdgraph)
{
  this->get_construct_ns()->exp_param(cdgraph);
  alternat_ns->exp_param(cdgraph);
}


void Term_Bar_list::exp_param(Cd_graph *cdgraph)
{
   Term_list_iterator  next_arg(*this);
   Term_  each_arg;

   while(each_arg=next_arg())
      each_arg->exp_param(cdgraph);
}



void Any_vertex_List::exp_param(Cd_graph *cdgraph)
{
    Any_vertex_list_iterator  next_arg(*this);
    Any_vertex_  each_arg;

     while(each_arg= next_arg())
       if (each_arg->CONTAIN_PAR_INT())
               each_arg->exp_param(cdgraph);      // expand a par once
}

void Any_vertex::exp_param(Cd_graph *cdgraph)
{
}
 
void Inherit_term::exp_param(Cd_graph *cdgraph)
{
    inherited->exp_param(cdgraph);
}

void Optional_term::exp_param(Cd_graph *cdgraph)
{
    opt->exp_param(cdgraph);
}

void Opt_labeled_term_Sandwich::exp_param(Cd_graph *cdgraph)
{
    inner->exp_param(cdgraph);
}


void Opt_labeled_term::exp_param(Cd_graph *cdgraph)
{
    vertex->exp_param(cdgraph);
}

//Term : Normal *common* 
//     <vertex> vertex
//     ["(" < actual_parameters> Term_Comma_list")"]
// this is a recursion --- cun

void Term::exp_param(Cd_graph *cdgraph)
{

  if (!actual_parameters) return;

   actual_parameters->exp_param(cdgraph);

/*after this,there is no argument for each term in the list*/

   Vertex_Comma_list *act_list = new Vertex_Comma_list();
   Term_list_iterator next_Term(*actual_parameters);
   Term_ each_Term;
   while (each_Term=next_Term())
       act_list->append((Vertex *) each_Term->get_vertex()->g_copy());

   cdgraph->DO_exp_param(vertex, act_list); 
   this->exp_param_CHANGE_NON();

}


void Term_Comma_list::exp_param(Cd_graph *cdgraph)
{
   Term_list_iterator  next_arg(*this);
   Term_ each_arg;
   while (each_arg = next_arg())
        each_arg->exp_param(cdgraph);   
 }

/* CHANGE PARAMETERS EXPRESSION:
 *  1. for term:              A(X) TO X_A              
 *  2. for Vertex_Comma_list: A,B to B__A
 *  3. for Term_Comma_list: A,B   B__A
 *  This function works when the actual_parameters are not nested 
 */


//Term :Normal common* <vertex> vertex ["(" < actual_parameters> Term_Comma_list")"]
void Term::exp_param_CHANGE_NON()
{
   char *a_par_name, *fun_name; 
   Term_Comma_list * reversed = new Term_Comma_list();

   Term_list_iterator  next_arg(*actual_parameters);
   Term_  each_arg;
   while(each_arg=next_arg())
       reversed->insert(each_arg);

   a_par_name = new char[LEN_PART_NAME];
   fun_name = new char[LEN_PART_NAME];
   a_par_name =reversed->exp_param_GET_NAME();
   fun_name = (vertex->get_vertex_name())->get_val();
   strcat(a_par_name, "_");
   strcat(a_par_name,fun_name);
   DemIdent *iIdent = new DemIdent ( a_par_name );
   Vertex* iVertex = new Vertex(); 
   iVertex->set_data_member(0, iIdent);
   vertex=(Vertex*)iVertex->g_copy();
   this->rset_vertex(iVertex);
   this->rset_actual_parameters(NULL );

}



char* Vertex_Comma_list::exp_param_GET_NAME()
{
   Vertex_Comma_list * reversed = new Vertex_Comma_list ();
   Vertex_list_iterator  next(*this);
   Vertex_ each;
   while (each= next())
       reversed->insert(each);

   char* a_par_name; 
   char* tmp_1;
   char* tmp_2;

   a_par_name = new char[LEN_PART_NAME];
   tmp_1 = new char[LEN_PART_NAME];
   tmp_2 = new char[LEN_PART_NAME];
   strcpy(tmp_1,"");
   strcpy(tmp_2,"");
   strcpy(a_par_name,"");
   Vertex_list_iterator  next_arg(*reversed);
   Vertex_ each_arg;
   while (each_arg = next_arg())
     {
      strcpy(a_par_name, tmp_2);
      tmp_1=(each_arg->get_vertex_name())->get_val();
      strcat(a_par_name, tmp_1);
      strcpy(tmp_2,a_par_name);
      strcat(tmp_2, "__");
     }
     return a_par_name;
}

char* Term_Comma_list::exp_param_GET_NAME()
{
   Term_list_iterator  next_arg(*this);
   Term_ each_arg;
   char* a_par_name; 
   char* tmp_1;
   char* tmp_2;

   a_par_name = new char[LEN_PART_NAME];
   tmp_1 = new char[LEN_PART_NAME];
   tmp_2 = new char[LEN_PART_NAME];
   strcpy(tmp_1,"");
   strcpy(tmp_2,"");
   strcpy(a_par_name,"");
   while (each_arg = next_arg())
     {
      strcpy(a_par_name, tmp_2);
      tmp_1=each_arg->exp_param_GET_NAME();
      strcat(a_par_name, tmp_1);
      strcpy(tmp_2,a_par_name);
      strcat(tmp_2, "__");
     }
     return a_par_name;

 }


char* Term::exp_param_GET_NAME() 
{
   char* new_vpar_name = (vertex->get_vertex_name())->get_val();
   return new_vpar_name;
}

/*
 * Assignment I-III
 *
 * This is the programe DO_exp_param.c 
 * This programe expand the parameter in  function call
 */
    
 


void Cd_graph::DO_exp_param(Vertex *fun_name, Vertex_Comma_list *par_names)
{
    adjacencies->DO_exp_param(this,fun_name, par_names);
}

void Adjacency_Nlist::DO_exp_param(Cd_graph *cdgraph,Vertex *fun_name, Vertex_Comma_list *par_names)
{
    Adjacency_list_iterator next_arg(*this);
    Adjacency_   each_arg;
    while (each_arg = next_arg())
      if (each_arg->get_source()->g_equal(fun_name))    
	 break;
    if ((!each_arg)||(!each_arg->get_parameters()))
    {
       cerr << toolname << ": error: on line " << fun_name->get_vertex_name()->get_line_number() << " '";
       fun_name->pp(cerr);
       cerr << "' is not a parameterized class name.\n" << endl;
       exit(-1);
    }
    Adjacency *iAdjacency = (Adjacency*)each_arg->g_copy();
    iAdjacency->DO_exp_param(cdgraph,fun_name, par_names);
}

int Adjacency::DO_exp_param(Cd_graph *cdgraph,Vertex *fun_name, Vertex_Comma_list *par_list)
{
char *par_name;

Vertex_Comma_list *formal_par_name = (Vertex_Comma_list *) parameters->g_copy();

par_name = new char[LEN_PART_NAME];
strcat(par_name, "");
par_name=par_list->exp_param_GET_NAME();
strcat(par_name,"_");
strcat(par_name,(source->get_vertex_name())->get_val());
DemIdent *iIdent = new DemIdent(par_name);
Vertex *iVertex = new Vertex(iIdent);

if (cdgraph->exp_param_DONE(iVertex)) return 0;

this->rset_source(iVertex);
this->rset_parameters(NULL);
ns->DO_exp_param(cdgraph, formal_par_name, par_list);
cdgraph->get_adjacencies()->append(this);
return 1;

}

int Cd_graph::exp_param_DONE(Vertex * iVertex)
{
    return adjacencies->exp_param_DONE(iVertex);
}

int Adjacency_Nlist::exp_param_DONE(Vertex * iVertex)
{
    Adjacency_list_iterator next_Adjacency(*this);
    Adjacency_ each_Adjacency;
    while (each_Adjacency=next_Adjacency())
       if (each_Adjacency->get_source()->g_equal(iVertex))
	   return 1;
    return 0;
}

/*
 * In the following parts, the programe will traverse the Repetit_n
 * and expand the parameter in function definition
 */
 
void Neighbors::DO_exp_param(   Cd_graph *cdgraph, Vertex_Comma_list * fun_name, Vertex_Comma_list *par_list)
{
}          

//Neighbors : Neighbors_wc | Repetit_n

void Neighbors_wc::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list  *formal_par_name, Vertex_Comma_list *par_list)
{
}

void Alternat_ns::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
  this->get_construct_ns()->DO_exp_param(cdgraph,formal_par_name, par_list);
  alternat_ns->DO_exp_param(cdgraph,formal_par_name, par_list);
}


void Term_Bar_list::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
   Term_list_iterator  next_arg(*this);
   Term_  each_arg;

   while(each_arg=next_arg())
     each_arg->DO_exp_param(cdgraph, formal_par_name, par_list);

}



void Construct_ns::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
  this->get_construct_ns()->DO_exp_param(cdgraph,formal_par_name,par_list);
}


void Any_vertex_List::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
    Any_vertex_list_iterator  next_arg(*this);
    Any_vertex_  each_arg;

     while(each_arg=next_arg())
        each_arg->DO_exp_param(cdgraph,formal_par_name,par_list);
    
}

void Any_vertex::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
}

void Opt_labeled_term::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
    vertex->DO_exp_param(cdgraph,formal_par_name,par_list);
}


void Optional_term::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name,
Vertex_Comma_list *par_list)
{
    opt->DO_exp_param(cdgraph,formal_par_name,par_list); 
}

void Opt_labeled_term_Sandwich::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name,Vertex_Comma_list *par_list)
{
    inner->DO_exp_param(cdgraph,formal_par_name,par_list); 
}

void Inherit_term::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name,Vertex_Comma_list *par_list)
{
   inherited->DO_exp_param(cdgraph,formal_par_name,par_list);
}

void Term_Comma_list::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
   Term_list_iterator  next_arg(*this);
   Term_ each_arg;
   while (each_arg = next_arg())
      each_arg->DO_exp_param(cdgraph,formal_par_name,par_list);
}





void Term::DO_exp_param(Cd_graph *cdgraph, Vertex_Comma_list *formal_par_name, Vertex_Comma_list *par_list)
{
 Vertex_list_iterator next_Vertex(*formal_par_name);
 Vertex_ each_Vertex;
 Vertex_list_iterator next_Vertex_act(*par_list);
 Vertex_ each_Vertex_act;


 if (actual_parameters)
  actual_parameters->DO_exp_param(cdgraph,formal_par_name,par_list);

 while ((each_Vertex_act=next_Vertex_act())
     && (each_Vertex=next_Vertex()))
    if( vertex->g_equal(each_Vertex))
    {
    	vertex=(Vertex*)(each_Vertex_act->g_copy());
        return;
    }
   
}


void Repetit_n::DO_exp_param(Cd_graph *cdgraph,Vertex_Comma_list *formal_par, Vertex_Comma_list *par_list)
{
    sandwiched->DO_exp_param(cdgraph,formal_par,par_list);
}

void Kernel_Sandwich::DO_exp_param(Cd_graph *cdgraph,Vertex_Comma_list *formal_par, Vertex_Comma_list *par_list)
{
   inner->DO_exp_param(cdgraph,formal_par,par_list);
}

void Kernel::DO_exp_param(Cd_graph *cdgraph,Vertex_Comma_list *formal_par, Vertex_Comma_list *par_list)
{
   if (nonempty)
      nonempty->DO_exp_param(cdgraph,formal_par, par_list);
   repeated->DO_exp_param(cdgraph,formal_par,par_list);
}

void Term_Sandwich::DO_exp_param(Cd_graph *cdgraph,Vertex_Comma_list *formal_par, Vertex_Comma_list *par_list)
{
   inner->DO_exp_param(cdgraph,formal_par,par_list);
}

/* 
 * This program Adjacency type:
 *
 * 1).nonpar prod. contains par-int should be in a Adjacency where:
 *        1: parameter = NULL
 *        2: actual_parameter ! = NULL
 *    return: 1 
 *        
 * 2). par prod. should be in a Adjacency where:
 *        1: parameter != NULL
 *     no parameter Adjacency:
 *        1:parameter = NULL
 *        2:actual_parameter = NUL
 *    return: 0
 */



int Adjacency::CONTAIN_PAR_INT()
{
    if (parameters) return 0;   //do not expand it
    return ns->CONTAIN_PAR_INT();
}

//Neighbors : Neighbors_wc

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


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

int Alternat_ns::CONTAIN_PAR_INT()
{
    if (this->get_construct_ns()->CONTAIN_PAR_INT()) return 1;
    return alternat_ns->CONTAIN_PAR_INT(); 
}

int Term_Bar_list::CONTAIN_PAR_INT()
{
  Term_list_iterator next_arg(*this);
  Term_ each_arg;

  while(each_arg=next_arg())
    if (each_arg->get_actual_parameters()) return 1;
  return 0; 
}

int Construct_ns::CONTAIN_PAR_INT()
{
   return (this->get_construct_ns()->CONTAIN_PAR_INT());
}


int Any_vertex_List::CONTAIN_PAR_INT()
{
    Any_vertex_list_iterator  next_arg(*this);
    Any_vertex_  each_arg;

    while(each_arg= next_arg())
         if(each_arg->CONTAIN_PAR_INT()) return 1;
    return 0;
 }

int Any_vertex::CONTAIN_PAR_INT()
{
    return 0;
}

int Opt_labeled_term::CONTAIN_PAR_INT()
{
  if (vertex->get_actual_parameters()) return 1;
  return 0;
}

int Optional_term::CONTAIN_PAR_INT()
{
  return opt->CONTAIN_PAR_INT();
}

int Opt_labeled_term_Sandwich::CONTAIN_PAR_INT()
{
  return inner->CONTAIN_PAR_INT();
}