/*
** BOS interface header file for C++
** Version 1.1    10.7.96
** Author: B. List
**
** This header file defines inline functions for all BOS 
** subroutines and functions that do not use input units
**
** The subroutines and functions generally take the same sort of
** arguments as their FORTRAN counterparts.
** For FORTRAN functions, they return the same value as the FORTRAN
** routine, e.g.
	ind = nlink ("DTRA", 0);
** For FORTRAN subroutines that change input variables, the value of the
** first changable variable is returned, e.g.
	ind = bktow (bcs.iw, "VETE", 0, bcs.iw, id);
** For character valued functions (chaint and nlist), a pointer to
** char [4] is returned. Two versions exist, one, where an array can be
** supplied, and one, where the array is created by new, e.g.:
	char *c=0;
	c = chaint (bcs.iw [ind1-4]);    // *c is created; c = chaint 
	c = chaint (c, bcs.iw [ind2-4]); // the value of *c is replaced
** This would do the same:
	char *c=0;
	c = chaint (c, bcs.iw [ind1-4]);
	c = chaint (bcs.iw [ind2-4]);
** 
** These character arrays are not 0-terminated!
** Neither need bank name strings be 0-terminated,
** nor the OPT parameter for blist.
** To get a 0-terminated string, use strint instead:
	char *c=0;
	cout << "Bankname: " << (c = strint (bcs.iw [ind1-4])) << '\n';
** strlist is the corresponding function for nlist.
**    
** Other parameters (as the list parameter for blist) must
** be 0-terminated.
** Therefore
	char name[4] = {'D', 'T', 'R', 'A'};   // not 0-terminated
	int ind = nlink (name, 0);             // legal
	char opt [2] = {'E', '+'};             // not 0-terminated
	blist (bcs.iw, opt, "DTNV");           // legal
	blist (bcs.iw, opt, name);             // illegal!
**
** The header file defines also a template class bcstype<n>, which can be used
** to define the BCS common, which must exist:
	bcstype<nbosiw> bcs_;
** This is done in bos.C, using the constant nbosiw defined in nbosiw.h.
**
** n ist the size of the boscommon and can be accessed via bcs_.nbosiw.
** The underscore is important, so that bcs_ can be identified with
** the /BCS/ common in FORTRAN. It is convenient to additionally
** define 
	bcstype<nbosiw>& bcs=bcs_;
** Then bcs.iw and bcs.rw correspond to the usual IW and RW arrays,
** with the notable exception that indices start with 0! Therefore:
	int idtra = nlink ("DTRA", 0);          // Get DTRA index
	char dtraname [4];
	chaint (dtraname, bcs.iw [idtra-4]);    // not bcs.iw [idtra-3]!
	int dtralength =  bcs.iw [idtra-1];     // not iw [idtra]!
	int dtracolums =  bcs.iw [idtra+0];     // not iw [idtra+1]!
	int dtrarows   =  bcs.iw [idtra+1];     // not iw [idtra+2]!
** Two BOS arrays may be defined e.g. as
	const int nbosiw = 1000000;
	bosmdltype bosmdl_;
	bosmdltype& bosmdl = bosmdl_;
	bcstype<nbosiw> bcs_;
	bcstype<nbosiw>& bcs = bcs_;
#ifdef LWSEP
	const int nboslw = 250000;
	bcstype<nboslw> cnstbf_;
	bcstype<nboslw>& cnstbf = cnstbf_;
#else 
  	bcstype<nbosiw>& cnstbf = bcs_;
#endif
	int   *iw = bcs.iw;
	float *rw = bcs.rw;
	int   *lw = cnstbf.iw;
	float *sw = cnstbf.rw;
**
** Generally, where the bos array must be given as argument,
** bcs, bcs.iw, and bcs.rw are all OK, because there exists an implicit
** conversion from bcstype<n> * to int *.
**
** Additionally, the notation
	ind = bcs.mlink ("DTRA", 0);
** can be used.
**
** Subroutines that have alternate return addresses, as bktow,
** are implemented as functions that return a true (not 0) value
** if all is OK, and 0, if the alternate return would have been taken 
** in FORTRAN:
	if (ind = bktow (bcs, "JDTH", 0, bcs, &id) {
	  // all OK, ind == id
	} else {
	  // error, e.g. cannot find JDTH bank, ind == 0, id is unchanged.
	};
** This applies to bktow, bkfrw, wbank.
**
** The BOSMDL common can be defined by using bosmdltype:
	bosmdltype  bosmdl_;
	bosmdltype& bosmdl = bosmdl_;
** In the main routine:	
	if (bosmdl.revent) 
	  cout << "REVENT, run " << bosmdl.nccrun << ", event " 
	       << bosmdl.nevent << '\n';
**
** Portability:
** This code has been tested on the indy workgroup servers.
** It is assumed that float and int are 32 bit in C++ and FORTYRAN,
** and that both languages use the same string representations.
** Therefore no guarantee is given that the code runs on other machines!
**
** Please send comments, suggestions, and bug reports to
** Benno List, blist@mail.desy.de .
**
*/
#ifndef NEWBOS_HEADER_H
#define NEWBOS_HEADER_H
#include <string.h>
#include <iostream.h>
#include "nbosiw.h"
extern "C" {
  void bnames_ (int *);
  void bos_    (int [], int *);
  void bosta_  ();
  void bosbl_  ();
  void bosfm_  ();
  void bosio_  ();
  void breadc_ ();
  int  nbank_  (char [4], int *, int *, int);
  int  mbank_  (int [], char [4], int *, int *, int);
  int  nlink_  (char [4], int *, int);
  int  mlink_  (int [], char [4], int *, int);
  int  ndrop_  (char [4], int *, int);
  int  mdrop_  (int [], char [4], int *, int);
  int  nprint_ (char [4], int *, int);
  int  mprint_ (int [], char [4], int *, int);
  int  namind_ (char [4], int);
  void bkfmt_  (char [4], char *, int, int);
  void blist_  (int [], char [2], char *, int, int);
  void chaint_ (char [4], int, int *);
  int  intcha_ (char *, int);
  int  bktow_  (int [], char [4], int *, int [], int *, int);
  int  bkfrw_  (int [], char [4], int *, int [], int *, int);
  int  wbank_  (int [], int *, int *);
  void wdrop_  (int [], int *);
  void wprnt_  (int [], int *);
  void wgarb_  (int []);
  void bgarb_  (int []);
  void bosbk_  (int []);
  void bosdp_  (int []);
  void mreadc_ (int []);
  void bdrop_  (int [], char *, int);
  void bprnt_  (int [], char *, int);
  void nlist_  (char [4], int, int [], int *, char *, int);
  int  bcallc_ (int [], char [4], int *, int);
  int  bwind_  (int [], char [4], int *, int *, int);
  int  nswap_  (char [4], int *, char [4], int *, int, int);
  int  mswap_  (int [], char [4], int *, char [4], int *, int, int);
  int  bswap_  (int [], char [4], char [4], int, int);
  int  wswap_  (int [], int *, int *);
}


