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

Revision 1.9  2002/02/26 13:23:14  sbeyer
* fixed bug where RAM lost information about its address width
* fixed bug where array of RAM was treated as single bitvector
* made pseudo-warning in case of overloaded functions real warning
  (source code is now REALLY processed further after WARNING output)
* in case of (case insensitive) overloading, added location of initial definition to warning/error output
* WARNING output no longer reports termination of pvs2hdl

Revision 1.8  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.7  2001/11/15 15:57:58  dirkl
- pvs2hdl gives only a warning when overloading a function

Revision 1.6  2001/06/22 10:28:29  dirkl
- prepared new config-file format
- excluded context pvsctl

Revision 1.5  2001/01/25 13:06:52  sbeyer

cosmetical adjustments

Revision 1.4  2001/01/15 15:13:01  sbeyer

cosmetic changes

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

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

Revision 1.2  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.1  2001/01/11 16:25:26  sbeyer

split types_and_functions (about 900 lines) into the 3 files
    types_and_functions_add
    types_and_functions_core
    types_and_functions_libs

*/
#include "types_and_functions_add.h"
#include "tools.h"
#include <iostream>
#include <cstdio>

using namespace std;

bool is_var_defined(const list<defined_var> &vars, const string &name,
					const knoten *&root)
{
  list<defined_var>::const_iterator i=vars.begin();
  while (i!=vars.end())
  {
    if (i->name==name)
    {
      root = i->root;
      return true;
    }
    i++;
  }
  return false;
};

