---

ParmParse.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _PARMPARSE_H_
#define _PARMPARSE_H_

/*
  DISCLAIMER:
  This is ugly because it consists of four files from boxlib
  concatenated together and munged hopelessly.  This was done
  (1) to greatly reduce the size of the API of boxlib
  (2) to avoid the godawful task of rewriting parmparse
  (3) to avoid cluttering the global namespace
  We deeply apologize.

  Any class that begins with PP_ is a convenience
  and will not be in any way supported by anyone at ANAG.
*/

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <string>
#include <vector>

#include <cassert>
#include "MayDay.H"
#include "Misc.H"
#include "Vector.H"
using std::cout;
using std::cerr;
using std::endl;
//#include <aString.H>

//#include <Pointers.H>

//#include <UseCount.H>

//
//@Man:
//@Memo: A Class Encapsulating Reference Counts for ParmParse
/*@Doc:

This class encapsulates reference counts.

This is a convenience class for ParmParse
and will not be in any way supported by anyone at ANAG.
*/
#ifndef DOXYGEN
class PP_UseCount
{
public:
  //
  //
  PP_UseCount ();
  //
  //
  PP_UseCount (const PP_UseCount& rhs);

  PP_UseCount& operator= (const PP_UseCount& rhs);
  //
  //
  ~PP_UseCount ();
  //
  //
  bool unique () const;
  //
  //
  int linkCount () const;

private:
  //
  // A pointer to the reference count.
  //
  unsigned int* cnt;
  //
  // Decrement the reference count and delete the reference
  // counter if there are no more references.
  //
  void decrement ();
};

//
// Inlines.
//

inline
PP_UseCount::PP_UseCount ()
  :
  cnt(new unsigned int(1))
{}

inline
PP_UseCount::PP_UseCount (const PP_UseCount& rhs)
  :
  cnt(rhs.cnt)
{
  ++*cnt;
}

inline
bool
PP_UseCount::unique () const
{
  return *cnt == 1;
}

inline
void
PP_UseCount::decrement ()
{
  if (unique())
    {
      delete cnt;
      cnt = 0;
    }
  else
    --*cnt;
}

inline
PP_UseCount&
PP_UseCount::operator= (const PP_UseCount& rhs)
{
  ++*rhs.cnt;
  decrement();
  cnt = rhs.cnt;
  return *this;
}

inline
PP_UseCount::~PP_UseCount ()
{
  decrement();
}

inline
int
PP_UseCount::linkCount () const
{
  return *cnt;
}


template <class T>
class PP_CpPtr
{
public:
  //
  //
  PP_CpPtr ();
  //
  //
  /*explicit*/ PP_CpPtr (T* rhs);
  //
  //
  ~PP_CpPtr ();

  PP_CpPtr (const PP_CpPtr<T>& rhs);

  PP_CpPtr<T>& operator= (T* rhs);

  PP_CpPtr<T>& operator= (const PP_CpPtr<T>& rhs);

  T& operator* () const;
  //
  //
  bool isNull () const;
  //
  //
  T* release ();
  //
  //
  bool operator== (const PP_CpPtr<T>& rhs) const;
  //
  //
  bool operator!= (const PP_CpPtr<T>& rhs) const;

protected:
  T* ptr;
};


template<class T>
class PP_CpClassPtr :
  public PP_CpPtr<T>
{
public:
  //
  //
  PP_CpClassPtr ();
  //
  //
  /*explicit*/ PP_CpClassPtr (T* rhs);

  PP_CpClassPtr (const PP_CpClassPtr<T>& rhs);

  PP_CpClassPtr<T>& operator= (T* rhs);

  PP_CpClassPtr<T>& operator= (const PP_CpClassPtr<T>& rhs);
  //
  //
  T* operator-> () const;
};


template<class T>
class PP_LnPtr
{
public:
  //
  //
  PP_LnPtr ();
  //
  //
  /*explicit*/ PP_LnPtr (T* rhs);

  PP_LnPtr<T>& operator= (const PP_LnPtr<T>& rhs);

  PP_LnPtr<T>& operator= (T* rhs)
  {
    //
    // This is inlined here as OCC won't have it any other way :-(
    //
    if (unique())
      delete ptr;
    ptr = rhs;
    ucnt = PP_UseCount();
    return *this;
  }

  ~PP_LnPtr ();
  //
  //
  bool unique () const;
  //
  //
  int linkCount () const;

  T& operator* () const;
  //
  //
  bool isNull () const;
  //
  //
  bool operator== (const PP_LnPtr<T>& rhs) const;
  //
  //
  bool operator!= (const PP_LnPtr<T>& rhs) const;

protected:
  T*       ptr;

private:
  PP_UseCount ucnt;
};


template<class T>
class PP_LnClassPtr
  : public PP_LnPtr<T>
{
public:
  //
  //
  PP_LnClassPtr ();
  //
  //
  /*explicit*/ PP_LnClassPtr (T* rhs);

  PP_LnClassPtr<T>& operator= (const PP_LnClassPtr<T>& rhs);

  PP_LnClassPtr<T>& operator= (T* rhs);
  //
  //
  T* operator->() const;
};

//
// Inlines.
//

template <class T>
inline
PP_CpPtr<T>::PP_CpPtr ()
  :
  ptr(0)
{}

template <class T>
inline
PP_CpPtr<T>::PP_CpPtr(T* rhs)
  :
  ptr(rhs)
{}

template <class T>
inline
PP_CpPtr<T>::~PP_CpPtr()
{
  delete ptr;
}

template <class T>
inline
bool
PP_CpPtr<T>::isNull () const
{
  return ptr == 0;
}

template <class T>
inline
PP_CpPtr<T>::PP_CpPtr (const PP_CpPtr<T>& rhs)
{
  ptr = rhs.isNull() ?  0 : new T(*rhs.ptr);
}

template <class T>
inline
PP_CpPtr<T>&
PP_CpPtr<T>::operator= (const PP_CpPtr<T>& rhs)
{
  if (!(ptr == rhs.ptr))
    {
      delete ptr;
      ptr = rhs.isNull() ? 0 : new T(*rhs.ptr);
    }
  return *this;
}

template <class T>
inline
PP_CpPtr<T>&
PP_CpPtr<T>::operator= (T* rhs)
{
  delete ptr;
  ptr = rhs;
  return *this;
}

template <class T>
inline
T&
PP_CpPtr<T>::operator* () const
{
  assert(ptr != 0);
  return *ptr;
}

template <class T>
inline
T*
PP_CpPtr<T>::release ()
{
  T* old = ptr;
  ptr = 0;
  return old;
}

template <class T>
inline
bool
PP_CpPtr<T>::operator== (const PP_CpPtr<T>& rhs) const
{
  return ptr == rhs.ptr;
}

template <class T>
inline
bool
PP_CpPtr<T>::operator!= (const PP_CpPtr<T>& rhs) const
{
  return ptr != rhs.ptr;
}

template <class T>
inline
PP_CpClassPtr<T>::PP_CpClassPtr ()
  :
  PP_CpPtr<T>()
{}

template <class T>
inline
PP_CpClassPtr<T>::PP_CpClassPtr (T* rhs)
  :
  PP_CpPtr<T>(rhs)
{}

