mdtools/interface_implementation/Globals.cpp

#include <cstdlib>
#include <cstdio>
#include <cstring>

#include "Globals.hpp"

/*
 * The following section lists all of the defined tokens for the
 * gloabal assignment statements. All are prefixed with a G_ to avoid
 * stepping on any previously defined enumerations. 
 *
 * NOTE: tokens start at 1, 0 is a resrved token number
 */

//required parameters
#define G_FORCEFIELD  1
#define G_NCOMPONENTS 2
#define G_TARGETTEMP  3
#define G_ENSEMBLE    4
#define G_DT          5
#define G_RUNTIME     6

//optional parameters
#define G_INITIALCONFIG 7
#define G_FINALCONFIG   8
#define G_NMOL          9
#define G_DENSITY       10
#define G_BOX           11
#define G_BOXX          12
#define G_BOXY          13
#define G_BOXZ          14
#define G_SAMPLETIME    15
#define G_STATUSTIME    16
#define G_RRF           17
#define G_DIELECTRIC    18
#define G_TEMPSET       19
#define G_THERMALTIME   20


Globals::Globals(){
  
  int i;
  
  components = NULL;
  
  command_table = new LinkedCommand*[hash_size];
  for( i=0; i<hash_size; i++ ) command_table[i] = NULL;

  addHash( "forceField",    G_FORCEFIELD );
  addHash( "nComponents",   G_NCOMPONENTS );
  addHash( "targetTemp",    G_TARGETTEMP );
  addHash( "ensemble",      G_ENSEMBLE );
  addHash( "dt",            G_DT );
  addHash( "runTime",       G_RUNTIME );

  addHash( "initialConfig", G_INITIALCONFIG );
  addHash( "finalConfig",   G_FINALCONFIG );
  addHash( "nMol",          G_NMOL );
  addHash( "density",       G_DENSITY );
  addHash( "box",           G_BOX );
  addHash( "boxX",          G_BOXX );
  addHash( "boxY",          G_BOXY );
  addHash( "boxZ",          G_BOXZ );
  addHash( "sampleTime",    G_SAMPLETIME );
  addHash( "statusTime",    G_STATUSTIME );
  addHash( "rRF",           G_RRF );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );

  have_force_field =  0;
  have_n_components = 0;
  have_target_temp =  0;
  have_ensemble =     0;
  have_dt =           0;
  have_run_time =     0;
  
  have_initial_config = 0;
  have_final_config =   0;
  have_n_mol =          0;
  have_density =        0;
  have_box =            0;
  have_box_x =          0;
  have_box_y =          0;
  have_box_y =          0;
  have_box_z =          0;
  have_sample_time =    0;
  have_status_time =    0;
  have_thermal_time =   0;
  have_rrf =            0;
  have_dielectric =     0;
  have_tempSet =        0;
}

Globals::~Globals(){
  int i;

  for( i=0; i<hash_size; i++ ){
    if( command_table[i] != NULL ) delete command_table[i];
  }
  delete[] command_table;

  if( components != NULL ){
    for( i=0; i<n_components; i++ ) delete components[i];
    delete[] components;
  }
}

int Globals::newComponent( event* the_event ){
  
  current_component = new Component;
  int index = the_event->evt.blk_index;
  char err[200];
  
  if( have_n_components && index < n_components ) 
    components[index] = current_component;
  else{
    if( have_n_components ){
      sprintf( err, "Globals error, %d out of nComponents range", 
               index );
      the_event->err_msg = strdup( err );
      return 0;
    }
    else{
      the_event->err_msg = strdup("Globals error, nComponents not given before"
                                  "first component declaration." );
      return 0;
    }
  }  
 
  return 1;
}