template<int nbosiw> 
class bcstype {
public:
	union {
	  int   iw [nbosiw];
	  float rw [nbosiw];
	};
	const int nhrow = 2, nhcol = 1, nhlen = 2;

	operator int *() {return iw;};
		
        inline bcstype (int bnames=400) {
          bnames_ (&bnames);
          int n = nbosiw;
          bos_ (iw, &n);
	  cout << "BOS array has been initialized with size " << nbosiw <<
	  " and space for " << bnames << " names\n" ;

        };
        inline ~bcstype () {
	cout << "BOS array has gone out of scope\n" ;

        };

	inline int  mbank (char name[4], int nr, int nd) 
		{return mbank_ (iw, name, &nr, &nd, 4);};
	inline int  mlink (char name[4], int nr) 
		{return mlink_ (iw, name, &nr, 4);};
	inline int  mdrop (char name[4], int nr) 
		{return mdrop_ (iw, name, &nr, 4);};
	inline int  mprint (char name[4], int nr) 
		{return mprint_ (iw, name, &nr, 4);};
	inline void blist (char opt[2], char *list) 
		{blist_ (iw, opt, list, 2, strlen (list));};
	inline int  bktow  (char name[4], int nr, int iw2[], int &id)
	{
		int i = bktow_ (iw, name, &nr, iw2, &id, 4);
		return i ? 0 : id; 
	};
	inline int  bktow  (char name[4], int nr, int &id)
	{
		int i = bktow_ (iw, name, &nr, iw, &id, 4);
		return i ? 0 : id; 
	};
	inline int  bkfrw  (char name[4], int nr, int iw2[], int id)
	{
		int i = bkfrw_ (iw, name, &nr, iw2, &id, 4);
		return i ? 0 : mlink_ (iw, name, &nr, 4); 
	};
	inline int  bkfrw  (char name[4], int nr, int id)
	{
		int i = bkfrw_ (iw, name, &nr, iw, &id, 4);
		return i ? 0 : mlink_ (iw, name, &nr, 4); 
	};
	inline int  wbank  (int &id, int nd)
	{
		int i = wbank_ (iw, &id, &nd);
		return i ? 0 : id;
	};
	inline void wdrop (int& id)    {wdrop_ (iw, &id);}
	inline void wprnt (int id)     {wprnt_ (iw, &id);}
	inline void wgarb ()           {wgarb_ (iw);};
	inline void bgarb ()           {bgarb_ (iw);};
	inline void bosbk ()           {bosbk_ (iw);};
	inline void bosdp ()           {bosdp_ (iw);};
	inline void mreadc ()          {mreadc_ (iw);};
	inline void bdrop (char *list) {bdrop_ (iw, list, strlen (list));};
	inline void bprnt (char *list) {bprnt_ (iw, list, strlen (list));};
	inline char *nlist (char name[4], int m, char *list)
	{
		if (!name) name = new char [4];
		nlist_ (name, 4, iw, &m, list, strlen (list));
		return name;
	};
	inline char *nlist (int m, char *list)
	{
		char *name = new char[4];
		nlist_ (name, 4, iw, &m, list, strlen (list));
		return name;
	};
	inline int  bcallc (char name[4], int nr) 
		{return bcallc_ (iw, name, &nr, 4);};
	inline int  bwind (char name[4], int nrmax, int &id) 
	{
		bwind_ (iw, name, &nrmax, &id, 4);
		return id;
	};
	inline int mswap (char nam1[4], int nr1, char nam2[4], int nr2)
		{return mswap_ (iw, nam1, &nr1, nam2, &nr2, 4, 4);};
	inline int bswap (char nam1[4], char nam2[4])
		{return bswap_ (iw, nam1, nam2, 4, 4);};
	inline int wswap (int &id1, int &id2)
	{
		wswap_ (iw, &id1, &id2);
		return id1;
	};
};