template <class T>
inline
PP_CpClassPtr<T>::PP_CpClassPtr (const PP_CpClassPtr<T>& rhs)
  :
  PP_CpPtr<T>(rhs)
{}

template <class T>
inline
PP_CpClassPtr<T>&
PP_CpClassPtr<T>::operator= (T* rhs)
{
  PP_CpPtr<T>::operator= (rhs);
  return *this;
}

template <class T>
inline
PP_CpClassPtr<T>&
PP_CpClassPtr<T>::operator= (const PP_CpClassPtr<T>& rhs)
{
  PP_CpPtr<T>::operator= (rhs);
  return *this;
}

template <class T>
inline
T*
PP_CpClassPtr<T>::operator-> () const
{
  return this->ptr;
}

template <class T>
inline
PP_LnPtr<T>::PP_LnPtr ()
  :
  ptr(0)
{}

template <class T>
inline
PP_LnPtr<T>::PP_LnPtr(T* rhs)
  :
  ptr(rhs)
{}

template <class T>
inline
bool
PP_LnPtr<T>::unique () const
{
  return ucnt.unique();
}

template <class T>
inline
PP_LnPtr<T>::~PP_LnPtr ()
{
  if (ucnt.unique())
    delete ptr;
}

template <class T>
inline
PP_LnPtr<T>&
PP_LnPtr<T>::operator= (const PP_LnPtr<T>& rhs)
{
  if (ptr != rhs.ptr)
    {
      if (unique())
        delete ptr;
      ptr = rhs.ptr;
      ucnt = rhs.ucnt;
    }
  return *this;
}

template <class T>
inline
int
PP_LnPtr<T>::linkCount () const
{
  return ucnt.linkCount();
}

template <class T>
inline
T&
PP_LnPtr<T>::operator* () const
{
  assert(ptr != 0);
  return *ptr;
}

template <class T>
inline
bool
PP_LnPtr<T>::isNull () const
{
  return ptr == 0;
}

template <class T>
inline
bool
PP_LnPtr<T>::operator== (const PP_LnPtr<T>& rhs) const
{
  return ptr == rhs.ptr;
}

template <class T>
inline
bool
PP_LnPtr<T>::operator!= (const PP_LnPtr<T>& rhs) const
{
  return ptr != rhs.ptr;
}

template <class T>
inline
PP_LnClassPtr<T>::PP_LnClassPtr ()
{}

template <class T>
inline
PP_LnClassPtr<T>::PP_LnClassPtr (T* rhs)
  :
  PP_LnPtr<T>(rhs)
{}

template <class T>
inline
PP_LnClassPtr<T>&
PP_LnClassPtr<T>::operator= (const PP_LnClassPtr<T>& rhs)
{
  PP_LnPtr<T>::operator=(rhs);
  return *this;
}

template <class T>
inline
PP_LnClassPtr<T>&
PP_LnClassPtr<T>::operator= (T* rhs)
{
  PP_LnPtr<T>::operator=(rhs);
  return *this;
}

template <class T>
inline
T*
PP_LnClassPtr<T>::operator->() const
{
  return this->ptr;
}

//
// Helper class for class PP_String.
//

class PP_StringRep
{
  friend class PP_String;
  char* s;
  int   bufferlength;
public:
  /*explicit*/ PP_StringRep (int _len = 0);
  ~PP_StringRep ();
  //
  // Resized the buffer and copies the contents of old buffer to new one.
  //
  void resize (int n);
};

//
// PP_StringRep inlines.
//

inline
PP_StringRep::PP_StringRep (int _len)
{
  bufferlength = _len;
  s = new char [bufferlength];
}

inline
PP_StringRep::~PP_StringRep ()
{
  delete [] s;
  s = 0;
}


class PP_String
{
public:
  //
  //
  PP_String ();

  /*explicit*/ PP_String (char c);

  /*explicit*/ PP_String (int len);

  PP_String (const char* s);
  //
  //
  PP_String (const PP_String& rhs);
  //
  //
  PP_String& operator= (const PP_String& rhs);

  PP_String& operator+= (const PP_String& right);

  PP_String& operator+= (const char* right);

  PP_String& operator+= (char c);

  PP_String& toUpper ();

  PP_String& toLower ();

  std::istream& getline (std::istream& strm);

  int length () const;

  //
  //
  bool isNull () const;

  char& operator [] (int k);

  char operator[] (int k) const;

  const char* c_str () const;

  double toDouble () const;

  int toInteger () const;

  long toLong () const;
  //
  //
  friend std::ostream& operator<< (std::ostream&       os,
                                   const PP_String& str);

  friend std::istream& operator>> (std::istream& is,
                                   PP_String& str);

protected:
  void copyModify ();

private:
  PP_LnClassPtr<PP_StringRep> p;
  int                   len;

  //
  // None of the following functions need to be friends.  I've made
  // them friends solely so they'll show up nicely in the HTML documentaion
  // spewed out by doc++.
  //

  //
  // Is left lexically less than right?
  //
  friend inline bool operator<  (const PP_String& left,
                                 const PP_String& right);
  //
  // Is left lexically less than or equal to right?
  //
  friend inline bool operator<= (const PP_String& left,
                                 const PP_String& right);
  //
  // Is left not equal to right?
  //
  friend inline bool operator!= (const PP_String& left,
                                 const PP_String& right);
  //
  // Is left equal to right?
  //
  friend inline bool operator== (const PP_String& left,
                                 const PP_String& right);
  //
  // Is left lexically greater than or equal to right?
  //
  friend inline bool operator>= (const PP_String& left,
                                 const PP_String& right);
  //
  // Is left lexically greater than right?
  //
  friend inline bool operator>  (const PP_String& left,
                                 const PP_String& right);
  //
  // Is left lexically less than right?
  //
  friend inline bool operator<  (const PP_String& left,
                                 const char*    right);
  //
  // Is left lexically less than or equal to right?
  //
  friend inline bool operator<= (const PP_String& left,
                                 const char*    right);
  //
  // Is left not equal to right?
  //
  friend inline bool operator!= (const PP_String& left,
                                 const char*    right);
  //
  // Is left equal to right?
  //
  friend inline bool operator== (const PP_String& left,
                                 const char*    right);
  //
  // Is left lexically greater than or equal to right?
  //
  friend inline bool operator>= (const PP_String& left,
                                 const char*    right);
  //
  // Is left lexically greater than right?
  //
  friend inline bool operator>  (const PP_String& left,
                                 const char*    right);
  //
  // Is left lexically less than right?
  //
  friend inline bool operator<  (const char*    left,
                                 const PP_String& right);
  //
  // Is left lexically less than or equal to right?
  //
  friend inline bool operator<= (const char*    left,
                                 const PP_String& right);
  //
  // Is left not equal to right?
  //
  friend inline bool operator!= (const char*    left,
                                 const PP_String& right);
  //
  // Is left equal to right?
  //
  friend inline bool operator== (const char*    left,
                                 const PP_String& right);
  //
  // Is left lexically greater than or equal to right?
  //
  friend inline bool operator>= (const char*    left,
                                 const PP_String& right);
  //
  // Is left lexically greater than right?
  //
  friend inline bool operator>  (const char*    left,
                                 const PP_String& right);
};

//
// PP_String inlines.
//

inline
bool
PP_String::isNull () const
{
  return len == 0;
}

inline
int
PP_String::length () const
{
  return len;
}

