/*-----------------------------------------------------------------------
 *      DEMETER System/C++ Generators
 *      Copyright (c) 1993 Northeastern University
 *------------------------------------------------------------------------
 *
 * $Log: main.C,v $
 * Revision 5.4.1.2  1994/10/13  02:13:28  demeter
 * *** empty log message ***
 *
 * Revision 5.4.1.1  1994/02/28  16:35:44  huersch
 * *** empty log message ***
 *
 * Revision 5.4  1994/02/28  16:35:42  huersch
 * *** empty log message ***
 *
 * Revision 5.3.1.1  1994/01/26  19:06:11  huersch
 *  No changes.
 *
 * Revision 5.3  1994/01/26  19:06:09  huersch
 * *** empty log message ***
 *
 * Revision 5.2.1.1  1994/01/24  16:16:33  huersch
 * No changes.
 *
 * Revision 5.2  1994/01/24  16:16:31  huersch
 * *** empty log message ***
 *
 * Revision 5.1.1.1  1993/11/15  15:18:07  demeter
 * *** empty log message ***
 *
 * Revision 5.1  1993/11/15  15:18:05  demeter
 * *** empty log message ***
 *
 * Revision 5.0.1.8  1993/10/28  17:42:10  demeter
 * *** empty log message ***
 *
 * Revision 5.0.1.7  1993/10/12  18:51:06  huersch
 * Fixed bug with MIFLAG
 *
 */

#include "generate.h"
#include <iostream.h>
#include <string.h>

void out_of_store()
{
   cerr << "generate: operator new failed, out of store\n";
   exit( 1 );
}

#ifndef __GNUC__
extern PF set_new_handler( PF );
#else
extern "C"  PF set_new_handler( PF );
#endif

extern int _demeter_hash(const char* classname);
int greeting = _demeter_hash("Greeting");



/* GEN_DIR is a global variable containing the path of the generation 
 * environment. This path is used to find the cd-print and cd-parse 
 * class dictionaries.
 */
char *GEN_DIR = getenv("GEN_DIR");


const int MAXPATH = 1024;

char NOCTORLIST[MAXPATH];
int MIFLAG;

main( int argc, char* argv[], char* envp[] )
{
 
  set_new_handler( &out_of_store );


  // command line evaluation
  if (argc != 4 || (strcmp(argv[1],"SI") && strcmp(argv[1],"MI")))
  {
    cerr << "Usage: generate { SI | MI } TOPENVNAME NOCTORLIST" << endl;
    exit(1);
  }

  // determine MI or SI generation
  MIFLAG = ( strcmp(argv[1],"MI") == 0 ) ? 1 : 0; 
  
  char target[MAXPATH];                 // indicates where to generate files
  char top[MAXPATH];                    // top environment directory
  char TOP[MAXPATH];                    // dito but all capital
  char* cwd = getcwd(NULL,1024);        // current working directory

  strcpy( NOCTORLIST, argv[3] );        // 

  strcpy( top, argv[2]);
  int len = strlen(top);

  for ( int i = 0; i < len; i++ )
  {
     if (top[i] >= 'a' && top[i] <= 'z')
       TOP[i] = top[i] - 'a' + 'A';
     else
       TOP[i] = top[i];
  }
  TOP[i] = '\0';

  Demeter_in* cd = new Demeter_in();
  // When called through the generate script
  cd = (Demeter_in*)cd -> g_parse("notmod/cds/cd-param-exp");
  if ( !cd ) {
    cerr << "generate error: parsing notmod/cds/cd-param-exp failed." << endl;
    exit ( 1 );
  }

  char* cd_inter_name = "notmod/cds/cd-inter";

  Demeter_in* cd_inter = (Demeter_in*) cd -> g_copy();
  Demeter_in* cd_pp = (Demeter_in*) cd -> g_copy();

  cout << "generate: creating intermediate notation in "
       << "notmod/cds/cd-inter ..." << endl;
  ofstream out( cd_inter_name, ios::out );
  if (!out) { 
    cerr << "generate: unable to open " << cd_inter_name 
	 << " for output" << endl;
    exit( 1 );
  }
  cd_inter -> gen_intermediate();
  cd_inter -> g_print( out );
  out.close();
  
  strcpy( target, cwd );
  strcat( target, "/notmod/def/" );   
  strcat( target, top );  
  strcat( target, ".h" );   
  cout << "generate: creating " << target 
       << " (class definitions) ... " << endl;
  cd_inter -> gen_classes( target, top, TOP );

  strcpy( target, cwd );
  strcat( target, "/notmod/def/" );   
  strcat( target, top );  
  strcat( target, "-DEM.C" );  
  cout << "generate: creating " << target 
       << " (non-inline functions) ... " << endl;
  cd_inter -> gen_non_inline( target, top );
  cd_pp -> gen_pprt( target );

/* for templates only
  strcpy( target, cwd );
  strcat( target, "/sortable.C" );   
  cout << "generate: creating " << target 
       << " (auxialiary functions for sort) ... " << endl;
  cd_inter -> gen_sortable( target, top );
*/

  cout << "generate: creating main.C.sample  ... " << endl;
  strcpy( target, cwd );
  strcat( target, "" );
  cd_inter -> gen_user_calls( target, top, TOP );

  cout << "generate: creating scanner/lex-syntax ... " << endl;
  cd -> gen_lex( "scanner" );

  return (0);
}