struct bosmdltype {
	int  begjob, endrun, begrun, revent, endjob, othdat,
             lccrun, nccrun, nevent,
             iha, ibs, idb, iddatel, lup, isn, jsn; 
	};

extern bosmdltype bosmdl_;
extern bosmdltype& bosmdl; 

/*	inline void bos (int jw[]=iw, int size=nbosiw) {bos_ (jw, &size);};
	inline int  mbank (int jw[], char name[4], int nr, int nd) 
		{return mbank_ (jw, name, &nr, &nd, 4);};
	inline int  mlink (cint jw[], har name[4], int nr) 
		{return mlink_ (jw, name, &nr, 4);};
	inline int  mdrop (int jw[], char name[4], int nr) 
		{return mdrop_ (jw, name, &nr, 4);};
	inline int  mprint (int jw[], char name[4], int nr) 
		{return mprint_ (jw, name, &nr, 4);};
	inline int  nbank (char name[4], int nr, int nd) 
		{return nbank_ (name, &nr, &nd, 4);};
	inline int  nlink (char name[4], int nr) 
		{return nlink_ (name, &nr, 4);};
	inline int  ndrop (char name[4], int nr) 
		{return ndrop_ (name, &nr, 4);};
	inline int  nprint (char name[4], int nr) 
		{return nprint_ (iw, name, &nr, 4);};
	inline void blist (char opt[2], char *list) 
		{blist_ (iw, opt, list, 2, strlen (list));};
	inline int  bktow  (char name[4], int nr, int iw2[], int &id)
	{
		int i = bktow_ (iw, name, &nr, iw2, &id, 4);
		return i ? 0 : id; 
	};
	inline int  bktow  (char name[4], int nr, int &id)
	{
		int i = bktow_ (iw, name, &nr, iw, &id, 4);
		return i ? 0 : id; 
	};
	inline int  bkfrw  (char name[4], int nr, int iw2[], int id)
	{
		int i = bkfrw_ (iw, name, &nr, iw2, &id, 4);
		return i ? 0 : mlink_ (iw, name, nr, 4); 
	};
	inline int  bkfrw  (char name[4], int nr, int id)
	{
		int i = bkfrw_ (iw, name, &nr, iw, &id, 4);
		return i ? 0 : mlink_ (iw, name, nr); 
	};
	inline int  wbank  (int &id, int nd)
	{
		int i = wbank_ (iw, &id, &nd);
		return i ? 0 : id;
	};
	inline void wdrop (int& id)    {wdrop_ (iw, &id);}
	inline void wprnt (int id)     {wprnt_ (iw, &id);}
	inline void wgarb ()           {wgarb_ (iw);};
	inline void bgarb ()           {bgarb_ (iw);};
	inline void bosbk ()           {bosbk_ (iw);};
	inline void bosdp ()           {bosdp_ (iw);};
	inline void mreadc ()          {mreadc_ (iw);};
	inline void bdrop (char *list) {bdrop_ (iw, list, strlen (list));};
	inline void bprnt (char *list) {bprnt_ (iw, list, strlen (list));};
	inline char *nlist (char name[4], int m, char *list)
	{
		if (!name) name = new char [4];
		nlist_ (name, 4, iw, &m, list, strlen (list));
		return name;
	};
	inline char *nlist (int m, char *list)
	{
		char *name = new char[4];
		nlist_ (name, 4, iw, &m, list, strlen (list));
		return name;
	};
	inline int  bcallc (char name[4], int nr) 
		{return bcallc_ (iw, name, &nr, 4);};
	inline int  bwind (char name[4], int nrmax, int &id) 
	{
		bwind_ (iw, name, &nrmax, &id, 4);
		return id;
	};
	inline int mswap (char nam1[4], int nr1, char nam2[4], int nr2)
		{return mswap_ (iw, nam1, &nr1, nam2, &nr2, 4, 4);};
	inline int bswap (char nam1[4], char nam2[4])
		{return bswap_ (iw, nam1, nam2, 4, 4);};
	inline int wswap (int &id1, int &id2)
	{
		wswap_ (iw, &id1, &id2);
		return id1;
	};
};
*/