inline
double
PP_String::toDouble () const
{
  return len == 0 ? 0 : std::atof(p->s);
}

inline
int
PP_String::toInteger () const
{
  return len == 0 ? 0 : atoi(p->s);
}

inline
long
PP_String::toLong () const
{
  return len == 0 ? 0 : atol(p->s);
}

inline
const char*
PP_String::c_str () const
{
  return p->s;
}

inline
char
PP_String::operator[] (int index) const
{
  assert(index >=0 && index < len);
  return p->s[index];
}

inline
PP_String
operator+ (const PP_String& left,
           const PP_String& right)
{
  PP_String result(left);
  return result += right;
}

inline
bool
operator< (const PP_String& left,
           const PP_String& right)
{
  return ::strcmp(left.c_str(), right.c_str()) < 0;
}

inline
bool
operator<= (const PP_String& left,
            const PP_String& right)
{
  return ::strcmp(left.c_str(), right.c_str()) <= 0;
}

inline
bool
operator!= (const PP_String& left,
            const PP_String& right)
{
  return ::strcmp(left.c_str(), right.c_str()) != 0;
}

inline
bool
operator== (const PP_String& left,
            const PP_String& right)
{
  return ::strcmp(left.c_str(), right.c_str()) == 0;
}

inline
bool
operator>= (const PP_String& left,
            const PP_String& right)
{
  return ::strcmp(left.c_str(), right.c_str()) >= 0;
}

inline
bool
operator>  (const PP_String& left,
            const PP_String& right)
{
  return ::strcmp(left.c_str(), right.c_str()) > 0;
}

inline
bool
operator< (const PP_String& left,
           const char*    right)
{
  return ::strcmp(left.c_str(), right) < 0;
}

inline
bool
operator<= (const PP_String& left,
            const char*    right)
{
  return ::strcmp(left.c_str(), right) <= 0;
}

inline
bool
operator!= (const PP_String& left,
            const char*    right)
{
  return ::strcmp(left.c_str(), right) != 0;
}

inline
bool
operator== (const PP_String& left,
            const char*    right)
{
  return ::strcmp(left.c_str(), right) == 0;
}

inline
bool
operator>= (const PP_String& left,
            const char*    right)
{
  return ::strcmp(left.c_str(), right) >= 0;
}

inline
bool
operator>  (const PP_String& left,
            const char*    right)
{
  return ::strcmp(left.c_str(), right) > 0;
}

inline
bool
operator< (const char*    left,
           const PP_String& right)
{
  return ::strcmp(left, right.c_str()) < 0;
}

inline
bool
operator<= (const char*    left,
            const PP_String& right)
{
  return ::strcmp(left, right.c_str()) <= 0;
}

inline
bool
operator!= (const char*    left,
            const PP_String& right)
{
  return ::strcmp(left, right.c_str()) != 0;
}

inline
bool
operator== (const char*    left,
            const PP_String& right)
{
  return ::strcmp(left, right.c_str()) == 0;
}

inline
bool
operator>= (const char*    left,
            const PP_String& right)
{
  return ::strcmp(left, right.c_str()) >= 0;
}

inline
bool
operator>  (const char*    left,
            const PP_String& right)
{
  return ::strcmp(left, right.c_str()) > 0;
}

//#include <List.H>

template <class T> class PP_ListLink;
template <class T> class PP_ListIterator;
template <class T> class PP_List;

template <class T>
class PP_ListLink
{
private:
  friend class PP_List<T>;
  friend class PP_ListIterator<T>;

  PP_ListLink (const T&     _val,
               PP_ListLink<T>* _pre,
               PP_ListLink<T>* _suc)
    :
    val(_val),
    pre(_pre),
    suc(_suc)
  {}

private:
  T            val;
  PP_ListLink<T>* pre;
  PP_ListLink<T>* suc;
};


template <class T>
class PP_ListIterator
{
public:
  //
  //
  /*explicit*/ PP_ListIterator (const PP_List<T>& aList);
  //
  //
  PP_ListIterator (const PP_ListIterator<T>& rhs);

  void rewind ();

  const T& operator() () const;

  const T& operator* () const;

  operator void* ();

  bool operator! () const;

  const T& value () const;

  PP_ListIterator<T>& operator++ ();

  PP_ListIterator<T>& operator-- ();

  PP_ListIterator<T> operator-- (int);

  PP_ListIterator<T> operator++ (int);

  bool operator== (const PP_ListIterator<T>&) const;
  //
  //
  bool operator!= (const PP_ListIterator<T>&) const;

protected:
  //
  // Construct a PP_ListIterator<T> to a PP_List<T> and object in that PP_List<T>.
  //
  PP_ListIterator (const PP_List<T>& _list,
                   PP_ListLink<T>*   _p);
  //
  // A reference to the PP_List<T> to which we point.
  //
  const PP_List<T>& list;
  //
  // A pointer to the element in the PP_List<T> to which we point.
  //
  PP_ListLink<T>* p;

private:
  friend class PP_List<T>;
  //
  // These are disallowed.
  //
  PP_ListIterator ();
  PP_ListIterator<T>& operator= (const PP_ListIterator<T>&);
};


template <class T>
class PP_List
{
public:
  //
  //
  PP_List ();
  //
  //
  PP_List (const PP_List<T>& rhs);
  //
  //
  PP_List<T>& operator= (const PP_List<T>& rhs);
  //
  //
  ~PP_List();
  //
  //
  void prepend (const T& value);
  //
  //
  void append (const T& value);
  //
  //
  void add (const T& value);
  //
  //
  void join (const PP_List<T>& src);

  void catenate (PP_List<T>& src);
  //
  //
  void clear ();
  //
  //
  T& firstElement () const;
  //
  //
  T& lastElement () const;

  bool includes (const T& value) const;

  bool operator== (const PP_List<T>& rhs) const;
  //
  //
  bool operator!= (const PP_List<T>& rhs) const;
  //
  //
  bool isEmpty () const;
  //
  //
  bool isNotEmpty () const;
  //
  //
  int length () const;
  //
  //
  void removeFirst ();
  //
  //
  void removeLast ();
  //
  //
  const T& operator[] (const PP_ListIterator<T>& li) const;
  //
  //
  T& operator[] (const PP_ListIterator<T>& li);
  //
  //
  void remove (const T& value);

  void remove (const PP_List<T>& lst);
  //
  //
  void remove (PP_ListIterator<T>& lit);
  //
  //
  void replace (PP_ListIterator<T>& li,
                const T&         val);

  void addAfter (PP_ListIterator<T>& lit,
                 const T&         val);

  void addBefore (PP_ListIterator<T>& lit,
                  const T&         val);
  //
  //
  PP_ListIterator<T> first () const;
  //
  //
  PP_ListIterator<T> last () const;

protected:
  //
  // A helper function for removing nodes.
  //
  void remove (PP_ListLink<T> *ln);
  //
  // A helper function for adding nodes.
  //
  PP_ListLink<T>* addBefore (PP_ListLink<T>* ln,
                             const T&     val);
  //
  // A helper function for adding nodes.
  //
  PP_ListLink<T>* addAfter (PP_ListLink<T>* ln,
                            const T&     val);
  //
  // The head of the list.
  //
  PP_ListLink<T>* head;
  //
  // The tail of the list.
  //
  PP_ListLink<T>* tail;
  //
  // Our good and trusted friend.
  //
  friend class PP_ListIterator<T>;
};