void add_var(const knoten *knot, 
             const knoten *type_expression,
             list<defined_var> &vars)
{
  const knoten *dummy;
  switch (knot->subtyp)
  {
    case 329 :   // idop
      if (knot->sub[0]->subtyp==332) // opsym
      {
        knot_error(cout << "Nur ID bei var_decl idop unerstuetzt, nicht opsym!\n",knot);
      }
      if (is_var_defined(vars, knot->sub[0]->sub[0]->wert_str, dummy))
      {
        knot_error(cout << "Variable " << knot->sub[0]->sub[0]->wert_str
		        << " ist ueberladen - Verarbeitung abgebrochen!",knot);
      }
      if (parameter_verbose)
        cout << "fuege Variable " << knot->sub[0]->sub[0]->wert_str
	     << " zu definierten Variablen hinzu...\n";
      vars.push_back(defined_var(type_expression,
                                 knot->sub[0]->sub[0]->wert_str));
      break;
    case 330 :   // idops ',' idop
      add_var(knot->sub[0],type_expression,vars);
      if (knot->sub[1]->subtyp==332) // opsym
      {
        knot_error(cout << "Nur ID bei var_decl idop unerstuetzt, nicht opsym!\n",knot);
      }
      if (is_var_defined(vars, knot->sub[1]->sub[0]->wert_str, dummy))
      {
        knot_error(cout << "Variable " << knot->sub[1]->sub[0]->wert_str
		        << " ist ueberladen - Verarbeitung abgebrochen!",knot);
      }
      if (parameter_verbose)
        cout << "fuege Variable " << knot->sub[1]->sub[0]->wert_str
	     << " zu definierten Variablen hinzu...\n";
      vars.push_back(defined_var(type_expression,
                                 knot->sub[1]->sub[0]->wert_str));
      break;
    default:
      knot_error(printf("Aufruf von add_var mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}

void add_type(const knoten *knot, const knoten *type_expression,
              const actuals_array &theory_actuals, 
              const params_array &params)
{
  defined_type dummy;
  switch (knot->subtyp)
  {
    case 329 :   // idop
      if (knot->sub[0]->subtyp==332) // opsym
        knot_error(cout << "Nur ID bei type_decl idop unerstuetzt, nicht opsym!\n",knot);
      if (is_type_defined(knot->sub[0]->sub[0]->wert_str,
			  dummy))
        knot_error(cout << "Typ " << dummy.name
		        << " ist ueberladen - Verarbeitung abgebrochen!",knot);
      if (parameter_verbose)
        cout << "fuege Typ " << knot->sub[0]->sub[0]->wert_str
             << " zu definierten Typen hinzu...\n";
      defined_types.push_back(defined_type(type_expression,
                                           knot->sub[0]->sub[0]->wert_str,
                                           theory_actuals,params));
      break;
    case 330 :   // idops ',' idop
      add_type(knot->sub[0],type_expression,theory_actuals,params);
      if (knot->sub[1]->subtyp==332) // opsym
        knot_error(cout << "Nur ID bei type_decl idop unerstuetzt, nicht opsym!\n",knot);
      if (is_type_defined(knot->sub[1]->sub[0]->wert_str,
			  dummy))
        knot_error(cout << "Typ " << dummy.name
		        << " ist ueberladen - Verarbeitung abgebrochen!",knot);
      if (parameter_verbose)
        cout << "fuege Typ " << knot->sub[1]->sub[0]->wert_str
             << " zu definierten Typen hinzu...\n";
      defined_types.push_back(defined_type(type_expression,
                                           knot->sub[1]->sub[0]->wert_str,
                                           theory_actuals,params));
      break;
    default:
      knot_error(printf("Aufruf von add_type mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}

void add_function(const knoten *knot, 
                  const knoten *expression, 
                  const knoten *return_type,
                  const actuals_array &theory_actuals, 
                  const params_array& params,
                  bool is_non_recursive_root)
{
  defined_function dummy;
  switch (knot->subtyp)
  {
    case 329 :   // idop
      if (knot->sub[0]->subtyp==332) // opsym
        knot_error(cout << "Nur ID bei const_decl/def_decl idop unerstuetzt, nicht opsym!\n",knot);
      if (is_function_defined(knot->sub[0]->sub[0]->wert_str,
			  dummy))
      { 
        knot_warning(cout << "Funktion " << dummy.name
		     << " ist ueberladen (Datei " <<
		     dummy.root->source_file << ", Zeile " <<
		     dummy.root->source_line << ") - wird ignoriert!",knot);
        break;
      }
      if (is_function_defined_caseinsensitive(knot->sub[0]->sub[0]->wert_str,dummy))
	knot_error(cout << "Funktion " << knot->sub[0]->sub[0]->wert_str
		   << " ist bereits mit anderer Gross/Kleinschreibung als "
                   << dummy.name << "in Datei " <<
		   dummy.root->source_file << ", Zeile " <<
		   dummy.root->source_line << " definiert. Dies führt unter Windows zu Fehlern. Verarbeitung abgebrochen!",knot);
      if (parameter_verbose)
        cout << "fuege Funktion " << knot->sub[0]->sub[0]->wert_str
	     << " zu definierten Funktionen hinzu...\n";
      defined_functions.push_back(defined_function(expression,
                                                   knot->sub[0]->sub[0]->wert_str,
                                                   theory_actuals,
                                                   params, 
                                                   return_type));
      if (is_non_recursive_root && theory_actuals.num==0)
        root_functions.push_back(defined_function(expression,
                                                  knot->sub[0]->sub[0]->wert_str,
                                                  theory_actuals,
                                                  params, 
                                                  return_type));
      break;
    case 330 :   // idops ',' idop
      add_function(knot->sub[0],expression,return_type,
                   theory_actuals,params,is_non_recursive_root);
      if (knot->sub[1]->subtyp==332) // opsym
        knot_error(cout << "Nur ID bei const_decl/def_decl idop unerstuetzt, nicht opsym!\n",knot);
      if (is_function_defined(knot->sub[1]->sub[0]->wert_str,
			      dummy))
        knot_warning(cout << "Funktion " << dummy.name
		     << " ist ueberladen - Verarbeitung abgebrochen!",knot);
      if (is_function_defined_caseinsensitive(knot->sub[0]->sub[0]->wert_str,dummy))
	knot_error(cout << "Funktion " << knot->sub[0]->sub[0]->wert_str
		   << " ist bereits mit anderer Gross/Kleinschreibung als " << dummy.name << " definiert. Dies führt unter Windows zu fehlern. Verarbeitung abgebrochen!",knot);
      if (parameter_verbose)
        cout << "fuege Funktion " << knot->sub[1]->sub[0]->wert_str
	     << " zu definierten Funktionen hinzu...\n";
      defined_functions.push_back(defined_function(expression,
                                                   knot->sub[1]->sub[0]->wert_str,
                                                   theory_actuals,
                                                   params, 
                                                   return_type));
      if (is_non_recursive_root && theory_actuals.num==0)
        root_functions.push_back(defined_function(expression,
                                                  knot->sub[1]->sub[0]->wert_str,
                                                  theory_actuals,
                                                  params, 
                                                  return_type));
      break;
    default:
      knot_error(printf("Aufruf von add_function mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}

void add_param(const string &name,
               const knoten *root,
               const actuals_array &theory_actuals,
	       params_array& params)
{
  const knoten *dummy;
  if (theory_actuals.is_actual(name))
    knot_error(cout << "Parameter " << name
	            << " ist bereits Actual (ueberalden)!\n", root);
  if (params.is_parameter(name,dummy))
    knot_error(cout << "Parameter " << name
	            << " ist doppelt in der Funktion!\n", root);
  params.add_param(name,root);
}

void get_adformal(const knoten *knot, 
                  const actuals_array &theory_actuals,
				  params_array& params,
				  const knoten *&help,
				  const list<defined_var> &vars)
{
  const knoten *dummy;
  switch (knot->subtyp)
  {
    case 95: // typeid
      switch(knot->sub[0]->subtyp)
      {
        case 335 : // idop
          if (knot->sub[0]->sub[0]->subtyp==332) // opsym
            knot_error(cout << "Als Parameter idop wird nur ID unterstuetzt, nich opsym!\n",
                       knot->sub[0]->sub[0]);
          if (help)
            add_param(knot->sub[0]->sub[0]->sub[0]->wert_str,
                      help,theory_actuals,params);
            
          else // search for missing types in defined variables
            if (is_var_defined(vars, knot->sub[0]->sub[0]->sub[0]->wert_str,dummy))
              add_param(knot->sub[0]->sub[0]->sub[0]->wert_str,
                        dummy,theory_actuals,params);
            else
              knot_error(cout << "Typ von Parameter " << knot->sub[0]->sub[0]->sub[0]->wert_str
			      << " kann nicht festgestellt werden!\n", knot->sub[0]);
          break;
        case 336 : // idop '|' expr
          knot_error(printf("typeid -> idop '|' expr nicht unterstuetzt!\n"),knot->sub[0]);
          break;
        case 337 : // idop ':' type_expr
          if (knot->sub[0]->sub[0]->subtyp==332) // opsym
            knot_error(printf("Als Parameter idop wird nur ID unterstuetzt, nich opsym!\n"),
                       knot->sub[0]->sub[0]);
          help=knot->sub[0]->sub[1];
          add_param(knot->sub[0]->sub[0]->sub[0]->wert_str,
                    knot->sub[0]->sub[1],theory_actuals,params);
		  break;
        case 338 : // idop ':' type_expr '|' expr
	  // print warning then continue
	  knot_warning(printf("typeid -> idop ':' type_expr '|' expr nicht unterstuetzt!\n"),knot->sub[0]);
	  if (knot->sub[0]->sub[0]->subtyp==332) // opsym
            knot_error(printf("Als Parameter idop wird nur ID unterstuetzt, nich opsym!\n"),
                       knot->sub[0]->sub[0]);
          help=knot->sub[0]->sub[1];
          add_param(knot->sub[0]->sub[0]->sub[0]->wert_str,
                    knot->sub[0]->sub[1],theory_actuals,params);
		  break;
	  break;
        default:
          knot_error(printf("typeid hat unzulaessigem Subtyp\n"),knot->sub[0]);
          break;
      }
      break;
    case 96: // '(' typeids ')'
	  knot_error(printf("adformal -> '(' typeids ')' nicht unterstuetzt!\n"),knot);
      break;
    default:
      knot_error(printf("Aufruf von get_adformal mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}

void get_adformals(const knoten *knot, 
                   const actuals_array &theory_actuals,
				   params_array& params,
				   const knoten *&help,
				   const list<defined_var> &vars)
{
  switch (knot->subtyp)
  {
    case 93: // adformal
      get_adformal(knot->sub[0], theory_actuals, params, help, vars);
      break;
    case 94: // adformal ',' adformals
      get_adformals(knot->sub[1], theory_actuals, params, help, vars);
      get_adformal(knot->sub[0], theory_actuals, params, help, vars);
      break;
    default:
      knot_error(printf("Aufruf von get_adformals mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}

void get_pdformals_plus(const knoten *knot, 
                        const actuals_array &theory_actuals,
                        params_array& params,
						const list<defined_var> &vars)
{
  const knoten *dummy=0;
  switch (knot->subtyp)
  {
    case 306: // '(' adformals ')'
      get_adformals(knot->sub[0], theory_actuals, params, dummy, vars);
      break;
    case 307: // pdformals_plus '(' adformals ')'
      get_adformals(knot->sub[1], theory_actuals, params, dummy, vars); // right-to-left evaluation!
      get_pdformals_plus(knot->sub[0], theory_actuals, params, vars);
      break;
    default:
      knot_error(printf("Aufruf von get_pdformals_plus mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}

void get_pdformals_stern(const knoten *knot, 
                         const actuals_array &theory_actuals,
                         params_array& params,
                         const list<defined_var> &vars)
{
  switch (knot->subtyp)
  {
    case 67: // 
      break;
    case 68: // pdformals_plus
      get_pdformals_plus(knot->sub[0], theory_actuals, params, vars);
      break;
    default:
      knot_error(printf("Aufruf von get_pdformals_stern mit unzulaessigem Subtyp\n"),knot);
      break;
  }
}