// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_hbook_CHBOOK
#define tools_hbook_CHBOOK

// A C interface to HBOOK.

// It is done in way that limits the number of #define.
// Only two remains for WIN32.

#ifdef WIN32
#include <cstring>
#endif

namespace tools {
namespace hbook {

#ifdef TOOLS_HBOOK_F2C_RET_DOUBLE
typedef double rret;
#else
typedef float rret;
#endif

#ifdef TOOLS_HBOOK_F2C_ARG_DOUBLE
typedef double rarg;
#else
typedef float rarg;
#endif

/////////////////////////////////////////////////////////////////
/// functions with only a different name WIN32 versus UNIX //////
/////////////////////////////////////////////////////////////////
#ifdef WIN32
extern "C" void __stdcall ZITOH(int*,int*,int*);
extern "C" void __stdcall RZINK(int*,int*,const char *,int);
extern "C" void __stdcall HLIMIT(int*);
extern "C" void __stdcall HFILL(int*,rarg*,rarg*,rarg*);
extern "C" void __stdcall HRIN(int*,int*,int*);
extern "C" void __stdcall HNOENT(int*,int*);
extern "C" void __stdcall HFNT(int*);
extern "C" void __stdcall HGNPAR(int*,const char *,int);
extern "C" void __stdcall HGNT(int*,int*,int*);
extern "C" void __stdcall HDCOFL();
extern "C" void __stdcall HDELET(int*);
extern "C" void __stdcall HIJXY(int*,int*,int*,rarg*,rarg*);
extern "C" rret __stdcall HIJE(int*,int*,int*);
extern "C" rret __stdcall HIJ(int*,int*,int*);
extern "C" rret __stdcall HIE(int*,int*);
extern "C" void __stdcall HIX(int*,int*,rarg*);
extern "C" void __stdcall HXI(int*,rarg*,int*);
extern "C" rret __stdcall HI(int*,int*);
extern "C" void __stdcall HXYIJ(int*,rarg*,rarg*,int*,int*);
extern "C" rret __stdcall HMIN(int*);
extern "C" rret __stdcall HMAX(int*);
extern "C" int __stdcall HISID(int*);
//extern "C" void __stdcall HGNF(int*,int*,rarg*,int*);
//extern "C" void __stdcall HIDALL(int*,int*);
//extern "C" void __stdcall HID1(int*,int*);
//extern "C" void __stdcall HID2(int*,int*);
//extern "C" int __stdcall HEXIST(int*);
#else
extern "C" void zitoh_(int*,int*,int*);
extern "C" void rzink_(int*,int*,const char *,int);
extern "C" void hlimit_(int*);
extern "C" void hfill_(int*,rarg*,rarg*,rarg*);
extern "C" void hrin_(int*,int*,int*);
extern "C" void hnoent_(int*,int*);
extern "C" void hfnt_(int*);
extern "C" void hgnpar_(int*,const char *,int);
extern "C" void hgnt_(int*,int*,int*);
extern "C" void hdcofl_();
extern "C" void hdelet_(int*);
extern "C" void hijxy_(int*,int*,int*,rarg*,rarg*);
extern "C" rret hije_(int*,int*,int*);
extern "C" rret hij_(int*,int*,int*);
extern "C" rret hie_(int*,int*);
extern "C" void hix_(int*,int*,rarg*);
extern "C" void hxi_(int*,rarg*,int*);
extern "C" rret hi_(int*,int*);
extern "C" void hxyij_(int*,rarg*,rarg*,int*,int*);
extern "C" rret hmin_(int*);
extern "C" rret hmax_(int*);
extern "C" int hisid_(int*);
//extern "C" void hgnf_(int*,int*,rarg*,int*);
//extern "C" void hidall_(int*,int*);
//extern "C" void hid1_(int*,int*);
//extern "C" void hid2_(int*,int*);
//extern "C" int hexist_(int*);
#endif

/////////////////////////////////////////////////////////////////
/// functions with a different signature WIN32 versus UNIX //////
/////////////////////////////////////////////////////////////////
#ifdef WIN32
#define DEFCHAR  const char*,const int

extern "C" void __stdcall UHTOC(int*,int*,const char*,const int,int*);
extern "C" void __stdcall HROPEN(int*,DEFCHAR,DEFCHAR,DEFCHAR,int*,int*);
extern "C" void __stdcall HREND(DEFCHAR);
extern "C" void __stdcall HROUT(int*,int*,DEFCHAR);
extern "C" void __stdcall HGIVE(int*,DEFCHAR,int*,rarg*,rarg*,int*,rarg*,rarg*,int*,int*);
extern "C" void __stdcall HGIVEN(int*,DEFCHAR,int*,DEFCHAR,rarg*,rarg*);
extern "C" void __stdcall HNTVAR2(int*,int*,DEFCHAR,DEFCHAR,DEFCHAR,int*,int*,int*,int*);
extern "C" void __stdcall HBNT(int*,DEFCHAR,DEFCHAR);
extern "C" void __stdcall HBNAME(int*,DEFCHAR,int*,DEFCHAR);
extern "C" void __stdcall HBNAM(int*,DEFCHAR,int*,DEFCHAR,int*);
extern "C" void __stdcall HBOOK1(int*,DEFCHAR,int*,rarg*,rarg*,rarg*);
extern "C" void __stdcall HBOOK2(int*,DEFCHAR,int*,rarg*,rarg*,int*,rarg*,rarg*,rarg*);
extern "C" void __stdcall HBOOKB(int*,DEFCHAR,int*,rarg*,rarg*);
extern "C" void __stdcall HBPROF(int*,DEFCHAR,int*,rarg*,rarg*,rarg*,rarg*,DEFCHAR);
extern "C" void __stdcall HCDIR(DEFCHAR,DEFCHAR);
extern "C" void __stdcall HLDIR(DEFCHAR,DEFCHAR);
extern "C" void __stdcall HMDIR(DEFCHAR,DEFCHAR);
extern "C" void __stdcall HDDIR(DEFCHAR);
extern "C" rret __stdcall HSTATI(int*,int*,DEFCHAR,int*);
extern "C" void __stdcall HRESET(int*,DEFCHAR);
extern "C" void __stdcall HOPERA(int*,DEFCHAR,int*,int*,rarg*,rarg*);
extern "C" void __stdcall HKIND(int*,int*,DEFCHAR);

#undef DEFCHAR

#define PASSCHAR(a_string) a_string,::strlen(a_string)
#else
typedef const char* DEFCHAR;

extern "C" void uhtoc_(int*,int*,const char*,int*,int);
extern "C" void hropen_(int*,DEFCHAR,DEFCHAR,DEFCHAR,int*,int*,int,int,int);
extern "C" void hrend_(DEFCHAR,int);
extern "C" void hrout_(int*,int*,DEFCHAR,int);
extern "C" void hgive_(int*,DEFCHAR,int*,rarg*,rarg*,int*,rarg*,rarg*,int*,int*,int);
extern "C" void hgiven_(int*,DEFCHAR,int*,DEFCHAR,rarg*,rarg*,int,int);
extern "C" void hntvar2_(int*,int*,DEFCHAR,DEFCHAR,DEFCHAR,int*,int*,int*,int*,int,int,int);
extern "C" void hbnt_(int*,DEFCHAR,DEFCHAR,int,int);
extern "C" void hbname_(int*,DEFCHAR,int*,DEFCHAR,int,int);
extern "C" void hbnam_(int*,DEFCHAR,int*,DEFCHAR,int*,int,int);
extern "C" void hbook1_(int*,DEFCHAR,int*,rarg*,rarg*,rarg*,int);
extern "C" void hbook2_(int*,DEFCHAR,int*,rarg*,rarg*,int*,rarg*,rarg*,rarg*,int);
extern "C" void hbookb_(int*,DEFCHAR,int*,rarg*,rarg*,int);
extern "C" void hbprof_(int*,DEFCHAR,int*,rarg*,rarg*,rarg*,rarg*,DEFCHAR,int,int);
extern "C" void hcdir_(DEFCHAR,DEFCHAR ,int,int);
extern "C" void hldir_(DEFCHAR,DEFCHAR ,int,int);
extern "C" void hmdir_(DEFCHAR,DEFCHAR ,int,int);
extern "C" void hddir_(DEFCHAR,int);
extern "C" rret hstati_(int*,int*,DEFCHAR,int*,int);
extern "C" void hreset_(int*,DEFCHAR,int);
extern "C" void hopera_(int*,DEFCHAR,int*,int*,rarg*,rarg*,int);
extern "C" void hkind_(int*,int*,DEFCHAR,int);
#endif

#ifdef WIN32
extern "C" int PAWC[1];
extern "C" int QUEST[100];
extern "C" int HCBOOK[51];
extern "C" int RZCL[11];
//extern "C" int HCBITS[37];
#else
extern "C" int pawc_[1];
extern "C" int quest_[100];
extern "C" int hcbook_[51];
extern "C" int rzcl_[11];
//extern "C" int hcbits_[37];
#endif

}}