//
// Inlines.
//

//
// The ListIterator stuff.
//

template <class T>
inline
PP_ListIterator<T>::PP_ListIterator (const PP_List<T>& _list,
                                     PP_ListLink<T>*   _p)
  :
  list(_list),
  p(_p)
{}

template <class T>
inline
PP_ListIterator<T>::PP_ListIterator (const PP_List<T>& aList)
  :
  list(aList)
{
  p = list.head;
}

template <class T>
inline
PP_ListIterator<T>::PP_ListIterator (const PP_ListIterator<T>& li)
  :
  list(li.list),
  p(li.p)
{}

template <class T>
inline
void
PP_ListIterator<T>::rewind ()
{
  p = list.head;
}

template <class T>
inline
const T&
PP_ListIterator<T>::operator() () const
{
  assert(p != 0);
  return p->val;
}

template <class T>
inline
const T&
PP_ListIterator<T>::operator* () const
{
  assert(p != 0);
  return p->val;
}

template <class T>
inline
PP_ListIterator<T>::operator void* ()
{
  return p != 0 ? this : 0;
}

template <class T>
inline
bool
PP_ListIterator<T>::operator! () const
{
  return p == 0 ? true : false;
}

template <class T>
inline
const T&
PP_ListIterator<T>::value () const
{
  assert(p != 0);
  return p->val;
}

template <class T>
inline
PP_ListIterator<T>&
PP_ListIterator<T>::operator++ ()
{
  if (p)
    p = p->suc;
  return *this;
}

template <class T>
inline
PP_ListIterator<T>&
PP_ListIterator<T>::operator-- ()
{
  if (p)
    p = p->pre;
  return *this;
}

template <class T>
inline
PP_ListIterator<T>
PP_ListIterator<T>::operator++ (int)
{
  const PP_ListIterator<T> li = *this;
  ++(*this);
  return li;
}

template <class T>
inline
PP_ListIterator<T>
PP_ListIterator<T>::operator-- (int)
{
  const PP_ListIterator<T> li = *this;
  --(*this);
  return li;
}

template <class T>
inline
bool
PP_ListIterator<T>::operator== (const PP_ListIterator<T>& _li) const
{
  return (&list == &_li.list && p == _li.p) ? true : false;
}

template <class T>
inline
bool
PP_ListIterator<T>::operator!= (const PP_ListIterator<T>& _li) const
{
  return ! PP_ListIterator<T>::operator==(_li);
}

//
// List stuff.
//

template <class T>
inline
PP_List<T>::PP_List ()
  :
  head(0),
  tail(0)
{}

template <class T>
inline
PP_List<T>::~PP_List ()
{
  clear();
}

template <class T>
inline
void
PP_List<T>::prepend (const T& value)
{
  addBefore(head, value);
}

template <class T>
inline
void
PP_List<T>::append (const T& value)
{
  addAfter(tail, value);
}

template <class T>
inline
T&
PP_List<T>::firstElement () const
{
  assert(head != 0);
  return head->val;
}

template <class T>
inline
T&
PP_List<T>::lastElement () const
{
  assert(tail != 0);
  return tail->val;
}

template <class T>
inline
bool
PP_List<T>::isEmpty () const
{
  return head == 0 && tail == 0;
}

template <class T>
inline
bool
PP_List<T>::isNotEmpty () const
{
  return !isEmpty();
}

template <class T>
inline
void
PP_List<T>::removeFirst ()
{
  remove(head);
}

template <class T>
inline
void
PP_List<T>::removeLast ()
{
  remove(tail);
}

template <class T>
inline
const T&
PP_List<T>::operator[] (const PP_ListIterator<T>& li) const
{
  assert(li.p != 0);
  return li.p->val;
}

template <class T>
inline
T&
PP_List<T>::operator[] (const PP_ListIterator<T>& li)
{
  assert(li.p != 0);
  return li.p->val;
}

template <class T>
inline
void
PP_List<T>::replace (PP_ListIterator<T>& li,
                     const T&         _val)
{
  assert(li.p != 0);
  li.p->val = _val;
}

template <class T>
inline
void
PP_List<T>::addAfter (PP_ListIterator<T>& lit,
                      const T&         val)
{
  addAfter(lit.p, val);
}

template <class T>
inline
void
PP_List<T>::addBefore (PP_ListIterator<T>& lit,
                       const T&         val)
{
  addBefore(lit.p, val);
}

template <class T>
inline
PP_ListIterator<T>
PP_List<T>::first () const
{
  return PP_ListIterator<T>(*this,head);
}

template <class T>
inline
PP_ListIterator<T>
PP_List<T>::last () const
{
  return PP_ListIterator<T>(*this,tail);
}

//
// List members
//

template <class T>
inline
PP_List<T>::PP_List (const PP_List<T>& source)
  :
  head(0),
  tail(0)
{
  if (source.isEmpty())
    tail = head = 0;
  else
    for (PP_ListIterator<T> li(source); li; ++li)
      append(li());
}

//
// This isn't inlined as it's declared virtual.
//

template <class T>
inline void
PP_List<T>::add (const T& value)
{
  append(value);
}

template <class T>
inline
int
PP_List<T>::length () const
{
  int len = 0;
  for (PP_ListIterator<T> li(*this); li; ++li)
    len++;
  return len;
}

template <class T>
inline
PP_List<T>&
PP_List<T>::operator= (const PP_List<T>& source)
{
  if (!(this == &source))
    {
      clear();
      for (PP_ListIterator<T> li(source); li; ++li)
        append(li());
    }
  return *this;
}

template <class T>
inline PP_ListLink<T> *
PP_List<T>::addBefore (PP_ListLink<T>* ln,
                       const T&     val)
{
  assert(ln != 0 || head == 0);

  PP_ListLink<T>* newlink;

  if (ln == head)
    {
      head = newlink = new PP_ListLink<T>(val, 0, head);

      if (tail == 0)
        tail = head;
      else
        head->suc->pre = newlink;
    }
  else
    {
      newlink = new PP_ListLink<T>(val, ln->pre, ln);

      ln->pre->suc = newlink;
      ln->pre = newlink;
    }

  return newlink;
}

template <class T>
inline
PP_ListLink<T>*
PP_List<T>::addAfter (PP_ListLink<T>* ln,
                      const T&     val)
{
  assert(ln != 0 || tail == 0);

  PP_ListLink<T>* newlink;

  // trying this here to satisfy icc -O2 (ndk)
  // this worked for me -- but since we aren't actively using icc, i'll
  // leave it commented.
  //newlink = new PP_ListLink<T>(val,tail,0);
  //delete newlink;

  if (ln == tail)
    {
      tail = newlink = new PP_ListLink<T>(val,tail,0);

      if (head == 0)
        head = tail;
      else
        tail->pre->suc = newlink;
    }
  else
    {
      newlink = new PP_ListLink<T>(val, ln, ln->suc);

      ln->suc->pre = newlink;
      ln->suc = newlink;
    }

  return newlink;
}

template <class T>
inline void
PP_List<T>::join (const PP_List<T>& list2)
{
  for (PP_ListIterator<T> li2(list2); li2; ++li2)
    append(li2());
}

