/* 
$Id: shared_lists.cpp,v 1.11 2002/03/21 15:44:00 dirkl Exp $
$Log: shared_lists.cpp,v $
Revision 1.11  2002/03/21 15:44:00  dirkl
- additional Information about the PVS-files (Output from 'cvs status file')
- started support for multiple connect-outside functions

Revision 1.10  2002/02/25 23:34:14  dirkl
- connections of bus_protocol get now connected to the top-level module(very uggly implementation)

Revision 1.9  2001/11/28 15:33:18  dirkl
- added error message for function with same name except for case; Xilinx Foundation can't handle such Functions

Revision 1.8  2001/01/18 16:04:48  sbeyer

added copy constructors

Revision 1.7  2001/01/12 16:24:48  sbeyer

C++-files now use 'class string' instead of 'char *'-stuff

Revision 1.6  2001/01/12 09:27:31  sbeyer

added support for overload detection in parameters/actuals
(parameter/actuals names for any function/type must be unique)
made compse_path recursive (now supports all relative paths)

Revision 1.5  2001/01/11 16:22:27  sbeyer

added error macros to header and cosmetic changes in implementation

Revision 1.4  2001/01/11 11:43:32  sbeyer

added debug output (operator <<) to the different structs

Revision 1.3  2001/01/09 16:27:32  sbeyer
*** empty log message ***

*/
#include "shared_lists.h"
#include "tools.h"

list<defined_type> defined_types;
list<defined_function> defined_functions;
list<defined_function> root_functions;

list<connect_outside> connect_outsides;

actuals_array::actuals_array(const actuals_array &act)
{
  num=act.num; 
  for (int i=0;i<MAX_NUM_ACTUALS;i++)
    names[i]=act.names[i];
}

ostream& operator <<(ostream& ostr, const actuals_array& acts)
{
  int j;
  if(acts.num)
  {
    ostr << "\t" << acts.num << " Actual(s): ";
    for (j=0;j+1<acts.num;j++)
      ostr << acts.names[j] << ", ";
    ostr << acts.names[j] << endl;
  }
  else
    ostr << "\tkeine Actuals" << endl;
  return ostr;
}

bool actuals_array::is_actual(const string &name) const
{
  for(int i=0;i<num;i++) 
    if (name==names[i])
      return true;
  return false;
}

params_array::params_array(const params_array &params)
{
  num=params.num; 
  for (int i=0;i<MAX_NUM_ACTUALS;i++)
  {
    names[i]=params.names[i];
    roots[i]=params.roots[i];
  }
}

ostream& operator <<(ostream& ostr, const params_array &params)
{
  string tmp;
  if(params.num)
  {
    ostr << "\t" << params.num << " Paramter: ";
    for (int j=0;j+1<params.num;j++)
    {
      ostr << params.names[params.num-j-1] 
           << " in Datei " << params.names[params.num-j-1] << ".gdl, ";
      tmp = params.names[params.num-j-1] + ".gdl";
      gdl_ausgabe(tmp.c_str(),params.roots[params.num-j-1]);  
    }
    ostr << params.names[0]
         << " in Datei " << params.names[0] << ".gdl" << endl;
    tmp = params.names[0] + ".gdl";
    gdl_ausgabe(tmp.c_str(),params.roots[0]);
  }
  else
    ostr << "\tkeine Parameter" << endl;
  return ostr;
}

bool params_array::is_parameter(const string &name, const knoten *&root) const
{
  for(int i=0;i<num;i++) 
    if (name==names[i])
    {
      root=roots[i];
      return true;
    }
  return false;
}

defined_type::defined_type(const defined_type &type)
{
  name     =type.name;
  root     =type.root;
  p_actuals=type.p_actuals;
  params   =type.params;
}

ostream& operator <<(ostream& ostr, const defined_type &type)
{
  ostr << "Name: " << type.name 
       << "\n\tBaum: in Datei " << type.name << ".gdl\n"
       << *type.p_actuals 
       << type.params;
  string tmp=type.name + ".gdl";
  gdl_ausgabe(tmp.c_str(),type.root);
  return ostr;
}

ostream& operator <<(ostream& ostr, const defined_function &function)
{
  ostr << (defined_type)function 
       << "\tReturn Type in Datei " << function.name << "_.gdl\n";
  string tmp = function.name + "_.gdl";
  gdl_ausgabe(tmp.c_str(),function.return_type);
  return ostr;
}

bool is_type_defined(const string &name, 
                     defined_type &ret)
{
  list<defined_type>::const_iterator i=defined_types.begin();
  while (i!=defined_types.end())
  {
    if (i->name==name)
    {
      ret = *i;
      return true;
    }
    i++;
  }
  return false;
};

bool is_function_defined(const string &name, 
                         defined_function &ret)
{
  list<defined_function>::const_iterator i=defined_functions.begin();
  while (i!=defined_functions.end())
  {
    if (i->name==name)
    {
      ret = *i;
      return true;
    }
    i++;
  }
  return false;
};

int cmp_nocase(const string& s, const string& s2)
{
  string::const_iterator p=s.begin();
  string::const_iterator p2=s2.begin();


  while (p!=s.end() && p2!=s2.end())
    {
      if (toupper(*p)!=toupper(*p2)) return (toupper(*p)<toupper(*p2)) ? -1:1;
      ++p;
      ++p2;
    }
  return (s2.size()==s.size()) ? 0: (s.size()<s2.size())? -1:1;
}

bool is_feedthrough_function(const string &name, string &parameter)
{
  string ret="";
  bool gefunden=false;
  list<connect_outside>::const_iterator i=connect_outsides.begin();

  while (i!=connect_outsides.end())
    {
      list<string>::const_iterator j=i->feedthrough_functions.begin();
      
      while (j!=i->feedthrough_functions.end())
	{
	  if (cmp_nocase(*j,name)==0)
	    {     
	      gefunden=true;
	      ret+=i->parameterstring;
	    }
	  j++;
	}

      i++;
    }

  if (gefunden)
    {
      parameter=ret;
      return true;
    }
  else
    {
      return false;
    }
}

bool is_function_defined_caseinsensitive(const string &name, 
					 defined_function &ret)
{
  list<defined_function>::const_iterator i=defined_functions.begin();
  while (i!=defined_functions.end())
  {
    if (cmp_nocase(i->name,name)==0)
    {
      ret = *i;
      return true;
    }
    i++;
  }
  return false;
};