inline void bnames (int n)         {bnames_ (&n);};

inline void bos (int iw[], int n)  {bos_ (iw, &n);};
inline void bos (float rw[], int n){bos_ ((int *)rw, &n);};

inline void bosta ()               {bosta_ ();};
inline void bosbl ()               {bosbl_ ();};
inline void bosfm ()               {bosfm_ ();};
inline void bosio ()               {bosio_ ();};

inline void breadc ()              {breadc_ ();};

inline int  nbank (char name[4], int nr, int nd) 
	{return nbank_ (name, &nr, &nd, 4);};
inline int  mbank (int iw[], char name[4], int nr, int nd) 
	{return mbank_ (iw, name, &nr, &nd, 4);};
inline int  mbank (float rw[], char name[4], int nr, int nd) 
	{return mbank_ ((int *)rw, name, &nr, &nd, 4);};
	
inline int  nlink (char name[4], int nr) 
	{return nlink_ (name, &nr, 4);};
inline int  mlink (int iw[], char name[4], int nr) 
	{return mlink_ (iw, name, &nr, 4);};
inline int  mlink (float rw[], char name[4], int nr) 
	{return mlink_ ((int *)rw, name, &nr, 4);};
	
inline int  ndrop (char name[4], int nr) 
	{return ndrop_ (name, &nr, 4);};