int Globals::componentAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    return current_component->assignString( the_event->evt.asmt.lhs,
                                            the_event->evt.asmt.rhs.sval,
                                            &(the_event->err_msg));
    break;
    
  case DOUBLE:
    return current_component->assignDouble( the_event->evt.asmt.lhs,
                                            the_event->evt.asmt.rhs.dval,
                                            &(the_event->err_msg));
    break;
    
  case INT:
    return current_component->assignInt( the_event->evt.asmt.lhs,
                                         the_event->evt.asmt.rhs.ival,
                                         &(the_event->err_msg));
    break;
    
  default:
    the_event->err_msg = strdup( "Globals error. Invalid component"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int Globals::componentStartIndex( event* the_event ){

  current_component->startIndex( the_event->evt.si.array, 
                                 the_event->evt.si.n_elements );
  return 1;
}

int Globals::componentEnd( event* the_event ){

  the_event->err_msg = current_component->checkMe();
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int Globals::globalAssign( event* the_event ){
  
  int key;
  int token;
  interface_assign_type the_type =  the_event->evt.asmt.asmt_type;
  char* lhs = the_event->evt.asmt.lhs;
  char err[300];
  
  token = 0;
  key = hash( lhs );
  if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
  
  if( token ){
    
    switch( token ){
      
    case G_FORCEFIELD:
      if( the_type == STRING ){
        strcpy( force_field, the_event->evt.asmt.rhs.sval );
        have_force_field = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. forceField was not a string assignment.\n" );
      return 0;
      break;
      
    case G_NCOMPONENTS:
      if( the_type == STRING ){
        the_event->err_msg = 
          strdup("Global error. nComponents is not a double or an int.\n" );
        return 0;
      }
      
      else if( the_type == DOUBLE ){
        n_components = (int)the_event->evt.asmt.rhs.dval;
        components = new Component*[n_components];
        have_n_components = 1;
        return 1;
      }
      
      else{
        n_components = the_event->evt.asmt.rhs.ival;
        components = new Component*[n_components];
        have_n_components = 1;
        return 1;
      }
      break;
      
    case G_TARGETTEMP:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. targetTemp is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        target_temp = the_event->evt.asmt.rhs.dval;
        have_target_temp = 1;
        return 1;
        break;
        
      case INT:
        target_temp = (double)the_event->evt.asmt.rhs.ival;
        have_target_temp = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. targetTemp unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_ENSEMBLE:
      if( the_type == STRING ){
        strcpy( ensemble, the_event->evt.asmt.rhs.sval );
        have_ensemble = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. ensemble was not assigned to a string\n" );
      return 0;
      break;      
      
    case G_DT:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. dt is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        dt = the_event->evt.asmt.rhs.dval;
        have_dt = 1;
        return 1;
        break;
        
      case INT:
        dt = (double)the_event->evt.asmt.rhs.ival;
        have_dt = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. dt unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_RUNTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. runTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        run_time = the_event->evt.asmt.rhs.dval;
        have_run_time = 1;
        return 1;
        break;
        
      case INT:
        run_time = (double)the_event->evt.asmt.rhs.ival;
        have_run_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. runTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_INITIALCONFIG:
      if( the_type == STRING ){
        strcpy( initial_config, the_event->evt.asmt.rhs.sval );
        have_initial_config = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. initialConfig was not a string assignment.\n" );
      return 0;
      break;
      
    case G_FINALCONFIG:
      if( the_type == STRING ){
        strcpy( final_config, the_event->evt.asmt.rhs.sval );
        have_final_config = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. finalConfig was not a string assignment.\n" );
      return 0;
      break;
      
    case G_NMOL:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. nMol is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        n_mol = (int)the_event->evt.asmt.rhs.dval;
        have_n_mol = 1;
        return 1;
        break;
        
      case INT:
        n_mol = the_event->evt.asmt.rhs.ival;
        have_n_mol = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. nMol unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_DENSITY:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. density is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        density = the_event->evt.asmt.rhs.dval;
        have_density = 1;
        return 1;
        break;
        
      case INT:
        density = (double)the_event->evt.asmt.rhs.ival;
        have_density = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. density unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOX:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. box is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box = the_event->evt.asmt.rhs.dval;
        have_box = 1;
        return 1;
        break;
        
      case INT:
        box = (double)the_event->evt.asmt.rhs.ival;
        have_box = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. box unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOXX:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. boxX is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box_x = the_event->evt.asmt.rhs.dval;
        have_box_x = 1;
        return 1;
        break;
        
      case INT:
        box_x = (double)the_event->evt.asmt.rhs.ival;
        have_box_x = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. boxX unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOXY:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. boxY is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box_y = the_event->evt.asmt.rhs.dval;
        have_box_y = 1;
        return 1;
        break;
        
      case INT:
        box_y = (double)the_event->evt.asmt.rhs.ival;
        have_box_y = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. boxY unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOXZ:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. boxZ is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box_z = the_event->evt.asmt.rhs.dval;
        have_box_z = 1;
        return 1;
        break;
        
      case INT:
        box_z = (double)the_event->evt.asmt.rhs.ival;
        have_box_z = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. boxZ unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_SAMPLETIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. sampleTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        sample_time = the_event->evt.asmt.rhs.dval;
        have_sample_time = 1;
        return 1;
        break;
        
      case INT:
        sample_time = (double)the_event->evt.asmt.rhs.ival;
        have_sample_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. sampleTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_STATUSTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. statusTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        status_time = the_event->evt.asmt.rhs.dval;
        have_status_time = 1;
        return 1;
        break;
        
      case INT:
        status_time = (double)the_event->evt.asmt.rhs.ival;
        have_status_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. statusTime unrecognized.\n" );
        return 0;
        break;
      }
      break;

   case G_THERMALTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. thermalTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        thermal_time = the_event->evt.asmt.rhs.dval;
        have_thermal_time = 1;
        return 1;
        break;
        
      case INT:
        thermal_time = (double)the_event->evt.asmt.rhs.ival;
        have_thermal_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. thermalTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_RRF:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. rRF is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        rRF = the_event->evt.asmt.rhs.dval;
        have_rrf = 1;
        return 1;
        break;
        
      case INT:
        rRF = (double)the_event->evt.asmt.rhs.ival;
        have_rrf = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. rRF unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_DIELECTRIC:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. dielectric is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        dielectric = the_event->evt.asmt.rhs.dval;
        have_dielectric = 1;
        return 1;
        break;
        
      case INT:
        dielectric = (double)the_event->evt.asmt.rhs.ival;
        have_dielectric = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. dielectric unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_TEMPSET:
      if( the_type == STRING ){
        
        if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
        else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
          return 0;
        }
        have_tempSet = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
      return 0;
      break;
    }
  }
  
  switch( the_type ){
    
  case STRING:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %s\n",
             lhs, the_event->evt.asmt.rhs.sval );
    break;
    
  case DOUBLE:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %lf\n",
             lhs, the_event->evt.asmt.rhs.dval );
    break;
    
  case INT:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %d\n",
             lhs, the_event->evt.asmt.rhs.ival );
    break;
    
  default:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = ?\n",
             lhs );
    break;
  }
  
  the_event->err_msg = strdup( err );
  return 0;
}

char* Globals::checkMe( void ){
  
  char err[300];
  short int have_err = 0;

  strcpy( err, "Global error. The following are required:\n" );
  
  if( !have_force_field ){
    strcat( err, "\t->forceField\n" );
    have_err= 1;
  }

  if( !have_n_components ){
    strcat( err, "\t->nComponents\n" );
    have_err= 1;
  }

  if( !have_target_temp ){
    strcat( err, "\t->targetTemp\n" );
    have_err= 1;
  }
  
  if( !have_ensemble ){
    strcat( err, "\t->ensemble\n" );
    have_err= 1;
  }
  
  if( !have_dt ){
    strcat( err, "\t->dt\n" );
    have_err= 1;
  }
  
  if( !have_run_time ){
    strcat( err, "\t->runTime\n" );
    have_err= 1;
  }
  
  if( have_err ) return strdup( err );
  
  return NULL;
}

int Globals::globalEnd( event* the_event ){
  
  the_event->err_msg = checkMe();
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int Globals::hash( char* text ){

  register unsigned short int i = 0; // loop counter
  int key = 0; // the hash key
  
  while( text[i] != '\0' ){
    
    key = ( ( key << hash_shift ) + text[i] ) % hash_size;
    
    i++;
  }
  
  if( key < 0 ){

    // if the key is less than zero, we've had an overflow error

    fprintf( stderr,
             "There has been an overflow error in the Globals' hash key.");
    exit(0);
  }
  
  return key;
}

void Globals::addHash( char* text, int token ){

  int key;
  LinkedCommand* the_element;

  the_element = new LinkedCommand;
  the_element->setValues( text, token );

  key = hash( text );
  the_element->setNext( command_table[key] );
  command_table[key] = the_element;
}
Revision:	134
Committed:	Fri Oct 11 15:09:09 2002 UTC (21 years, 8 months ago) by chuckv
File size:	16489 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	mmeineke	10	#include <cstdlib>
2			#include <cstdio>
3			#include <cstring>
4
5			#include "Globals.hpp"
6
7			/*
8			* The following section lists all of the defined tokens for the
9			* gloabal assignment statements. All are prefixed with a G_ to avoid
10			* stepping on any previously defined enumerations.
11			*
12			* NOTE: tokens start at 1, 0 is a resrved token number
13			*/
14
15			//required parameters
16			#define G_FORCEFIELD 1
17			#define G_NCOMPONENTS 2
18			#define G_TARGETTEMP 3
19			#define G_ENSEMBLE 4
20			#define G_DT 5
21			#define G_RUNTIME 6
22
23			//optional parameters
24			#define G_INITIALCONFIG 7
25			#define G_FINALCONFIG 8
26			#define G_NMOL 9
27			#define G_DENSITY 10
28			#define G_BOX 11
29			#define G_BOXX 12
30			#define G_BOXY 13
31			#define G_BOXZ 14
32			#define G_SAMPLETIME 15
33			#define G_STATUSTIME 16
34			#define G_RRF 17
35			#define G_DIELECTRIC 18
36			#define G_TEMPSET 19
37			#define G_THERMALTIME 20
38
39
40			Globals::Globals(){
41
42			int i;
43
44			components = NULL;
45
46			command_table = new LinkedCommand*[hash_size];
47			for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
48
49			addHash( "forceField", G_FORCEFIELD );
50			addHash( "nComponents", G_NCOMPONENTS );
51			addHash( "targetTemp", G_TARGETTEMP );
52			addHash( "ensemble", G_ENSEMBLE );
53			addHash( "dt", G_DT );
54			addHash( "runTime", G_RUNTIME );
55
56			addHash( "initialConfig", G_INITIALCONFIG );
57			addHash( "finalConfig", G_FINALCONFIG );
58			addHash( "nMol", G_NMOL );
59			addHash( "density", G_DENSITY );
60			addHash( "box", G_BOX );
61			addHash( "boxX", G_BOXX );
62			addHash( "boxY", G_BOXY );
63			addHash( "boxZ", G_BOXZ );
64			addHash( "sampleTime", G_SAMPLETIME );
65			addHash( "statusTime", G_STATUSTIME );
66			addHash( "rRF", G_RRF );
67			addHash( "dielectric", G_DIELECTRIC );
68			addHash( "tempSet", G_TEMPSET );
69			addHash( "thermalTime", G_THERMALTIME );
70
71			have_force_field = 0;
72			have_n_components = 0;
73			have_target_temp = 0;
74			have_ensemble = 0;
75			have_dt = 0;
76			have_run_time = 0;
77
78			have_initial_config = 0;
79			have_final_config = 0;
80			have_n_mol = 0;
81			have_density = 0;
82			have_box = 0;
83			have_box_x = 0;
84			have_box_y = 0;
85			have_box_y = 0;
86			have_box_z = 0;
87			have_sample_time = 0;
88			have_status_time = 0;
89			have_thermal_time = 0;
90			have_rrf = 0;
91			have_dielectric = 0;
92			have_tempSet = 0;
93			}
94
95			Globals::~Globals(){
96			int i;
97
98			for( i=0; i<hash_size; i++ ){
99			if( command_table[i] != NULL ) delete command_table[i];
100			}
101			delete[] command_table;
102
103			if( components != NULL ){
104			for( i=0; i<n_components; i++ ) delete components[i];
105			delete[] components;
106			}
107			}
108
109			int Globals::newComponent( event* the_event ){
110
111			current_component = new Component;
112			int index = the_event->evt.blk_index;
113			char err[200];
114
115			if( have_n_components && index < n_components )
116			components[index] = current_component;
117			else{
118			if( have_n_components ){
119			sprintf( err, "Globals error, %d out of nComponents range",
120			index );
121			the_event->err_msg = strdup( err );
122			return 0;
123			}
124			else{
125			the_event->err_msg = strdup("Globals error, nComponents not given before"
126			"first component declaration." );
127			return 0;
128			}
129			}
130
131			return 1;
132			}
133
134
135
136			int Globals::componentAssign( event* the_event ){
137
138			switch( the_event->evt.asmt.asmt_type ){
139
140			case STRING:
141	chuckv	118	return current_component->assignString( the_event->evt.asmt.lhs,
142			the_event->evt.asmt.rhs.sval,
143			&(the_event->err_msg));
144	mmeineke	10	break;
145
146			case DOUBLE:
147	chuckv	118	return current_component->assignDouble( the_event->evt.asmt.lhs,
148			the_event->evt.asmt.rhs.dval,
149			&(the_event->err_msg));
150	mmeineke	10	break;
151
152			case INT:
153	chuckv	118	return current_component->assignInt( the_event->evt.asmt.lhs,
154			the_event->evt.asmt.rhs.ival,
155			&(the_event->err_msg));
156	mmeineke	10	break;
157
158			default:
159			the_event->err_msg = strdup( "Globals error. Invalid component"
160			" assignment type" );
161			return 0;
162			break;
163			}
164			return 0;
165			}
166
167			int Globals::componentStartIndex( event* the_event ){
168
169			current_component->startIndex( the_event->evt.si.array,
170			the_event->evt.si.n_elements );
171			return 1;
172			}
173
174			int Globals::componentEnd( event* the_event ){
175
176			the_event->err_msg = current_component->checkMe();
177			if( the_event->err_msg != NULL ) return 0;
178
179			return 1;
180			}
181
182			int Globals::globalAssign( event* the_event ){
183
184			int key;
185			int token;
186			interface_assign_type the_type = the_event->evt.asmt.asmt_type;
187			char* lhs = the_event->evt.asmt.lhs;
188			char err[300];
189
190			token = 0;
191			key = hash( lhs );
192			if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
193
194			if( token ){
195
196			switch( token ){
197
198			case G_FORCEFIELD:
199			if( the_type == STRING ){
200			strcpy( force_field, the_event->evt.asmt.rhs.sval );
201			have_force_field = 1;
202			return 1;
203			}
204
205			the_event->err_msg =
206			strdup( "Global error. forceField was not a string assignment.\n" );
207			return 0;
208			break;
209
210			case G_NCOMPONENTS:
211			if( the_type == STRING ){
212			the_event->err_msg =
213			strdup("Global error. nComponents is not a double or an int.\n" );
214			return 0;
215			}
216
217			else if( the_type == DOUBLE ){
218			n_components = (int)the_event->evt.asmt.rhs.dval;
219			components = new Component*[n_components];
220			have_n_components = 1;
221			return 1;
222			}
223
224			else{
225			n_components = the_event->evt.asmt.rhs.ival;
226			components = new Component*[n_components];
227			have_n_components = 1;
228			return 1;
229			}
230			break;
231
232			case G_TARGETTEMP:
233			switch( the_type ){
234
235			case STRING:
236			the_event->err_msg =
237			strdup( "Global error. targetTemp is not a double or int.\n" );
238			return 0;
239			break;
240
241			case DOUBLE:
242			target_temp = the_event->evt.asmt.rhs.dval;
243			have_target_temp = 1;
244			return 1;
245			break;
246
247			case INT:
248			target_temp = (double)the_event->evt.asmt.rhs.ival;
249			have_target_temp = 1;
250			return 1;
251			break;
252
253			default:
254			the_event->err_msg =
255			strdup( "Global error. targetTemp unrecognized.\n" );
256			return 0;
257			break;
258			}
259			break;
260
261			case G_ENSEMBLE:
262			if( the_type == STRING ){
263			strcpy( ensemble, the_event->evt.asmt.rhs.sval );
264			have_ensemble = 1;
265			return 1;
266			}
267
268			the_event->err_msg =
269			strdup( "Global error. ensemble was not assigned to a string\n" );
270			return 0;
271			break;
272
273			case G_DT:
274			switch( the_type ){
275
276			case STRING:
277			the_event->err_msg =
278			strdup( "Global error. dt is not a double or int.\n" );
279			return 0;
280			break;
281
282			case DOUBLE:
283			dt = the_event->evt.asmt.rhs.dval;
284			have_dt = 1;
285			return 1;
286			break;
287
288			case INT:
289			dt = (double)the_event->evt.asmt.rhs.ival;
290			have_dt = 1;
291			return 1;
292			break;
293
294			default:
295			the_event->err_msg =
296			strdup( "Global error. dt unrecognized.\n" );
297			return 0;
298			break;
299			}
300			break;
301
302			case G_RUNTIME:
303			switch( the_type ){
304
305			case STRING:
306			the_event->err_msg =
307			strdup( "Global error. runTime is not a double or int.\n" );
308			return 0;
309			break;
310
311			case DOUBLE:
312			run_time = the_event->evt.asmt.rhs.dval;
313			have_run_time = 1;
314			return 1;
315			break;
316
317			case INT:
318			run_time = (double)the_event->evt.asmt.rhs.ival;
319			have_run_time = 1;
320			return 1;
321			break;
322
323			default:
324			the_event->err_msg =
325			strdup( "Global error. runTime unrecognized.\n" );
326			return 0;
327			break;
328			}
329			break;
330
331			case G_INITIALCONFIG:
332			if( the_type == STRING ){
333			strcpy( initial_config, the_event->evt.asmt.rhs.sval );
334			have_initial_config = 1;
335			return 1;
336			}
337
338			the_event->err_msg =
339			strdup( "Global error. initialConfig was not a string assignment.\n" );
340			return 0;
341			break;
342
343			case G_FINALCONFIG:
344			if( the_type == STRING ){
345			strcpy( final_config, the_event->evt.asmt.rhs.sval );
346			have_final_config = 1;
347			return 1;
348			}
349
350			the_event->err_msg =
351			strdup( "Global error. finalConfig was not a string assignment.\n" );
352			return 0;
353			break;
354
355			case G_NMOL:
356			switch( the_type ){
357
358			case STRING:
359			the_event->err_msg =
360			strdup( "Global error. nMol is not a double or int.\n" );
361			return 0;
362			break;
363
364			case DOUBLE:
365			n_mol = (int)the_event->evt.asmt.rhs.dval;
366			have_n_mol = 1;
367			return 1;
368			break;
369
370			case INT:
371			n_mol = the_event->evt.asmt.rhs.ival;
372			have_n_mol = 1;
373			return 1;
374			break;
375
376			default:
377			the_event->err_msg =
378			strdup( "Global error. nMol unrecognized.\n" );
379			return 0;
380			break;
381			}
382			break;
383
384			case G_DENSITY:
385			switch( the_type ){
386
387			case STRING:
388			the_event->err_msg =
389			strdup( "Global error. density is not a double or int.\n" );
390			return 0;
391			break;
392
393			case DOUBLE:
394			density = the_event->evt.asmt.rhs.dval;
395			have_density = 1;
396			return 1;
397			break;
398
399			case INT:
400			density = (double)the_event->evt.asmt.rhs.ival;
401			have_density = 1;
402			return 1;
403			break;
404
405			default:
406			the_event->err_msg =
407			strdup( "Global error. density unrecognized.\n" );
408			return 0;
409			break;
410			}
411			break;
412
413			case G_BOX:
414			switch( the_type ){
415
416			case STRING:
417			the_event->err_msg =
418			strdup( "Global error. box is not a double or int.\n" );
419			return 0;
420			break;
421
422			case DOUBLE:
423			box = the_event->evt.asmt.rhs.dval;
424			have_box = 1;
425			return 1;
426			break;
427
428			case INT:
429			box = (double)the_event->evt.asmt.rhs.ival;
430			have_box = 1;
431			return 1;
432			break;
433
434			default:
435			the_event->err_msg =
436			strdup( "Global error. box unrecognized.\n" );
437			return 0;
438			break;
439			}
440			break;
441
442			case G_BOXX:
443			switch( the_type ){
444
445			case STRING:
446			the_event->err_msg =
447			strdup( "Global error. boxX is not a double or int.\n" );
448			return 0;
449			break;
450
451			case DOUBLE:
452			box_x = the_event->evt.asmt.rhs.dval;
453			have_box_x = 1;
454			return 1;
455			break;
456
457			case INT:
458			box_x = (double)the_event->evt.asmt.rhs.ival;
459			have_box_x = 1;
460			return 1;
461			break;
462
463			default:
464			the_event->err_msg =
465			strdup( "Global error. boxX unrecognized.\n" );
466			return 0;
467			break;
468			}
469			break;
470
471			case G_BOXY:
472			switch( the_type ){
473
474			case STRING:
475			the_event->err_msg =
476			strdup( "Global error. boxY is not a double or int.\n" );
477			return 0;
478			break;
479
480			case DOUBLE:
481			box_y = the_event->evt.asmt.rhs.dval;
482			have_box_y = 1;
483			return 1;
484			break;
485
486			case INT:
487			box_y = (double)the_event->evt.asmt.rhs.ival;
488			have_box_y = 1;
489			return 1;
490			break;
491
492			default:
493			the_event->err_msg =
494			strdup( "Global error. boxY unrecognized.\n" );
495			return 0;
496			break;
497			}
498			break;
499
500			case G_BOXZ:
501			switch( the_type ){
502
503			case STRING:
504			the_event->err_msg =
505			strdup( "Global error. boxZ is not a double or int.\n" );
506			return 0;
507			break;
508
509			case DOUBLE:
510			box_z = the_event->evt.asmt.rhs.dval;
511			have_box_z = 1;
512			return 1;
513			break;
514
515			case INT:
516			box_z = (double)the_event->evt.asmt.rhs.ival;
517			have_box_z = 1;
518			return 1;
519			break;
520
521			default:
522			the_event->err_msg =
523			strdup( "Global error. boxZ unrecognized.\n" );
524			return 0;
525			break;
526			}
527			break;
528
529			case G_SAMPLETIME:
530			switch( the_type ){
531
532			case STRING:
533			the_event->err_msg =
534			strdup( "Global error. sampleTime is not a double or int.\n" );
535			return 0;
536			break;
537
538			case DOUBLE:
539			sample_time = the_event->evt.asmt.rhs.dval;
540			have_sample_time = 1;
541			return 1;
542			break;
543
544			case INT:
545			sample_time = (double)the_event->evt.asmt.rhs.ival;
546			have_sample_time = 1;
547			return 1;
548			break;
549
550			default:
551			the_event->err_msg =
552			strdup( "Global error. sampleTime unrecognized.\n" );
553			return 0;
554			break;
555			}
556			break;
557
558			case G_STATUSTIME:
559			switch( the_type ){
560
561			case STRING:
562			the_event->err_msg =
563			strdup( "Global error. statusTime is not a double or int.\n" );
564			return 0;
565			break;
566
567			case DOUBLE:
568			status_time = the_event->evt.asmt.rhs.dval;
569			have_status_time = 1;
570			return 1;
571			break;
572
573			case INT:
574			status_time = (double)the_event->evt.asmt.rhs.ival;
575			have_status_time = 1;
576			return 1;
577			break;
578
579			default:
580			the_event->err_msg =
581			strdup( "Global error. statusTime unrecognized.\n" );
582			return 0;
583			break;
584			}
585			break;
586
587			case G_THERMALTIME:
588			switch( the_type ){
589
590			case STRING:
591			the_event->err_msg =
592			strdup( "Global error. thermalTime is not a double or int.\n" );
593			return 0;
594			break;
595
596			case DOUBLE:
597			thermal_time = the_event->evt.asmt.rhs.dval;
598			have_thermal_time = 1;
599			return 1;
600			break;
601
602			case INT:
603			thermal_time = (double)the_event->evt.asmt.rhs.ival;
604			have_thermal_time = 1;
605			return 1;
606			break;
607
608			default:
609			the_event->err_msg =
610			strdup( "Global error. thermalTime unrecognized.\n" );
611			return 0;
612			break;
613			}
614			break;
615
616			case G_RRF:
617			switch( the_type ){
618
619			case STRING:
620			the_event->err_msg =
621			strdup( "Global error. rRF is not a double or int.\n" );
622			return 0;
623			break;
624
625			case DOUBLE:
626			rRF = the_event->evt.asmt.rhs.dval;
627			have_rrf = 1;
628			return 1;
629			break;
630
631			case INT:
632			rRF = (double)the_event->evt.asmt.rhs.ival;
633			have_rrf = 1;
634			return 1;
635			break;
636
637			default:
638			the_event->err_msg =
639			strdup( "Global error. rRF unrecognized.\n" );
640			return 0;
641			break;
642			}
643			break;
644
645			case G_DIELECTRIC:
646			switch( the_type ){
647
648			case STRING:
649			the_event->err_msg =
650			strdup( "Global error. dielectric is not a double or int.\n" );
651			return 0;
652			break;
653
654			case DOUBLE:
655			dielectric = the_event->evt.asmt.rhs.dval;
656			have_dielectric = 1;
657			return 1;
658			break;
659
660			case INT:
661			dielectric = (double)the_event->evt.asmt.rhs.ival;
662			have_dielectric = 1;
663			return 1;
664			break;
665
666			default:
667			the_event->err_msg =
668			strdup( "Global error. dielectric unrecognized.\n" );
669			return 0;
670			break;
671			}
672			break;
673
674			case G_TEMPSET:
675			if( the_type == STRING ){
676
677			if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
678			else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
679			else{
680			the_event->err_msg =
681			strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
682			return 0;
683			}
684			have_tempSet = 1;
685			return 1;
686			}
687
688			the_event->err_msg =
689			strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
690			return 0;
691			break;
692			}
693			}
694
695			switch( the_type ){
696
697			case STRING:
698			sprintf( err,
699			"Global error. Unrecognized assignment:\n"
700			"\t-> %s = %s\n",
701			lhs, the_event->evt.asmt.rhs.sval );
702			break;
703
704			case DOUBLE:
705			sprintf( err,
706			"Global error. Unrecognized assignment:\n"
707			"\t-> %s = %lf\n",
708			lhs, the_event->evt.asmt.rhs.dval );
709			break;
710
711			case INT:
712			sprintf( err,
713			"Global error. Unrecognized assignment:\n"
714			"\t-> %s = %d\n",
715			lhs, the_event->evt.asmt.rhs.ival );
716			break;
717
718			default:
719			sprintf( err,
720			"Global error. Unrecognized assignment:\n"
721			"\t-> %s = ?\n",
722			lhs );
723			break;
724			}
725
726			the_event->err_msg = strdup( err );
727			return 0;
728			}
729
730			char* Globals::checkMe( void ){
731
732			char err[300];
733			short int have_err = 0;
734
735			strcpy( err, "Global error. The following are required:\n" );
736
737			if( !have_force_field ){
738			strcat( err, "\t->forceField\n" );
739			have_err= 1;
740			}
741
742			if( !have_n_components ){
743			strcat( err, "\t->nComponents\n" );
744			have_err= 1;
745			}
746
747			if( !have_target_temp ){
748			strcat( err, "\t->targetTemp\n" );
749			have_err= 1;
750			}
751
752			if( !have_ensemble ){
753			strcat( err, "\t->ensemble\n" );
754			have_err= 1;
755			}
756
757			if( !have_dt ){
758			strcat( err, "\t->dt\n" );
759			have_err= 1;
760			}
761
762			if( !have_run_time ){
763			strcat( err, "\t->runTime\n" );
764			have_err= 1;
765			}
766
767			if( have_err ) return strdup( err );
768
769			return NULL;
770			}
771
772			int Globals::globalEnd( event* the_event ){
773
774			the_event->err_msg = checkMe();
775			if( the_event->err_msg != NULL ) return 0;
776
777			return 1;
778			}
779
780			int Globals::hash( char* text ){
781
782			register unsigned short int i = 0; // loop counter
783			int key = 0; // the hash key
784
785			while( text[i] != '\0' ){
786
787			key = ( ( key << hash_shift ) + text[i] ) % hash_size;
788
789			i++;
790			}
791
792			if( key < 0 ){
793
794			// if the key is less than zero, we've had an overflow error
795
796			fprintf( stderr,
797			"There has been an overflow error in the Globals' hash key.");
798			exit(0);
799			}
800
801			return key;
802			}
803
804			void Globals::addHash( char* text, int token ){
805
806			int key;
807			LinkedCommand* the_element;
808
809			the_element = new LinkedCommand;
810			the_element->setValues( text, token );
811
812			key = hash( text );
813			the_element->setNext( command_table[key] );
814			command_table[key] = the_element;
815	chuckv	134	}