template <class T>
inline void
PP_List<T>::catenate (PP_List<T>& list2)
{
  if (list2.isEmpty())
    //
    // Do nothing.
    //
    ;
  else if (isEmpty())
    {
      head = list2.head;
      tail = list2.tail;
      list2.head = 0;
      list2.tail = 0;
    }
  else
    {
      tail->suc = list2.head;
      list2.head->pre = tail;
      tail = list2.tail;
      list2.head = 0;
      list2.tail = 0;
    }
}

template <class T>
inline void
PP_List<T>::clear ()
{
  PP_ListLink<T>* next = 0;

  for (PP_ListLink<T>* p = head; p != 0; p = next)
    {
      next = p->suc;
      p->suc = 0;
      delete p;
    }
  tail = head = 0;
}

template <class T>
inline bool
PP_List<T>::includes (const T& v) const
{
  bool rc = false;
  for (PP_ListIterator<T> li(*this); li && !rc; ++li)
    if (v == li())
      rc = true;
  return rc;
}

template<class T>
inline bool
PP_List<T>::operator== (const PP_List<T>& rhs) const
{
  if (length() == rhs.length())
    {
      for (PP_ListIterator<T> li(*this), ri(rhs); li; ++li, ++ri)
        if (li() != ri())
          return false;
      return true;
    }

  return false;
}

template<class T>
inline bool
PP_List<T>::operator!= (const PP_List<T>& rhs) const
{
  return !operator==(rhs);
}

template <class T>
inline void
PP_List<T>::remove (PP_ListIterator<T>& li)
{
  PP_ListLink<T> *np = li.p->suc;
  remove(li.p);
  li.p = np;
}

template <class T>
inline void
PP_List<T>::remove (const T& _v)
{
  for (PP_ListIterator<T> litr(*this); litr; ++litr)
    if (litr() == _v)
      remove(litr);
}

template <class T>
inline void
PP_List<T>::remove (const PP_List<T>& _lv)
{
  for (PP_ListIterator<T> litr(_lv); litr; ++litr)
    remove(litr());
}

template <class T>
inline void
PP_List<T>::remove (PP_ListLink<T>* ln)
{
  assert(head !=0 && tail != 0);

  if (head == ln && tail == ln)
    head = tail = 0;
  else if (head == ln)
    {
      assert(ln->pre == 0);
      head = ln->suc;
      head->pre = 0;
    }
  else if (tail == ln)
    {
      assert(ln->suc == 0);
      tail = ln->pre;
      tail->suc  = 0;
    }
  else
    {
      assert(ln->suc != 0 && ln->pre != 0);
      ln->suc->pre = ln->pre;
      ln->pre->suc = ln->suc;
    }
  delete ln;
  ln = 0;
}

template <class T> class PP_Array;


template <class T>
class PP_Array
{
public:
  //
  //
  PP_Array ();

  /*explicit*/ PP_Array (long len);

  PP_Array (long     len,
            const T& initialvalue);

  PP_Array (const T* vec,
            long     len);
  //
  //
  PP_Array (const PP_Array<T>& rhs);

  PP_Array<T>& operator= (const PP_Array<T>& rhs);
  //
  //
  ~PP_Array ();

  void clear ();
  //
  //
  bool ready  () const;

  void reserve (long _truesize);

  void shrinkWrap ();

  void resize (long newlen);

  void resize (long     newlen,
               const T& initialvalue);
  //
  //
  long length () const;

  long trueSize () const;

  T& operator[] (long K);
  //
  //
  const T& operator[] (long K) const;
  //
  //
  T& get (long i);
  //
  //
  const T& get (long i) const;

  T* dataPtr ();
  //
  //
  const T* dataPtr () const;
  //
  //
  void set (long     i,
            const T& elem);
  //
  //
  void swap (long i,
             long j);
  //
  //
  bool operator== (const PP_Array<T>& rhs) const;
  //
  //
  bool operator!= (const PP_Array<T>& rhs) const;

protected:
  //
  // The true size of the PP_Array.
  //
  long truesize;
  //
  // The number of elements in the PP_Array.
  //
  long nelem;
  //
  // The array itself.
  //
  T* vp;

private:
  //
  // This is disallowed.
  //
  PP_Array<T>& operator= (int);
};

//
// Inlines.
//

template <class T>
inline
PP_Array<T>::PP_Array ()
{
  nelem    = 0;
  vp       = new T[1];
  truesize = 1;
}

template <class T>
inline
PP_Array<T>::PP_Array (long len)
{
  assert(len >= 0);
  nelem    = len;
  vp       = new T[len];
  truesize = nelem;
}

template <class T>
inline
void
PP_Array<T>::clear ()
{
  delete [] vp;
  vp       = 0;
  nelem    = 0;
  truesize = 0;
}

template <class T>
inline
PP_Array<T>::~PP_Array ()
{
  clear();
}

template <class T>
inline
bool
PP_Array<T>::ready () const
{
  return vp != 0 && nelem != 0;
}

template <class T>
inline
long
PP_Array<T>::length () const
{
  return nelem;
}

template <class T>
inline
long
PP_Array<T>::trueSize () const
{
  return truesize;
}

template <class T>
inline
T&
PP_Array<T>::operator[] (long i)
{
  assert(vp != 0);
  assert(i >= 0 && i < nelem);
  return vp[i];
}

template <class T>
inline
const T&
PP_Array<T>::operator[] (long i) const
{
  assert(vp != 0);
  assert(i >= 0 && i < nelem);
  return vp[i];
}

template <class T>
inline
T&
PP_Array<T>::get (long i)
{
  assert(vp != 0);
  assert(i >= 0 && i < nelem);
  return vp[i];
}

template <class T>
inline
const T&
PP_Array<T>::get (long i) const
{
  assert(vp != 0);
  assert(i >= 0 && i < nelem);
  return vp[i];
}

template <class T>
inline
void
PP_Array<T>::set (long     i,
                  const T& elem)
{
  assert(vp != 0);
  assert(i >= 0 && i < nelem);
  vp[i] = elem;
}

template <class T>
inline
T*
PP_Array<T>::dataPtr ()
{
  return vp;
}

template <class T>
inline
const T*
PP_Array<T>::dataPtr () const
{
  return vp;
}

template <class T>
inline
void
PP_Array<T>::swap (long i,
                   long j)
{
  assert(i >= 0 && i < nelem);
  assert(j >= 0 && j < nelem);
  T tmp = vp[i];
  vp[i] = vp[j];
  vp[j] = tmp;
}

template <class T>
inline
bool
PP_Array<T>::operator!= (const PP_Array<T>& rhs) const
{
  return !(operator==(rhs));
}

//
// Non-inlined stuff.
//

template <class T>
PP_Array<T>::PP_Array (long     len,
                       const T& initialValue)
{
  assert(len >= 0);
  nelem = len;
  vp    = new T[len];
  truesize = nelem;
  for(long i = 0; i < nelem; ++i)
    vp[i] = initialValue;
}

template <class T>
PP_Array<T>::PP_Array (const T* vec,
                       long     len)
{
  assert(len >= 0);
  nelem = len;
  vp    = new T[len];
  truesize = nelem;
  for(long i = 0; i < nelem; ++i)
    vp[i] = vec[i];
}

