mdtools/interface_implementation/Globals.cpp

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

#include "Globals.hpp"
#include "simError.h"

/*
 * 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

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