ParseOptions.C File Reference

#include <stdlib.h>
#include <string.h>
#include "ParseOptions.h"
#include "ConfigList.h"
#include "InfoStream.h"
#include "strlib.h"
#include <tcl.h>

Go to the source code of this file.

Macros
#define	dataelement_cons_macro_default(Mtype, MType, Mptr, Mdef)
#define	dataelement_cons_macro(Mtype, MType, Mptr)
#define	parse_input_macro_default(fctnname, type, optional)
	routines to add dependencies to the array More...
#define	parse_input_macro(fctnname, type, optional)
#define	parse_input_macro_default_b(fctnname, type, optional, extra)
#define	parse_input_macro_b(fctnname, type, optional, extra)
#define	parse_stringlist_macro(fctn, xxx)
#define	set_macro(type, field, fieldptr)
#define	simple_set_macro(type, field, fieldptr)
#define	PRINT_DOUBLE(BUF, VAL)   Tcl_PrintDouble(0,VAL,BUF)

Functions
const char *	rstring (Range r)
const char *	ustring (Units u)
static Units	next (Units u)
BigReal	convert (Units to, Units from)
static char *	Strdup (const char *newname)
	dataelement_cons_macro_default (BigReal, FLOAT, fptr, fdef)
	dataelement_cons_macro_default (int, INT, iptr, idef)
	dataelement_cons_macro_default (unsigned int, UINT, uiptr, uidef)
	dataelement_cons_macro_default (Vector, VECTOR, vptr, vdef)
	dataelement_cons_macro (BigReal, FLOAT, fptr)
	dataelement_cons_macro (Vector, VECTOR, vptr)
	dataelement_cons_macro (int, INT, iptr)
	dataelement_cons_macro (unsigned int, UINT, uiptr)
	dataelement_cons_macro (char, STRING, sptr)
	parse_input_macro (require, BigReal, FALSE)
	parse_input_macro (require, Vector, FALSE)
	parse_input_macro (require, int, FALSE)
	parse_input_macro (require, unsigned int, FALSE)
	parse_input_macro_b (requireB, int, FALSE, tmp->type=DataElement::BOOL)
	parse_input_macro (require, char, FALSE)
	parse_input_macro (optional, BigReal, TRUE)
	parse_input_macro (optional, Vector, TRUE)
	parse_input_macro (optional, int, TRUE)
	parse_input_macro (optional, unsigned int, TRUE)
	parse_input_macro_b (optionalB, int, TRUE, tmp->type=DataElement::BOOL)
	parse_input_macro (optional, char, TRUE)
	parse_input_macro_default (require, BigReal, FALSE)
	parse_input_macro_default (require, Vector, FALSE)
	parse_input_macro_default (require, int, FALSE)
	parse_input_macro_default (require, unsigned int, FALSE)
	parse_input_macro_default_b (requireB, int, FALSE, tmp->type=DataElement::BOOL)
	parse_input_macro_default (optional, BigReal, TRUE)
	parse_input_macro_default (optional, Vector, TRUE)
	parse_input_macro_default (optional, int, TRUE)
	parse_input_macro_default (optional, unsigned int, TRUE)
	parse_input_macro_default_b (optionalB, int, TRUE, tmp->type=DataElement::BOOL)
	parse_stringlist_macro (require, FALSE)
	parse_stringlist_macro (optional, TRUE)
	set_macro (float, fdata, fptr)
	set_macro (int, idata, iptr)
	set_macro (uint, uidata, uiptr)
	simple_set_macro (bool, idata, iptr)
	simple_set_macro (vector, vdata, vptr)
	simple_set_macro (stringlist, sldata, slptr)
static void	PRINT_VECTOR (char *buf, Vector val)

Variables
static const char *	unit_string_array [N_UNITS_UNDEFINED+1]
static BigReal	scaling_factors [N_UNITS_UNDEFINED+1]

Macro Definition Documentation

dataelement_cons_macro

#define dataelement_cons_macro	(		Mtype,
			MType,
			Mptr
	)

Value:

ParseOptions::DataElement::DataElement(const char *newname,      \
     const char *newparent, int optional, const char *err,       \
     Mtype *ptr)                                                 \
{                                                                \
   init(newname, newparent, optional, err);                      \
   type = MType;                                                 \
   Mptr = ptr;                                                   \
}

Definition at line 153 of file ParseOptions.C.

dataelement_cons_macro_default

#define dataelement_cons_macro_default	(		Mtype,
			MType,
			Mptr,
			Mdef
	)

Value:

ParseOptions::DataElement::DataElement(const char *newname,      \
     const char *newparent, int optional, const char *err,       \
     Mtype *ptr, Mtype defalt)                                   \
{                                                                \
   init(newname, newparent, optional, err);                      \
   type = MType;                                                 \
   Mptr = ptr;                                                   \
   Mdef = defalt;                                                \
   has_default = TRUE;                                           \
   if ( ptr ) *ptr = defalt;                                     \
}

Definition at line 140 of file ParseOptions.C.

parse_input_macro

#define parse_input_macro	(		fctnname,
			type,
			optional
	)

Value:

int ParseOptions::fctnname(const char *parent, const char *newname,   \
                          const char *msg, type *ptr)                 \
{                                                                     \
   DataElement *tmp = new DataElement(newname, parent, optional, msg, \
                                      ptr);                           \
   if (!make_dependencies(tmp)) {                                     \
      iout << iERROR << "ParseOption '" << newname << "' already exists" << "\n" << endi; \
      return FALSE;                                                   \
   }                                                                  \
   add_element(tmp);                                                  \
   return TRUE;                                                       \
}

Definition at line 284 of file ParseOptions.C.

parse_input_macro_b

#define parse_input_macro_b	(		fctnname,
			type,
			optional,
			extra
	)

Value:

int ParseOptions::fctnname(const char *parent, const char *newname,   \
                          const char *msg, type *ptr)                 \
{                                                                     \
   DataElement *tmp = new DataElement(newname, parent, optional, msg, \
                                      ptr);                           \
   if (!make_dependencies(tmp)) {                                     \
      iout << iERROR << "ParseOption '" << newname << "' already exists" << "\n" << endi; \
      return FALSE;                                                   \
   }                                                                  \
   add_element(tmp);                                                  \
   extra;                                                             \
   return TRUE;                                                       \
}

Definition at line 311 of file ParseOptions.C.

parse_input_macro_default

#define parse_input_macro_default	(		fctnname,
			type,
			optional
	)

Value:

int ParseOptions::fctnname(const char *parent, const char *newname,   \
                          const char *msg, type *ptr, type defalt)    \
{                                                                     \
   DataElement *tmp = new DataElement(newname, parent, optional, msg, \
                                      ptr, defalt);                   \
   if (!make_dependencies(tmp)) {                                     \
      iout << iERROR << "ParseOption '" << newname << "' already exists" << "\n" << endi; \
      return FALSE;                                                   \
   }                                                                  \
   add_element(tmp);                                                  \
   return TRUE;                                                       \
}

routines to add dependencies to the array

Definition at line 271 of file ParseOptions.C.

parse_input_macro_default_b

#define parse_input_macro_default_b	(		fctnname,
			type,
			optional,
			extra
	)

Value:

int ParseOptions::fctnname(const char *parent, const char *newname,   \
                          const char *msg, type *ptr, type defalt)    \
{                                                                     \
   DataElement *tmp = new DataElement(newname, parent, optional, msg, \
                                      ptr, defalt);                   \
   if (!make_dependencies(tmp)) {                                     \
      iout << iERROR << "ParseOption '" << newname << "' already exists" << "\n" << endi; \
      return FALSE;                                                   \
   }                                                                  \
   add_element(tmp);                                                  \
   extra;                                                             \
   return TRUE;                                                       \
}

Definition at line 297 of file ParseOptions.C.

parse_stringlist_macro

#define parse_stringlist_macro	(		fctn,
			xxx
	)

Value:

int ParseOptions::fctn(const char *parent, const char *newname, \
                          const char *msg, StringList **ptr, int many_allowed)\
{                                                                            \
   DataElement *tmp = new DataElement(newname, parent, xxx, msg,             \
                                      ptr, many_allowed);                    \
   if (!make_dependencies(tmp)) {                                            \
      iout << iERROR << "ParseOption '" << newname << "' already exists" << "\n" << endi;\
      return FALSE;                                                          \
   }                                                                         \
   add_element(tmp);                                                         \
   return TRUE;                                                              \
}

Definition at line 352 of file ParseOptions.C.

PRINT_DOUBLE

#define PRINT_DOUBLE	(		BUF,
			VAL
	)		Tcl_PrintDouble(0,VAL,BUF)

Definition at line 925 of file ParseOptions.C.

Referenced by ParseOptions::getfromptr(), and PRINT_VECTOR().

set_macro

#define set_macro	(		type,
			field,
			fieldptr
	)

Value:

int ParseOptions::set_##type(DataElement *el)            \
{                                                        \
   if (el->range == FREE_RANGE ||                        \
       (el->range == POSITIVE && el->field > 0) ||       \
       (el->range == NOT_NEGATIVE && el->field >= 0) ||  \
       (el->range == NEGATIVE && el->field < 0) ||       \
       (el->range == NOT_POSITIVE && el->field <= 0)) {  \
      if (el->fieldptr) *(el->fieldptr) = el->field;     \
      return 1;                                          \
   }                                                     \
   iout << iERROR << "'" << el->name << "' was set to " << el->field << " but it " \
           << "should be " << rstring(el->range)          \
           << "\n" << endi;      \
   return 0;                \
}

Definition at line 603 of file ParseOptions.C.

simple_set_macro

#define simple_set_macro	(		type,
			field,
			fieldptr
	)

Value:

void ParseOptions::set_##type(DataElement *el)     \
{                                                   \
   if (el->fieldptr) *(el->fieldptr) = el->field;    \
}

Definition at line 624 of file ParseOptions.C.

Function Documentation

convert()

BigReal convert	(	Units	to,
		Units	from
	)

Definition at line 89 of file ParseOptions.C.

References N_ANGSTROM, N_EV, N_FSEC, N_HOUR, N_KCAL, N_KELVIN, N_KJOULE, N_METER, N_MIN, N_NANOMETER, N_NSEC, N_SEC, N_UNIT, and scaling_factors.

{
// cout << "Converting from " << string(from) << " to " << string(to) << std::endl;
// cout << scaling_factors[from] << " <--> " << scaling_factors[to] << std::endl;
   if (from == N_UNIT && to == N_UNIT) { return 1.0; }
   if ((from == N_NSEC || from == N_FSEC || from == N_SEC || from == N_MIN || 
        from == N_HOUR) &&
       (to   == N_NSEC || to   == N_FSEC || to   == N_SEC || to   == N_MIN || 
        to   == N_HOUR)) {
      return scaling_factors[from]/scaling_factors[to];
   }
   if ((from == N_METER || from == N_NANOMETER || from == N_ANGSTROM) &&
       (to   == N_METER || to   == N_NANOMETER || to   == N_ANGSTROM)) {
      return scaling_factors[from]/scaling_factors[to];
   }
   if ((from == N_KCAL || from == N_KJOULE || from == N_EV) &&
       (to   == N_KCAL || to   == N_KJOULE || to   == N_EV)) {
      return scaling_factors[from]/scaling_factors[to];
   }
   if (from == N_KELVIN && to == N_KELVIN) {
      return scaling_factors[from]/scaling_factors[to];
   }
   return 0.0;
}

dataelement_cons_macro() [1/5]

dataelement_cons_macro	(	BigReal	,
		FLOAT	,
		fptr
	)

dataelement_cons_macro() [2/5]

dataelement_cons_macro	(	Vector	,
		VECTOR	,
		vptr
	)

dataelement_cons_macro() [3/5]

dataelement_cons_macro	(	int	,
		INT	,
		iptr
	)

dataelement_cons_macro() [4/5]

dataelement_cons_macro	(	unsigned	int,
		UINT	,
		uiptr
	)