inline int  mdrop (int iw[], char name[4], int nr) 
	{return mdrop_ (iw, name, &nr, 4);};
inline int  mdrop (float rw[], char name[4], int nr) 
	{return mdrop_ ((int *)rw, name, &nr, 4);};
	
inline int  nprint (char name[4], int nr) 
	{return nprint_ (name, &nr, 4);};
inline int  mprint (int iw[], char name[4], int nr) 
	{return mprint_ (iw, name, &nr, 4);};
inline int  mprint (float rw[], char name[4], int nr) 
	{return mprint_ ((int *)rw, name, &nr, 4);};
	
inline int  namind (char name[4]) {return namind_ (name, 4);};

inline void bkfmt (char name[4], char *fmt) 
	{bkfmt_ (name, fmt, 4, strlen (fmt));};
	
inline void blist (int iw[], char opt[2], char *list) 
	{blist_ (iw, opt, list, 2, strlen (list));};
inline void blist (float rw[], char opt[2], char *list) 
	{blist_ ((int *)rw, opt, list, 2, strlen (list));};
	
inline char *chaint (char c[4], int i) 
{
	if (!c) c = new char [4];
	chaint_ (c, 4, &i);
	return c;
};
inline char *chaint (int i) 
{
	char *c = new char [4];
	chaint_ (c, 4, &i);
	return c;
};
inline char *strint (char c[5], int i) 
{
	if (!c) c = new char [5];
	chaint_ (c, 4, &i);
	c [4] = '\0';
	return c;
};
inline char *strint (int i) 
{
	char *c = new char [5];
	chaint_ (c, 4, &i);
	c [4] = '\0';
	return c;
};

inline int  intcha (char *c)  {return intcha_ (c, 4);};

inline int  bktow  (int iw1[], char name[4], int nr, int iw2[], int &id)
{
	int i = bktow_ (iw1, name, &nr, iw2, &id, 4);
	return i ? 0 : id; 
};
inline int  bktow  (float rw1[], char name[4], int nr, float rw2[], int &id)
{
	int i = bktow_ ((int *)rw1, name, &nr, (int *)rw2, &id, 4);
	return i ? 0 : id; 
};

inline int  bkfrw  (int iw1[], char name[4], int nr, int iw2[], int id)
{
	int i = bkfrw_ (iw1, name, &nr, iw2, &id, 4);
	return i ? 0 : mlink_ (iw1, name, &nr, 4); 
};
inline int  bkfrw  (float rw1[], char name[4], int nr, float rw2[], int id)
{
	int i = bkfrw_ ((int *)rw1, name, &nr, (int *)rw2, &id, 4);
	return i ? 0 : mlink_ ((int *)rw1, name, &nr, 4); 
};

inline int  wbank  (int iw[], int &id, int nd)
{
	int i = wbank_ (iw, &id, &nd);
	return i ? 0 : id;
};
inline int  wbank  (float rw[], int &id, int nd)
{
	int i = wbank_ ((int *)rw, &id, &nd);
	return i ? 0 : id;
};

inline void wdrop (int iw[],   int& id) {wdrop_ (iw,        &id);};
inline void wdrop (float rw[], int& id) {wdrop_ ((int *)rw, &id);};

inline void wprnt (int iw[],   int id) {wprnt_ (iw,        &id);};
inline void wprnt (float rw[], int id) {wprnt_ ((int *)rw, &id);};

inline void wgarb (int iw[])  {wgarb_ (iw);};
inline void wgarb (float rw[]){wgarb_ ((int *)rw);};


inline void bgarb (int iw[])  {bgarb_ (iw);};
inline void bgarb (float rw[]){bgarb_ ((int *)rw);};

inline void bosbk (int iw[])  {bosbk_ (iw);};
inline void bosbk (float rw[]){bosbk_ ((int *)rw);};