template <class T>
PP_Array<T>::PP_Array (const PP_Array<T>& a)
{
  nelem = a.nelem;
  vp    = new T[nelem];
  truesize = nelem;
  for (long i = 0; i < nelem; i++)
    vp[i] = a.vp[i];
}

template <class T>
PP_Array<T>&
PP_Array<T>::operator= (const PP_Array<T>& sa)
{
  if (this != &sa)
    {
      clear();
      vp       = new T[sa.nelem];
      nelem    = sa.nelem;
      truesize = nelem;
      for(long i = 0; i < nelem; i++)
        vp[i] = sa.vp[i];
    }
  return *this;
}

template <class T>
inline
void
PP_Array<T>::resize (long newlen)
{
  if (newlen == nelem)
    return;
  if (newlen <= truesize)
    {
      nelem = newlen;
      return;
    }
  T* newvp = new T[newlen];
  long len = Min(newlen,nelem);
  for (long i = 0; i < len; i++)
    newvp[i] = vp[i];
  delete [] vp;
  vp = newvp;
  nelem = newlen;
  truesize = newlen;
}

template <class T>
inline
void PP_Array<T>::resize (long     newlen,
                          const T& initialValue)
{
  if (newlen == nelem)
    return;
  if (newlen <= truesize)
    {
      for(long i = nelem; i < newlen; ++i)
        vp[i] = initialValue;
      nelem = newlen;
      return;
    }
  T* newvp = new T[newlen];
  long len = Min(newlen,nelem);
  long i;
  for (i = 0; i < len; i++)
    newvp[i] = vp[i];
  for(i = len; i < newlen; ++i)
    newvp[i] = initialValue;
  delete [] vp;
  vp = newvp;
  nelem = newlen;
  truesize = newlen;
}

template <class T>
void
PP_Array<T>::reserve (long _truesize)
{
  if (_truesize > truesize)
    {
      T* newvp = new T[_truesize];
      for (long i = 0; i < nelem; i++)
        newvp[i] = vp[i];
      delete [] vp;
      vp = newvp;
      truesize = _truesize;
    }
}

template <class T>
void
PP_Array<T>::shrinkWrap ()
{
  if (nelem != truesize)
    {
      T* newvp = new T[nelem];
      for (long i = 0; i < nelem; i++)
        newvp[i] = vp[i];
      delete [] vp;
      vp = newvp;
      truesize = nelem;
    }
}

template <class T>
bool
PP_Array<T>::operator== (const PP_Array<T>& rhs) const
{
  if (length() != rhs.length())
    return false;

  for (long i = 0; i < length(); ++i)
    if (!((*this)[i] == rhs[i]))
      return false;

  return true;
}

// -----------------------------------------------------------------
// ----------------------- COMMENTS -------------------------------
// -----------------------------------------------------------------
// The ParmParse class implements a simple database for the storage
// and retrieval of command-line and input-file arguments.  The
// entries are stored in a static table in (name,value_list) pairs.
//
// The format of the input file is a series of OPTIONS and DEFINITIONS.
//
// An OPTION is an entry of the form:  -<name> and has no associated list
// of values.  For example, the command line:
//        prog -verbose -no_opt
// has two options: "verbose" and "no_opt".
//
// A DEFINITION is of the form  <name> = <value> <value> ...
// The equal sign is important since the list of values can span multiple
// lines.
//
// Comments in an input file include all text from a '#' character to the
// end of the line.  Here is an example input file:
//
//   -no_garbage                # an OPTION
//   niter = 100                # niter is an integer
//   title = "Double Wammy"     # example of a string with spaces
//   cell_size = 0.5 0.75       # cell spacing in each dimension
//   plot.var = Density 1 10    # a list of values
//   plot.var = Energy  5 12    # another list of values
//   bigarray = 1 2 3 4 5 6 7 8 # first part of array
//              9 10 11 12      # continuation of bigarray
//   test = apple "boy blue" 10 20 30 40
//   FILE = prob_file           # insert contents of this "prob_file" here
//
// The "FILE = <filename>" definition is special.  Rather than just
// adding this entry to the database, it reads the contents of <filename>
// into the database.
//
// ParmParse stores all entries in a static table which is built the
// first time a ParmParse object is constructed (usually in main()).
// Subsequent invocations have access to this table.
// A ParmParse constructor has an optional "prefix" argument that will
// limit the searches to only those entries of the table with this prefix
// in name.  For example:
//     ParmParse pp("plot");
// will find only those entries with name given by "plot.<string>".
//
// All values in the table are stored as strings.  For example, the
// values of "cell_size" in the above input file are stored as the
// strings "0.5" and "0.75".  These strings can be returned as either
// string of numeric values by the query functions.
// Character strings with spaces must be delimited by double quotes
// in the input file but the quotes are stripped before they are entered
// into the table.  For example, 'title' in the above input file has a
// single value, the string 'Double Wammy' (without the quotes).
// Each value in the list associated with a definition can be referred to
// by its index number.  The index numbers start at 0 just like an array
// in the C programming language.  Consider the definition of "test" in
// the above input file.  The first value 'apple'is a string with index
// 0.  The second value 'boy blue' is a string with index 1.  The
// remaining four values are integers indexed 2, 3, 4, and 5.
//
// For a string value to represent an integer or float it must fit the
// following regular experssion:
//   Sign    ::= '+' | '-'
//   Digit   ::= '0' | '1' | ... | '9'
//   Integer ::= [Sign]Digit+
//   Exp     ::= ('e'|'E')Integer
//   Float   ::= ( Integer[.Digit*][Exp] | [Integer].Digit+[Exp] )
//
// Where '+' indicates one or more occurences, '*' represents zero or
// more occurences, '|' means one or the other and '[]' represents zero
// or one occurence.
//
// Note that floats and doubles have the same string representation and
// that the FORTRAN "double" exponent format is not supported.
// That is, 1.0d+3 is not a valid representation of a floating point
// number but that 1.0e+3 is acceptable.
//
// There are a host of functions allowing the user to query the database
// and retrieve values.  Here are some general rules about the names of
// the member functions:
//
// * Functions with the string "get" in their names attempt to get a
//   value or an array of values from the table.  They generate a
//   run-time error if they are not successful.
//
// * Functions with the string "query" in their names attempt to get a
//   value or an array of values from the table.  They return the value 1
//   (true) if they are successful and 0 (false) if not.
//
// * Functions with the string "arr" in their names get an Array of
//   values from the given entry in the table.  The array argument is
//   resized (if necessary) to hold all the values requested.
//
// * Functions without the string "arr" in their names get single
//   values from the given entry in the table.
//
// The following is a code sample showing how to use ParmParse:
//
// main(int argc, char **argv)
// {
//     char* in_file_name = argv[1];
//     ParmParse pp(argc-2, argv+2, 0, in_file_name);
//
//     // was the "-verbose" command line argument set?
//     int verbose = pp.contains("verbose");
//
//     // Query table for value of "niter".  If not in table
//     // then set to default value
//     if (!pp.query("niter",niter)) niter = 20;
//
//     // read array of cell sizes if in table
//     std::vector<float> dx;
//     if (nx=pp.countval("cell_size")) {
//        // get nx values starting at index 0 and store in dx.
//        // dx is automatically resized here.
//        pp.getarr("cell_size",dx,0,nx);
//     }
// }
//
// void do_graphics()
// {
//    //
//    // Will only query entries with the "plot" prefix:
//    //
//    ParmParse pp("plot");
//    //
//    // Read all variables with "plot.var" keyword.
//    //
//    std::string var_name;
//    std::vector<int> range;
//    int num = pp.countname("var");
//    //
//    // Element 0 in list is a string.
//    //
//    pp.get("var",var_name,0);
//    //
//    // Elements 1 and 2 are integers.
//    // Note that "range" will be resized to hold 2 elements.
//    //
//    pp.getarr("var",range,1,2);
//    cout << "variable = " << var_name << "lo, hi = ",
//         << range[0] << " " << range[1] << endl;
// }
// -----------------------------------------------------------------
// -----------------------  END COMMENTS ---------------------------
// -----------------------------------------------------------------