dataelement_cons_macro() [5/5]

dataelement_cons_macro	(	char	,
		STRING	,
		sptr
	)

dataelement_cons_macro_default() [1/4]

dataelement_cons_macro_default	(	BigReal	,
		FLOAT	,
		fptr	,
		fdef
	)

dataelement_cons_macro_default() [2/4]

dataelement_cons_macro_default	(	int	,
		INT	,
		iptr	,
		idef
	)

dataelement_cons_macro_default() [3/4]

dataelement_cons_macro_default	(	unsigned	int,
		UINT	,
		uiptr	,
		uidef
	)

dataelement_cons_macro_default() [4/4]

dataelement_cons_macro_default	(	Vector	,
		VECTOR	,
		vptr	,
		vdef
	)

next()

static Units next ( Units  u )

static

Definition at line 48 of file ParseOptions.C.

References N_ANGSTROM, N_EV, N_FSEC, N_HOUR, N_KCAL, N_KELVIN, N_KJOULE, N_METER, N_MIN, N_NANOMETER, N_NSEC, N_SEC, N_UNIT, and N_UNITS_UNDEFINED.

Referenced by ConfigList::add_element(), ResidueLookupElem::append(), bin_evaluation_1away(), bin_evaluation_k_away(), PDB::PDB(), Rebalancer::refine(), ParseOptions::set(), spatial_hashing(), ConfigList::~ConfigList(), and ReductionSet::~ReductionSet().

                           {
  switch (u) {
   case N_UNIT: return N_FSEC;
   case N_FSEC: return N_NSEC;
   case N_NSEC: return N_SEC;
   case N_SEC: return N_MIN;
   case N_MIN: return N_HOUR;
   case N_HOUR:  return N_ANGSTROM;
   case N_ANGSTROM: return N_NANOMETER;
   case N_NANOMETER: return N_METER;
   case N_METER: return N_KCAL;
   case N_KCAL: return N_KJOULE;
   case N_KJOULE: return N_EV;
   case N_EV: return N_KELVIN;
   case N_KELVIN: return N_UNITS_UNDEFINED;
   default: return N_UNITS_UNDEFINED;
  }
}

parse_input_macro() [1/10]

parse_input_macro	(	require	,
		BigReal	,
		FALSE
	)

parse_input_macro() [2/10]

parse_input_macro	(	require	,
		Vector	,
		FALSE
	)

parse_input_macro() [3/10]

parse_input_macro	(	require	,
		int	,
		FALSE
	)

parse_input_macro() [4/10]

parse_input_macro	(	require	,
		unsigned	int,
		FALSE
	)

parse_input_macro() [5/10]

parse_input_macro	(	require	,
		char	,
		FALSE
	)

parse_input_macro() [6/10]

parse_input_macro	(	optional	,
		BigReal	,
		TRUE
	)

parse_input_macro() [7/10]

parse_input_macro	(	optional	,
		Vector	,
		TRUE
	)

parse_input_macro() [8/10]

parse_input_macro	(	optional	,
		int	,
		TRUE
	)

parse_input_macro() [9/10]

parse_input_macro	(	optional	,
		unsigned	int,
		TRUE
	)

parse_input_macro() [10/10]

parse_input_macro	(	optional	,
		char	,
		TRUE
	)

parse_input_macro_b() [1/2]

parse_input_macro_b	(	requireB	,
		int	,
		FALSE	,
		tmp->	type = DataElement::BOOL
	)

parse_input_macro_b() [2/2]

parse_input_macro_b	(	optionalB	,
		int	,
		TRUE	,
		tmp->	type = DataElement::BOOL
	)

parse_input_macro_default() [1/8]

parse_input_macro_default	(	require	,
		BigReal	,
		FALSE
	)

parse_input_macro_default() [2/8]

parse_input_macro_default	(	require	,
		Vector	,
		FALSE
	)

parse_input_macro_default() [3/8]

parse_input_macro_default	(	require	,
		int	,
		FALSE
	)

parse_input_macro_default() [4/8]

parse_input_macro_default	(	require	,
		unsigned	int,
		FALSE
	)