//////////////////////////////////////////////////////////////////////////////
/// our wrapping /////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#include <string>
#include <vector>
#include <cstring> //memset

namespace tools {
namespace hbook {

//////////////////////////////////////////////////////////////////////////////
/// package //////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
inline void CHLIMIT(int a_num) {
#ifdef WIN32
  HLIMIT(&a_num);
#else
  hlimit_(&a_num);
#endif
}

inline void CHDELET(int a_id){
#ifdef WIN32
  HDELET(&a_id);
#else
  hdelet_(&a_id);
#endif
}

inline void CHDCOFL() {
#ifdef WIN32
  HDCOFL();
#else
  hdcofl_();
#endif
}

inline void CRZINK(int a_key,int a_cycle,const std::string& a_opts) {
#ifdef WIN32
  RZINK(&a_key,&a_cycle,PASSCHAR(a_opts.c_str()));
#else
  rzink_(&a_key,&a_cycle,a_opts.c_str(),a_opts.size());
#endif
}

inline void CZITOH(int* a1,int* a2,int* a3) {
#ifdef WIN32
  ZITOH(a1,a2,a3);
#else
  zitoh_(a1,a2,a3);
#endif
}

/*
inline std::vector<int> CHIDALL() {
  // We should use first a function getting the number of ids only.
  // See hids.f in this directory and hidall.F code.
  int ids[100000];
  int n;
#ifdef WIN32
  HIDALL(ids,&n);
#else
  hidall_(ids,&n);
#endif
  std::vector<int> r;
  r.resize(n,0);
  for(int i=0;i<n;i++) r[i] = ids[i];
  return r;
}
inline std::vector<int> CHID1() {
  // We should use first a function getting the number of 1D ids only.
  // See hids.f in this directory and hid1.F code.
  int ids[100000];
  int n;
#ifdef WIN32
  HID1(ids,&n);
#else
  hid1_(ids,&n);
#endif
  std::vector<int> r;
  r.resize(n,0);
  for(int i=0;i<n;i++) r[i] = ids[i];
  return r;
}
inline std::vector<int> CHID2() {
  // We should use first a function getting the number of 2D ids only.
  // See hids.f in this directory and hid1.F code.
  int ids[100000];
  int n;
#ifdef WIN32
  HID2(ids,&n);
#else
  hid2_(ids,&n);
#endif
  std::vector<int> r;
  r.resize(n,0);
  for(int i=0;i<n;i++) r[i] = ids[i];
  return r;
}
inline bool CHEXIST(int a_id) {
  int id = a_id;
  // What is the mapping of F77 LOGICAL to C ?
#ifdef WIN32
  logical l = HEXIST(&id);
#else
  logical l = hexist_(&id);
#endif
}

inline void CHCLR() {
  // Clear //PAWC structure.
  //CHCDIR("//PAWC"," ");
  std::vector<std::string> drs;
  CHDIRS(true,drs);
 {std::vector<std::string>::iterator it;
  for(it=drs.begin();it!=drs.end();++it){
    std::string& dir = *it;
    CHDDIR(dir);
  }}
  CHDELET(0);
}
*/

inline int* get_pawc() {
#ifdef WIN32
  return PAWC;
#else
  return pawc_;
#endif
}
inline int* get_quest() { 
#ifdef WIN32
  return QUEST;
#else
  return quest_;
#endif
}
//inline int* get_hcbits() {
//#ifdef WIN32
//  return HCBITS;
//#else
//  return hcbits_;
//#endif
//}
inline int* get_hcbook() {
#ifdef WIN32
  return HCBOOK;
#else
  return hcbook_;
#endif
}
inline int* get_rzcl() {
#ifdef WIN32
  return RZCL;
#else
  return rzcl_;
#endif
}

//////////////////////////////////////////////////////////////////////////////
/// file /////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
inline int CHROPEN(int a1,const std::string& a2,const std::string& a3,const std::string& a4,int a5) {
  int ier = 0;
#ifdef WIN32
  HROPEN(&a1,PASSCHAR(a2.c_str()),PASSCHAR(a3.c_str()),PASSCHAR(a4.c_str()),&a5,&ier);
#else
  hropen_(&a1,a2.c_str(),a3.c_str(),a4.c_str(),&a5,&ier,a2.size(),a3.size(),a4.size());
#endif
  return ier;
}


inline void CHRIN(int a_id,int a_cycle,int a_offset){
#ifdef WIN32
  HRIN(&a_id,&a_cycle,&a_offset);
#else
  hrin_(&a_id,&a_cycle,&a_offset);
#endif
}

inline void CHROUT(int a1,int a2,const std::string& a3) {
#ifdef WIN32
  HROUT(&a1,&a2,PASSCHAR(a3.c_str()));
#else
  hrout_(&a1,&a2,a3.c_str(),a3.size());
#endif
}

inline void CHREND(const std::string& a1) {
#ifdef WIN32
  HREND(PASSCHAR(a1.c_str()));
#else
  hrend_(a1.c_str(),a1.size());
#endif
}

inline void CHCDIR(const std::string& a1,const std::string& a2) {
#ifdef WIN32
  HCDIR(PASSCHAR(a1.c_str()),PASSCHAR(a2.c_str()));
#else
  hcdir_(a1.c_str(),a2.c_str(),a1.size(),a2.size());
#endif
}

inline void CHLDIR(const std::string& a1,const std::string& a2) {
#ifdef WIN32
  HLDIR(PASSCHAR(a1.c_str()),PASSCHAR(a2.c_str()));
#else
  hldir_(a1.c_str(),a2.c_str(),a1.size(),a2.size());
#endif
}

inline void CHPWDF(char* a_pwd) { //must be 1024 allocated.
  int l = 1024;
 {for(int i=0;i<l;i++) a_pwd[i] = 0;}
  static const char a2[] = "R";  
#ifdef WIN32
  HCDIR(a_pwd,l,a2,1);
#else
  hcdir_(a_pwd,a2,l,1);
#endif
  /*int len=0;*/
 {for(int i=l-1;i>0;i--) {
    if(a_pwd[i]==0) continue;
    if(a_pwd[i]!=' ') {/*len=i;*/break;}
    a_pwd[i] = 0;
  }}
}

inline std::string CHPWD() {
  char pwd[1024];
  CHPWDF(pwd);
  return pwd;
}

inline void CHMDIR(const std::string& a1,const std::string& a2) {
#ifdef WIN32
  HMDIR(PASSCHAR(a1.c_str()),PASSCHAR(a2.c_str()));
#else
  hmdir_(a1.c_str(),a2.c_str(),a1.size(),a2.size());
#endif
}

inline void CHDDIR(const std::string& a1) {
#ifdef WIN32
  HDDIR(PASSCHAR(a1.c_str()));
#else
  hddir_(a1.c_str(),a1.size());
#endif
}

inline bool CHISID(int a_id) {
#ifdef WIN32
  return (HISID(&a_id)==1?true:false);
#else
  return (hisid_(&a_id)==1?true:false);
#endif
}

inline void CHDIRS(bool a_PAWC,std::vector<std::string>& a_dirs){
  a_dirs.clear();

  int* pawc = get_pawc();

  if(a_PAWC) {

    int* iq = &(pawc[17]);

    int* lq = &(pawc[9]);
    int lcdir = get_hcbook()[6];
    int lf = lq[lcdir-1];
    while(lf!=0) {

      int ncw = 4;
      //int ihdir[4];
      //CZITOH(iq+lf+1,ihdir,&ncw);
      int* ihdir = iq+lf+1;

      char chdir[17];
     {for(int i=0;i<17;i++) chdir[i] = 0;}
      int nch=16;
#ifdef WIN32
      UHTOC(ihdir,&ncw,chdir,16,&nch);
#else
      uhtoc_(ihdir,&ncw,chdir,&nch,16);
#endif
     {for(int i=17-1;i>0;i--) {
        if(chdir[i]==0) continue;
        if(chdir[i]!=' ') break;
        chdir[i] = 0;
     }}

      a_dirs.push_back(chdir);

      lf = lq[lf];
    }

  } else { //On a UNIT.

    int* iq = &(pawc[17]);

    const int KLS = 26;
    const int KNSD = 23;
    int lcdir = get_rzcl()[2];
    int ls = iq[lcdir+KLS];
    int ndir = iq[lcdir+KNSD];
    for (int k=0;k<ndir;k++) {
      lcdir = get_rzcl()[2];
      int ncw = 4;
      int ihdir[4];
      CZITOH(iq+(lcdir+ls+7*k),ihdir,&ncw);

      char chdir[17];
     {for(int i=0;i<17;i++) chdir[i] = 0;}
      int nch=16;
#ifdef WIN32
      UHTOC(ihdir,&ncw,chdir,16,&nch);
#else
      uhtoc_(ihdir,&ncw,chdir,&nch,16);
#endif
     {for(int i=17-1;i>0;i--) {
        if(chdir[i]==0) continue;
        if(chdir[i]!=' ') break;
        chdir[i] = 0;
      }}

      a_dirs.push_back(chdir);
    }
  }
}

inline std::vector<int> CHKEYS(){
  // Apply on a //LUN<unit> directory.
  std::vector<int> keys;
  int* quest = get_quest();  
  for (int key=1;key<1000000;key++) {
    CRZINK(key,0,"S");
    if(quest[0]) break;
    if(quest[13] & 8) continue;
    int id = quest[20];
    keys.push_back(id);
  }
  return keys;
}

inline bool CHEDIR(const std::string& a_dir,bool a_PAWC){
  std::vector<std::string> drs;
  CHDIRS(a_PAWC,drs);
  std::vector<std::string>::iterator it;
  for(it=drs.begin();it!=drs.end();++it){
    if(a_dir==(*it)) return true;
  }
  return false;
}

//////////////////////////////////////////////////////////////////////////////
/// histogram ////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
inline void CHBOOK1(int a_id,const std::string& a_title,int a_xnum,rarg a_xmin,rarg a_xmax,rarg a_vmx = 0) {
#ifdef WIN32
  HBOOK1(&a_id,PASSCHAR(a_title.c_str()),&a_xnum,&a_xmin,&a_xmax,&a_vmx);
#else
  hbook1_(&a_id,a_title.c_str(),&a_xnum,&a_xmin,&a_xmax,&a_vmx,a_title.size());
#endif
}

inline void CHBOOK2(int a_id,const std::string& a_title,int a_xnum,rarg a_xmin,rarg a_xmax,int a_ynum,rarg a_ymin,rarg a_ymax,rarg a_vmx = 0) {
#ifdef WIN32
  HBOOK2(&a_id,PASSCHAR(a_title.c_str()),
         &a_xnum,&a_xmin,&a_xmax,&a_ynum,&a_ymin,&a_ymax,&a_vmx);
#else
  hbook2_(&a_id,a_title.c_str(),
         &a_xnum,&a_xmin,&a_xmax,&a_ynum,&a_ymin,&a_ymax,&a_vmx,
         a_title.size());
#endif
}

inline bool CHBOOKB(
 int a_id
,const std::string& a_title
,const std::vector<rarg>& a_edges
,rarg a_vmx = 0
) {
  if(!a_edges.size()) return false;

  int edgen = (int)a_edges.size();
  rarg* edges = new rarg[edgen];
  for(int i=0;i<edgen;i++) edges[i] = a_edges[i];

  int ncx = edgen-1;
#ifdef WIN32
  HBOOKB(&a_id,PASSCHAR(a_title.c_str()),&ncx,edges,&a_vmx);
#else
  hbookb_(&a_id,a_title.c_str(),&ncx,edges,&a_vmx,a_title.size());
#endif
  delete [] edges;
  return true;
}

inline void CHBPROF(
 int a_id
,const std::string& a_title
,int a_xnum,rarg a_xmin,rarg a_xmax
,rarg a_ymin,rarg a_ymax
,const std::string& a_opts
) {
#ifdef WIN32
  HBPROF(&a_id,PASSCHAR(a_title.c_str()),
         &a_xnum,&a_xmin,&a_xmax,&a_ymin,&a_ymax,
         PASSCHAR(a_opts.c_str()));
#else
  hbprof_(&a_id,a_title.c_str(),
         &a_xnum,&a_xmin,&a_xmax,&a_ymin,&a_ymax,
         a_opts.c_str(),a_title.size(),a_opts.size());
#endif
}

inline void CHGIVE(
 int a_id
,std::string& a_title
,int& a_xnum
,rarg& a_xmin
,rarg& a_xmax
,int& a_ynum
,rarg& a_ymin
,rarg& a_ymax
){
  char chtitl[128];
  int ncx,ncy;
  rarg xmin,xmax,ymin,ymax;
  int nwt,idb;
#ifdef WIN32
  HGIVE(&a_id,chtitl,80,&ncx,&xmin,&xmax,&ncy,&ymin,&ymax,&nwt,&idb);
#else
  hgive_(&a_id,chtitl,&ncx,&xmin,&xmax,&ncy,&ymin,&ymax,&nwt,&idb,80);
#endif
  chtitl[4*nwt] = 0;
  a_title = chtitl;
  a_xnum = ncx;
  a_xmin = xmin;
  a_xmax = xmax;
  a_ynum = ncy;
  a_ymin = ymin;
  a_ymax = ymax;
}

inline void CHGIVE( //without title.
 int a_id
,int& a_xnum
,rarg& a_xmin
,rarg& a_xmax
,int& a_ynum
,rarg& a_ymin
,rarg& a_ymax
){
  char chtitl[128];
  int ncx,ncy;
  rarg xmin,xmax,ymin,ymax;
  int nwt,idb;
#ifdef WIN32
  HGIVE(&a_id,chtitl,80,&ncx,&xmin,&xmax,&ncy,&ymin,&ymax,&nwt,&idb);
#else
  hgive_(&a_id,chtitl,&ncx,&xmin,&xmax,&ncy,&ymin,&ymax,&nwt,&idb,80);
#endif
  a_xnum = ncx;
  a_xmin = xmin;
  a_xmax = xmax;
  a_ynum = ncy;
  a_ymin = ymin;
  a_ymax = ymax;
}

inline int CHNOENT(int a_id){
  int nentries;
#ifdef WIN32
  HNOENT(&a_id,&nentries);
#else
  hnoent_(&a_id,&nentries);
#endif
  return nentries;
}

inline void CHFILL(int a_id,rarg a_x,rarg a_y,rarg a_w){
#ifdef WIN32
  HFILL(&a_id,&a_x,&a_y,&a_w);
#else
  hfill_(&a_id,&a_x,&a_y,&a_w);
#endif
}

inline rret CHI(int a_id,int a_i){
#ifdef WIN32
  return HI(&a_id,&a_i);
#else
  return hi_(&a_id,&a_i);
#endif
}

inline rret CHIE(int a_id,int a_i){
#ifdef WIN32
  return HIE(&a_id,&a_i);
#else
  return hie_(&a_id,&a_i);
#endif
}

inline rret CHIJ(int a_id,int a_i,int a_j){
#ifdef WIN32
  return HIJ(&a_id,&a_i,&a_j);
#else
  return hij_(&a_id,&a_i,&a_j);
#endif
}

inline rret CHIJE(int a_id,int a_i,int a_j){
#ifdef WIN32
  return HIJE(&a_id,&a_i,&a_j);
#else
  return hije_(&a_id,&a_i,&a_j);
#endif
}

inline rret CHIX(int a_id,int a_i){
  rarg x;
#ifdef WIN32
  HIX(&a_id,&a_i,&x);
#else
  hix_(&a_id,&a_i,&x);
#endif
  return x;
}

inline void CHIJXY(int a_id,int a_i,int a_j,rarg& aX,rarg& aY){
  rarg x,y;
#ifdef WIN32
  HIJXY(&a_id,&a_i,&a_j,&x,&y);
#else
  hijxy_(&a_id,&a_i,&a_j,&x,&y);
#endif
  aX = x;
  aY = y;
}

inline int CHXI(int a_id,rarg a_x){
  int i;
#ifdef WIN32
  HXI(&a_id,&a_x,&i);
#else
  hxi_(&a_id,&a_x,&i);
#endif
  return i;
}

inline void CHXYIJ(int a_id,rarg a_x,rarg a_y,int& aI,int& aJ){
  int i,j;
#ifdef WIN32
  HXYIJ(&a_id,&a_x,&a_y,&i,&j);
#else
  hxyij_(&a_id,&a_x,&a_y,&i,&j);
#endif
  aI = i;
  aJ = j;
}

inline rret CHMIN(int a_id){
#ifdef WIN32
  return HMIN(&a_id);
#else
  return hmin_(&a_id);
#endif
}

inline rret CHMAX(int a_id){
#ifdef WIN32
  return HMAX(&a_id);
#else
  return hmax_(&a_id);
#endif
}

inline rret CHSTATI(int a_id,int a_what,const std::string& aChoice,int a_num){
#ifdef WIN32
  return HSTATI(&a_id,&a_what,PASSCHAR(aChoice.c_str()),&a_num);
#else
  return hstati_(&a_id,&a_what,aChoice.c_str(),&a_num,aChoice.size());
#endif
}

inline void CHRESET(int a_id,const std::string& a_title){
#ifdef WIN32
  HRESET(&a_id,PASSCHAR(a_title.c_str()));
#else
  hreset_(&a_id,a_title.c_str(),a_title.size());
#endif
}

//////////////////////////////////////////////////////////////////////////////
/// Tuple ////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
inline void CHBNT(int a1,const std::string& a2,const std::string& a3) {
#ifdef WIN32
  HBNT(&a1,PASSCHAR(a2.c_str()),PASSCHAR(a3.c_str()));
#else
  hbnt_(&a1,a2.c_str(),a3.c_str(),a2.size(),a3.size());
#endif
}

inline void CHBNAME(int a1,const std::string& a2,void* a3,const std::string& a4) {
#ifdef WIN32
  HBNAME(&a1,PASSCHAR(a2.c_str()),(int*)a3,PASSCHAR(a4.c_str()));
#else
  hbname_(&a1,a2.c_str(),(int*)a3,a4.c_str(),a2.size(),a4.size());
#endif
}

inline void CHBNAM(int a1,const std::string& a2,void* a3,const std::string& a4,int a5) {
#ifdef WIN32
  HBNAM(&a1,PASSCHAR(a2.c_str()),(int*)a3,PASSCHAR(a4.c_str()),&a5);
#else
  hbnam_(&a1,a2.c_str(),(int*)a3,a4.c_str(),&a5,a2.size(),a4.size());
#endif
}

inline void CHGNPAR(int a1,const std::string& a2) {
#ifdef WIN32
  HGNPAR(&a1,PASSCHAR(a2.c_str()));
#else
  hgnpar_(&a1,a2.c_str(),a2.size());
#endif
}

inline void CHFNT(int a1) {
#ifdef WIN32
  HFNT(&a1);
#else
  hfnt_(&a1);
#endif
}

inline void CHNTVAR2(
 int a1,int a2
,std::string& a3,std::string& a4,std::string& a5
,int& a6,int& a7,int& a8,int& a9) {

  char name[32];
  ::memset(name,' ',sizeof(name));
  name[sizeof(name)-1] = 0;

  char block[32];
  ::memset(block,' ',sizeof(block));
  block[sizeof(block)-1] = 0;

  char fullname[64];
  ::memset(fullname,' ',sizeof(fullname));
  fullname[sizeof(fullname)-1]=0;

  int v6,v7,v8,v9;
#ifdef WIN32
  HNTVAR2(&a1,&a2,PASSCHAR(name),PASSCHAR(fullname),PASSCHAR(block),&v6,&v7,&v8,&v9);
#else
  hntvar2_(&a1,&a2,name,fullname,block,&v6,&v7,&v8,&v9,32,64,32);
#endif

  int j;
  for (j=30;j>0;j--) {
    if (name[j] == ' ') name[j] = 0;
  }
  for (j=62;j>0;j--) {
    if (fullname[j] == ' ') fullname[j] = 0;
  }
  for (j=30;j>0;j--) {
    if (block[j] == ' ') block[j] = 0;
    else break;
  }

  a3 = name;
  a4 = fullname;
  a5 = block;

  a6 = v6;
  a7 = v7;
  a8 = v8;
  a9 = v9;
}

inline int CHGIVEN(
 int a_id
,std::string& a_title
,std::vector<std::string>& aColumns
){
  // Get number of columns :
  char chtitl[128];
  int nvar = 0;
  rarg rmin[1000],rmax[1000];
#ifdef WIN32
  HGIVEN(&a_id,chtitl,80,&nvar,PASSCHAR(""),rmin,rmax);
#else
  hgiven_(&a_id,chtitl,&nvar,"",rmin,rmax,80,0);
#endif

  // Get title and columns name :
  const int Nchar = 9;
  char* chtag_out = new char[nvar*Nchar+1];
  chtag_out[nvar*Nchar]=0;
  int i;
  for (i=0;i<=80;i++)chtitl[i]=0;
#ifdef WIN32
  HGIVEN(&a_id,chtitl,80,&nvar,chtag_out,Nchar,rmin,rmax);
#else
  hgiven_(&a_id,chtitl,&nvar,chtag_out,rmin,rmax,80,Nchar);
#endif
  for (i=80;i>0;i--) {if (chtitl[i] == ' ') chtitl[i] = 0; }

  a_title = chtitl;

  aColumns.clear();
  char* name = chtag_out;
  for(i=0; i<nvar;i++) {
    name[Nchar-1] = 0;
    int first = 0;
    int last = 0;
    // suppress trailing blanks
    int j;
    for (j=Nchar-2;j>0;j--) {
      if (name[j] == ' ' && last == 0) name[j] = 0;
      else last = j;
    }
    // suppress heading blanks
    for (j=0;j<Nchar;j++) {
      if (name[j] != ' ') break;
      first = j+1;
    }
    aColumns.push_back(name+first);
    name += Nchar;
  }

  return nvar;
}

inline int CHGNT(int a_id,int a_row){
  int ier = 0;
#ifdef WIN32
  HGNT(&a_id,&a_row,&ier);
#else
  hgnt_(&a_id,&a_row,&ier);
#endif
  return ier;
}

//inline int CHGNF(int a_id,int aRow,rarg* aBuffer){
//  int id = a_id;
//  int row = aRow;
//  int ier = 0;
//#ifdef WIN32
//  HGNF(&id,&row,aBuffer,&ier);
//#else
//  hgnf_(&id,&row,aBuffer,&ier);
//#endif
//  return ier;
//}

inline void CHOPERA(int a_id1,const std::string& a_opts,int a_id2,int a_id3,rarg a_c1,rarg a_c2) {
#ifdef WIN32
  HOPERA(&a_id1,PASSCHAR(a_opts.c_str()),&a_id2,&a_id3,&a_c1,&a_c2);
#else
  hopera_(&a_id1,a_opts.c_str(),&a_id2,&a_id3,&a_c1,&a_c2,a_opts.size());
#endif
}

}}

#ifdef WIN32
#undef PASSCHAR
#endif

#endif