//
// Forward reference to private class.
//
class PP_entry;

#endif //for the doxygen thing


class ParmParse
{
  friend class PP_entry;
public:


  ParmParse (int         argc,
             char**      argv,
             const char* prefix  = 0,
             const char* parfile = 0);

  /*explicit*/ ParmParse (const char* prefix = 0);

  ~ParmParse();


  bool contains (const char* name);


  bool contains (const std::string& name);


  int countval (const char* name,
                int         n = -1);


  int countname (const char* name);


  int countname (const std::string& name);


  void dumpTable (std::ostream& os);


  void get (const char* name,
            int&        ref,
            int         ival=0);


  int query (const char* name,
             int&        ref,
             int         ival=0);


  void get (const char* name,
            float&      ref,
            int         ival=0);


  int query (const char* name,
             float&      ref,
             int         ival=0);


  void get (const char* name,
            double&     ref,
            int         ival=0);


  int query (const char* name,
             double&     ref,
             int         ival=0);


  void get (const char*  name,
            std::string& ref,
            int          ival=0);


  int query (const char*  name,
             std::string& ref,
             int          ival=0);


  void getarr (const char* name,
               Vector<int>& ref,
               int         start_ix,
               int         num_val);


  void getarr (const char* name,
               std::vector<int>& ref,
               int         start_ix,
               int         num_val);


  int queryarr (const char* name,
                Vector<int>& ref,
                int         start_ix,
                int         num_val);


  int queryarr (const char* name,
                std::vector<int>& ref,
                int         start_ix,
                int         num_val);


  void getarr (const char*   name,
               Vector<float>& ref,
               int           start_ix,
               int           num_val);


  void getarr (const char*   name,
               std::vector<float>& ref,
               int           start_ix,
               int           num_val);


  int queryarr (const char*   name,
                Vector<float>& ref,
                int           start_ix,
                int           num_val);


  int queryarr (const char*   name,
                std::vector<float>& ref,
                int           start_ix,
                int           num_val);


  void getarr (const char*    name,
               Vector<double>& ref,
               int            start_ix,
               int            num_val);


  void getarr (const char*    name,
               std::vector<double>& ref,
               int            start_ix,
               int            num_val);


  int queryarr (const char*    name,
                Vector<double>& ref,
                int            start_ix,
                int            num_val);


  int queryarr (const char*    name,
                std::vector<double>& ref,
                int            start_ix,
                int            num_val);


  void getarr (const char*     name,
               Vector<std::string>& ref,
               int             start_ix,
               int             num_val);


  void getarr (const char*     name,
               std::vector<std::string>& ref,
               int             start_ix,
               int             num_val);


  int queryarr (const char*               name,
                Vector<std::string>& ref,
                int                       start_ix,
                int                       num_val);


  int queryarr (const char*               name,
                std::vector<std::string>& ref,
                int                       start_ix,
                int                       num_val);

#ifndef DOXYGEN
  //
  // This should be protected, but cfront-derived compilers complain :-(
  //
  enum PPType
    {
      ppDefn,
      ppOption,
      ppInt,
      ppFloat,
      ppDouble,
      ppString,
      ppEQ_sign,
      ppEOF
    };


protected:
  //
  // Table of entries common to all objects.
  //
  static PP_List<PP_entry*> table;
  //
  // Command line arguments.
  //
  static int    xargc;
  static char** xargv;
  //
  // Keep track of number of ParmParse objects out there.
  //
  static int num_obj;
  //
  // Parses string and builds table.
  //
  void bldTable (const char*      str,
                 int              lenstr,
                 PP_List<PP_entry*>& tab);
  //
  // Add defn to table, check for file inclusion.
  //
  void addDefn (PP_String&         def,
                PP_List<PP_String>&   val,
                PP_List<PP_entry*>& tab);
  //
  // Reads file into string then parses it with call to bldTable.
  //
  void read_file (const char*      fname,
                  PP_List<PP_entry*>& tab);
  //
  // Lexical analyser called by bldTable.
  //
  PPType getToken (const char*,
                   int&,
                   int,
                   char*);
  //
  // Reclaims memory used in table.
  //
  void rmTable ();
  //
  // Prefix used in keyword search.
  //
  PP_String thePrefix;
  //
  // Used by constructor to build table.
  //
  void ppinit (const char* parfile);
  //
  // Find n'th occurence of name in table.
  //
  const PP_entry* ppindex (int         n,
                           const char* name) const;
  //
  // Get ival_th value of k_th occurence of given name.
  // If k_th occurence does not exist or ival_th value does
  // not exist or if ival_type does not match with type, an
  // error message is reported and the program halts.
  // If successful, value is stored in ptr.
  // same as above but searches for last occurence of name.
  //
  void  getval (const char* name,
                const PPType type,
                void*        ptr,
                int          ival,
                int          k=-1);
  //
  // Get an array of values.
  //
  void getarr (const char*  name,
               const PPType type,
               void*        ptr,
               int          start_ix,
               int          num_val,
               int          k=-1);
  int queryval (const char*  name,
                const PPType type,
                void*        ptr,
                int          ival,
                int          k=-1);
  int queryarr (const char*  name,
                const PPType type,
                void*        ptr,
                int          start_ix,
                int          num_val,
                int          k=-1);

  bool isInteger (const PP_String& str,
                  int&           val);
  int isDouble (const PP_String& str,
                double&        val);

#endif /* DOXYGEN ENDIF */

};

#ifndef DOXYGEN
class PP_entry
{
private:
  friend class ParmParse;
  PP_entry()
  {}

  PP_entry (PP_String&          name,
            ParmParse::PPType typ,
            PP_List<PP_String>&    vals);

  ~PP_entry()
  {}

  PP_String               defname;
  ParmParse::PPType     deftype;
  PP_Array<PP_String>        val;

  void dump (std::ostream& os) const;
};
#endif //doxygen

//
// Inlines.
//

inline
int
ParmParse::countval (const char* name,
                     int         n)
{
  //
  // First find n'th occurance of name in table.
  //
  const PP_entry* def = ppindex(n,name);
  return def == 0 ? 0 : def->val.length();
}

inline
void
ParmParse::get (const char* name,
                int&        ptr,
                int ival)
{
  getval(name,ppInt,&ptr,ival,-1);
}

inline
int
ParmParse::query (const char* name,
                  int&        ptr,
                  int         ival)
{
  return queryval(name,ppInt,&ptr,ival,-1);
}

inline
void
ParmParse::get (const char* name,
                float&      ptr,
                int         ival)
{
  getval(name,ppFloat,&ptr,ival,-1);
}