parse_input_macro_default() [5/8]

parse_input_macro_default	(	optional	,
		BigReal	,
		TRUE
	)

parse_input_macro_default() [6/8]

parse_input_macro_default	(	optional	,
		Vector	,
		TRUE
	)

parse_input_macro_default() [7/8]

parse_input_macro_default	(	optional	,
		int	,
		TRUE
	)

parse_input_macro_default() [8/8]

parse_input_macro_default	(	optional	,
		unsigned	int,
		TRUE
	)

parse_input_macro_default_b() [1/2]

parse_input_macro_default_b	(	requireB	,
		int	,
		FALSE	,
		tmp->	type = DataElement::BOOL
	)

parse_input_macro_default_b() [2/2]

parse_input_macro_default_b	(	optionalB	,
		int	,
		TRUE	,
		tmp->	type = DataElement::BOOL
	)

parse_stringlist_macro() [1/2]

parse_stringlist_macro	(	require	,
		FALSE
	)

parse_stringlist_macro() [2/2]

parse_stringlist_macro	(	optional	,
		TRUE
	)

PRINT_VECTOR()

static void PRINT_VECTOR ( char *  buf, Vector  val  )

static

Definition at line 927 of file ParseOptions.C.

References PRINT_DOUBLE, Vector::x, Vector::y, and Vector::z.

Referenced by ParseOptions::getfromptr().

                                                {
  PRINT_DOUBLE(buf, val.x);
  buf += strlen(buf); buf[0] = ' '; ++buf;
  PRINT_DOUBLE(buf, val.y);
  buf += strlen(buf); buf[0] = ' '; ++buf;
  PRINT_DOUBLE(buf, val.z);
  buf += strlen(buf); buf[0] = ' '; buf[1] = 0;
}

rstring()

const char* rstring

(

Range

r

)

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 25 of file ParseOptions.C.

References FREE_RANGE, NEGATIVE, NOT_NEGATIVE, NOT_POSITIVE, and POSITIVE.

{
   switch (r) {
    case FREE_RANGE: return "unconstrained";
    case POSITIVE: return "positive";
    case NOT_NEGATIVE: return "non-negative";
    case NEGATIVE: return "negative";
    case NOT_POSITIVE: return "non-positive";
    default: return "error in rstring(Range )";
   }
}

set_macro() [1/3]

set_macro	(	float	,
		fdata	,
		fptr
	)

set_macro() [2/3]

set_macro	(	int	,
		idata	,
		iptr
	)

set_macro() [3/3]

set_macro	(	uint	,
		uidata	,
		uiptr
	)

simple_set_macro() [1/3]

simple_set_macro	(	bool	,
		idata	,
		iptr
	)

simple_set_macro() [2/3]

simple_set_macro	(	vector	,
		vdata	,
		vptr
	)

simple_set_macro() [3/3]

simple_set_macro	(	stringlist	,
		sldata	,
		slptr
	)

Strdup()

static char* Strdup ( const char *  newname )

static

Definition at line 114 of file ParseOptions.C.

{
  char *tmp = new char[strlen(newname)+1];
  strcpy(tmp, newname);
  return tmp;
}

ustring()

const char* ustring

(

Units

u

)

Definition at line 42 of file ParseOptions.C.

References unit_string_array.

Referenced by ParseOptions::units().

{
   return unit_string_array[u];
}

Variable Documentation

scaling_factors

BigReal scaling_factors[N_UNITS_UNDEFINED+1]

static

Initial value:

= {
   1, 1, 1000, 1E15, 60E15, 3600E15, 1, 10, 1E10, 1, 1/4.1855, 1/23.052,
   1, 0
}

Definition at line 82 of file ParseOptions.C.

Referenced by convert().

unit_string_array

const char* unit_string_array[N_UNITS_UNDEFINED+1]

static

Initial value:

=  {
  "", "fs", "ns", "sec", "min", "hr", "A", "nm", "m", 
  "kcal", "kJ", "eV", "K", "undefined units"
}

Definition at line 37 of file ParseOptions.C.

Referenced by ustring().