inline void bosdp (int iw[])  {bosdp_ (iw);};
inline void bosdp (float rw[]){bosdp_ ((int *)rw);};

inline void mreadc (int iw[])  {mreadc_ (iw);};
inline void mreadc (float rw[]){mreadc_ ((int *)rw);};

inline void bdrop (int iw[],   char *list) {bdrop_ (iw,        list, strlen (list));};
inline void bdrop (float rw[], char *list) {bdrop_ ((int *)rw, list, strlen (list));};

inline void bprnt (int iw[],   char *list) {bprnt_ (iw,        list, strlen (list));};
inline void bprnt (float rw[], char *list) {bprnt_ ((int *)rw, list, strlen (list));};

inline char *nlist (char name[4], int iw[],   int n, char *list)
{
	if (!name) name = new char [4];
	nlist_ (name, 4, iw,        &n, list, strlen (list));
	return name;
};
inline char *nlist (char name[4], float rw[], int n, char *list)
{
	if (!name) name = new char [4];
	nlist_ (name, 4, (int *)rw, &n, list, strlen (list));
	return name;
};
inline char *nlist (int iw[],   int n, char *list)
{
	char *name = new char[4];
	nlist_ (name, 4, iw,        &n, list, strlen (list));
	return name;
};
inline char *nlist (float rw[], int n, char *list)
{
	char *name = new char[4];
	nlist_ (name, 4, (int *)rw, &n, list, strlen (list));
	return name;
};

inline char *strlist (char name[5], int iw[],   int n, char *list)
{
	if (!name) name = new char [5];
	nlist_ (name, 4, iw,        &n, list, strlen (list));
	name [5] = '\0';
	return name;
};
inline char *strlist (char name[5], float rw[], int n, char *list)
{
	if (!name) name = new char [5];
	nlist_ (name, 4, (int *)rw, &n, list, strlen (list));
	name [5] = '\0';
	return name;
};
inline char *strlist (int iw[],   int n, char *list)
{
	char *name = new char[5];
	nlist_ (name, 4, iw,        &n, list, strlen (list));
	name [5] = '\0';
	return name;
};
inline char *strlist (float rw[], int n, char *list)
{
	char *name = new char[5];
	nlist_ (name, 4, (int *)rw, &n, list, strlen (list));
	name [5] = '\0';
	return name;
};
	
inline int  bcallc (int iw[], char name[4], int nr) 
	{return bcallc_ (iw, name, &nr, 4);};
inline int  bcallc (float rw[], char name[4], int nr) 
	{return bcallc_ ((int *)rw, name, &nr, 4);};
	
inline int  bwind (int iw[], char name[4], int nrmax, int &id) 
{
	bwind_ (iw, name, &nrmax, &id, 4);
	return id;
};
inline int  bwind (float rw[], char name[4], int nrmax, int &id) 
{
	bwind_ ((int *)rw, name, &nrmax, &id, 4);
	return id;
};

inline int nswap (char nam1[4], int nr1, char nam2[4], int nr2)
	{return nswap_ (nam1, &nr1, nam2, &nr2, 4, 4);};
	
inline int mswap (int iw[],   char nam1[4], int nr1, char nam2[4], int nr2)
	{return mswap_ (iw,        nam1, &nr1, nam2, &nr2, 4, 4);};
inline int mswap (float rw[], char nam1[4], int nr1, char nam2[4], int nr2)
	{return mswap_ ((int *)rw, nam1, &nr1, nam2, &nr2, 4, 4);};
	
inline int bswap (int iw[],   char nam1[4], char nam2[4])
	{return bswap_ (iw,        nam1, nam2, 4, 4);};
inline int bswap (float rw[], char nam1[4], char nam2[4])
	{return bswap_ ((int *)rw, nam1, nam2, 4, 4);};

inline int  wswap  (int iw[], int &id1, int &id2)
{
	wswap_ (iw, &id1, &id2);
	return id1;
};
inline int  wswap  (float rw[], int &id1, int &id2)
{
	wswap_ ((int *)rw, &id1, &id2);
	return id1;
};
#endif