inline
int
ParmParse::query (const char* name,
                  float&      ptr,
                  int         ival)
{
  return queryval(name,ppFloat,&ptr,ival,-1);
}

inline
void
ParmParse::get (const char* name,
                double&     ptr,
                int         ival)
{
  getval(name,ppDouble,&ptr,ival,-1);
}

inline
int
ParmParse::query (const char* name,
                  double&     ptr,
                  int         ival)
{
  return queryval(name,ppDouble,&ptr,ival,-1);
}

inline
void
ParmParse::get (const char*  name,
                std::string& ptr,
                int          ival)
{
  PP_String pp_string;
  getval(name,ppString,&pp_string,ival,-1);
  ptr = pp_string.c_str();
}

inline
int
ParmParse::query (const char*  name,
                  std::string& ptr,
                  int          ival)
{
  PP_String pp_string;
  int status = queryval(name,ppString,&pp_string,ival,-1);
  if (status != 0)
    ptr = pp_string.c_str();
  return status;
}

inline
void
ParmParse::getarr (const char* name,
                   std::vector<int>& ptr,
                   int         start_ix,
                   int         num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  int* c_array = new int[num_val];
  getarr(name,ppInt,c_array,start_ix,num_val,-1);
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i];
    }
  delete[] c_array;
}

inline
void
ParmParse::getarr (const char* name,
                   Vector<int>& ptr,
                   int         start_ix,
                   int         num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  int* c_array = new int[num_val];
  getarr(name,ppInt,c_array,start_ix,num_val,-1);
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i];
    }
  delete[] c_array;
}

inline
int
ParmParse::queryarr (const char* name,
                     std::vector<int>& ptr,
                     int         start_ix,
                     int         num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  int* c_array = new int[num_val];
  int status = queryarr(name,ppInt,c_array,start_ix,num_val,-1);
  if (status != 0 )
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i];
        }
    }
  return status;
}

inline
int
ParmParse::queryarr (const char* name,
                     Vector<int>& ptr,
                     int         start_ix,
                     int         num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  int* c_array = new int[num_val];
  int status = queryarr(name,ppInt,c_array,start_ix,num_val,-1);
  if (status != 0 )
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i];
        }
    }
  return status;
}

inline
void
ParmParse::getarr (const char*   name,
                   std::vector<float>& ptr,
                   int           start_ix,
                   int           num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  float* c_array = new float[num_val];
  getarr(name,ppFloat,c_array,start_ix,num_val,-1);
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i];
    }
  delete[] c_array;
}

inline
void
ParmParse::getarr (const char*   name,
                   Vector<float>& ptr,
                   int           start_ix,
                   int           num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  float* c_array = new float[num_val];
  getarr(name,ppFloat,c_array,start_ix,num_val,-1);
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i];
    }
  delete[] c_array;
}

inline
int
ParmParse::queryarr (const char*   name,
                     std::vector<float>& ptr,
                     int           start_ix,
                     int           num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  float* c_array = new float[num_val];
  int status = queryarr(name,ppFloat,c_array,start_ix,num_val,-1);
  if (status != 0)
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i];
        }
    }
  delete[] c_array;
  return status;
}

inline
int
ParmParse::queryarr (const char*   name,
                     Vector<float>& ptr,
                     int           start_ix,
                     int           num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  float* c_array = new float[num_val];
  int status = queryarr(name,ppFloat,c_array,start_ix,num_val,-1);
  if (status != 0)
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i];
        }
    }
  delete[] c_array;
  return status;
}

inline
void
ParmParse::getarr (const char*    name,
                   std::vector<double>& ptr,
                   int            start_ix,
                   int            num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  double* c_array = new double[num_val];
  int status = queryarr(name,ppDouble,c_array,start_ix,num_val,-1);
  if (status == 0)
    {
      cerr << "ParmParse::getarr(): "
           << name
           << " not found in table" << endl;
      dumpTable(cerr);
      MayDay::Abort();
    }
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i];
    }
  delete[] c_array;
}

inline
void
ParmParse::getarr (const char*    name,
                   Vector<double>& ptr,
                   int            start_ix,
                   int            num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  double* c_array = new double[num_val];
  int status = queryarr(name,ppDouble,c_array,start_ix,num_val,-1);
  if (status == 0)
    {
      cerr << "ParmParse::getarr(): "
           << name
           << " not found in table" << endl;
      dumpTable(cerr);
      MayDay::Abort();
    }
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i];
    }
  delete[] c_array;
}

inline
int
ParmParse::queryarr (const char*    name,
                     std::vector<double>& ptr,
                     int            start_ix,
                     int            num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  double* c_array = new double[num_val];
  int status = queryarr(name,ppDouble,c_array,start_ix,num_val,-1);
  if (status != 0)
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i];
        }
    }
  delete[] c_array;
  return status;
}

inline
int
ParmParse::queryarr (const char*    name,
                     Vector<double>& ptr,
                     int            start_ix,
                     int            num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  double* c_array = new double[num_val];
  int status = queryarr(name,ppDouble,c_array,start_ix,num_val,-1);
  if (status != 0)
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i];
        }
    }
  delete[] c_array;
  return status;
}

inline
void
ParmParse::getarr (const char*     name,
                   std::vector<std::string>& ptr,
                   int             start_ix,
                   int             num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  PP_String* c_array = new PP_String[num_val];
  getarr(name,ppString,c_array,start_ix,num_val,-1);
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i].c_str();
    }
  delete[] c_array;
}

inline
void
ParmParse::getarr (const char*     name,
                   Vector<std::string>& ptr,
                   int             start_ix,
                   int             num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  PP_String* c_array = new PP_String[num_val];
  getarr(name,ppString,c_array,start_ix,num_val,-1);
  for (int i = 0; i < num_val; ++i)
    {
      ptr[i] = c_array[i].c_str();
    }
  delete[] c_array;
}

inline
int
ParmParse::queryarr (const char*     name,
                     std::vector<std::string>& ptr,
                     int             start_ix,
                     int             num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  PP_String* c_array = new PP_String[num_val];
  int status = queryarr(name,ppString,c_array,start_ix,num_val,-1);
  if (status != 0)
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i].c_str();
        }
    }
  delete[] c_array;
  return status;
}

inline
int
ParmParse::queryarr (const char*     name,
                     Vector<std::string>& ptr,
                     int             start_ix,
                     int             num_val)
{
  if (ptr.size() < num_val)
    ptr.resize(num_val);
  PP_String* c_array = new PP_String[num_val];
  int status = queryarr(name,ppString,c_array,start_ix,num_val,-1);
  if (status != 0)
    {
      for (int i = 0; i < num_val; ++i)
        {
          ptr[i] = c_array[i].c_str();
        }
    }
  delete[] c_array;
  return status;
}

inline
bool
ParmParse::isInteger (const PP_String& str,
                      int&           val)
{
  //
  // Start token scan.
  //
  char* endp = 0;
  val = (int) strtol(str.c_str(), &endp, 10);
  return *endp == 0;
}

inline
int
ParmParse::isDouble (const PP_String& str,
                     double&        val)
{
  char* endp = 0;
  val = std::strtod(str.c_str(), &endp);
  return *endp == 0;
}

inline
int
ParmParse::countname (const std::string& name)
{
  return countname(name.c_str());
}

#endif /*CH_PARMPARSE_H*/

---