/* 
$Id: shared_lists.h,v 1.19 2002/12/02 14:36:57 sbeyer Exp $
$Log: shared_lists.h,v $
Revision 1.19  2002/12/02 14:36:57  sbeyer
* ported source to gcc-3.2 (still compiles AND WORKS with gcc-2.9x)

Revision 1.18  2002/03/22 19:25:40  dirkl
*** empty log message ***

Revision 1.17  2002/03/21 16:55:50  dirkl
- support for multiple connect_outside functions seems to work

Revision 1.16  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.15  2002/02/25 23:34:14  dirkl
- connections of bus_protocol get now connected to the top-level module(very uggly implementation)

Revision 1.14  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.13  2001/06/22 10:28:29  dirkl
- prepared new config-file format
- excluded context pvsctl

Revision 1.12  2001/01/23 15:58:02  sbeyer

moved macros knot_error, raise_error from shared_lists.h to backend.h

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

added copy constructors

Revision 1.10  2001/01/15 16:08:35  sbeyer

cosmetics

Revision 1.9  2001/01/13 17:00:45  sbeyer

cosmetic changes...

Revision 1.8  2001/01/12 16:24:49  sbeyer

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

Revision 1.7  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.6  2001/01/11 16:22:26  sbeyer

added error macros to header and cosmetic changes in implementation

Revision 1.5  2001/01/11 11:43:33  sbeyer

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

Revision 1.4  2001/01/10 18:12:29  sbeyer

added params_array to defined_types_and_functions (+support)

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

*/
#ifndef shared_lists_h
#define shared_lists_h

#include <list>
#include <string>
#include <iostream>
#include "backend.h"

using namespace std;

// an actuals_array is generated for every theory
struct actuals_array
{
  unsigned int num;
  string       names[MAX_NUM_ACTUALS];

  // default-constructor creates empty array
  actuals_array()
    { num=0;}

  actuals_array(const actuals_array &act);

  bool add_actual(const string &_actual)
    { if(num<MAX_NUM_ACTUALS) names[num++]=_actual; 
      return num<=MAX_NUM_ACTUALS;}

  friend ostream& operator <<(ostream& ostr, const actuals_array &acts);

  bool is_actual(const string &name) const;
};

// the parameters of defined functions/types are stored
// in a params_array
struct params_array
{
  unsigned int  num;
  string        names[MAX_NUM_ACTUALS];
  const knoten *roots[MAX_NUM_ACTUALS];

  // default-constructor creates empty array
  params_array()
    { num=0; }

  params_array(const params_array &params);

  bool add_param(const string &_param,const knoten *_root,const bool warning=false)
    { if(num<MAX_NUM_ACTUALS) 
      { names[num]=_param;
        roots[num++]=_root; }
      return num<=MAX_NUM_ACTUALS;}

  friend ostream& operator <<(ostream& ostr, const params_array &params);

  bool is_parameter(const string &name, const knoten *&root) const;
};

// for types, four items are stored:
// * the root node in the parse tree (type_expr)
// * the name (which is unique)
// * a pointer to the theory's actuals_array
// * the functions/types parameter names/root nodes (as params_array)
struct defined_type
{
  const knoten *root;
  string        name;
  const actuals_array *p_actuals;
  params_array params;

  // default-constructor
  defined_type()
    { root=0; p_actuals=0; }

  defined_type(const defined_type &type);

  // full constructor
  defined_type(const knoten        *_root, 
               const string        &_name, 
               const actuals_array &_actuals,
               const params_array  &_params)
    { root=_root; name=_name;
      p_actuals=&_actuals; params=_params; }

  friend ostream& operator <<(ostream& ostr, const defined_type &type);
};

// for functions, one additional item is stored:
// the return type's root-pointer
// additionlly, the root node is of type expr instead of type_expr

struct defined_function:public defined_type
{
  const knoten *return_type;

  // default-constructor
  defined_function()
    { return_type=0; }

  defined_function(const defined_function &function) : defined_type(function)
    { return_type=function.return_type; }

  defined_function(const knoten        *_root, 
                   const string        &_name, 
                   const actuals_array &_actuals,
                   const params_array  &_params,
                   const knoten        *_return_type)
    : defined_type(_root,_name,_actuals,_params)
    { return_type=_return_type; }

  friend ostream& operator <<(ostream& ostr, const defined_function &function);
};

// stores info about connect_outside functions
struct connect_outside
{
  string functionname;
  bool first;
  defined_function function;
  string parameterstring;
  string bindings;
  string original_functionname;
  
  // enthält alle Funktionen, die zwischen dem Toplevelmodul und der zu verbindenden
  // Funktion liegen
  list<string> feedthrough_functions;
};

// the 3 shared lists
extern list<defined_type> defined_types;
extern list<defined_function> defined_functions;
extern list<defined_function> root_functions;

extern list<connect_outside> connect_outsides;

// true, if functionname is in list of feedthrough_function
// &parameter returns the correct feedtrough parameter declaration
bool is_feedthrough_function(const string &name,string &parameter);

//
// is_type_defined returns false in case type 'name' is not defined,
// else it returns true and a reference to the defined type in 'ret'
// (without overloading, type names are unique)
//
bool is_type_defined(const string &name, 
                     defined_type &ret);

//
// is_function_defined returns false in case function 'name' is not defined,
// else it returns true and a reference to the defined function in 'ret'
// (without overloading, function names are unique)
//
bool is_function_defined(const string &name, 
                         defined_function &ret);


//
// same as above but not case sensitive
bool is_function_defined_caseinsensitive(const string &name, 
					 defined_function &ret);
#endif // shared_lists_h