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 *
#	Content
1	#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	return current_component->assignString( the_event->evt.asmt.lhs,
142	the_event->evt.asmt.rhs.sval,
143	&(the_event->err_msg));
144	break;
145
146	case DOUBLE:
147	return current_component->assignDouble( the_event->evt.asmt.lhs,
148	the_event->evt.asmt.rhs.dval,
149	&(the_event->err_msg));
150	break;
151
152	case INT:
153	return current_component->assignInt( the_event->evt.asmt.lhs,
154	the_event->evt.asmt.rhs.ival,
155	&(the_event->err_msg));
156	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	}