#include "aaspi_interface.h"
#include "aaspi_file.h"
#include "aaspi_framework.h"

AASPI_Framework global_afw;

inline static void copy_fort_string(char *fstr, const string &str, int maxlen)
{
	size_t ln=str.size();
	if (ln > size_t(maxlen)) ln=maxlen;
	memcpy(fstr,str.c_str(),ln);
        if (ln < size_t(maxlen)) { // Fill remained with blanks
		memset(fstr+ln,' ',maxlen-ln);
	}
}


void aaspi_init()
{
	global_afw.init();
}

void aaspi_set_arg_count(int len)
{
	global_afw.set_arg_count(len);
}

void aaspi_set_arg(int pos, char *arg)
{
	if (!arg) arg="";
	global_afw.set_arg(pos,arg);
}

void aaspi_close_all_files()
{
	global_afw.close_all_files();
}

void aaspi_get_host_name(char *hst,int maxlen)
{
	string rv=global_afw.getHostName();
	copy_fort_string(hst,rv,maxlen);
}

void aaspi_get_user_name(char *usr,int maxlen)
{
	string rv=global_afw.getUserName();
	copy_fort_string(usr,rv,maxlen);
}

void aaspi_get_time(char *tm,int maxlen)
{
	string rv=global_afw.getTime();
	copy_fort_string(tm,rv,maxlen);
}

void aaspi_get_home_dir(char *hd,int maxlen)
{
	string rv=global_afw.homeDir();
	copy_fort_string(hd,rv,maxlen);
}

void aaspi_get_prog_name(char *pn,int maxlen)
{
	string rv=global_afw.progName();
	copy_fort_string(pn,rv,maxlen);
}

//------------------------------------------------------------------------

void aaspi_get_param_string(const char *tag, char *par, const char *defval, int maxlen)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_get_param_string" << endl;
		return;
	}
	if (!defval) defval="";
	string rv=global_afw.get_param_string(tag,defval);
	copy_fort_string(par,rv,maxlen);
}

void aaspi_get_param_int(const char *tag, int *par, int defval)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_get_param_int" << endl;
		return;
	}
	int rv=global_afw.get_param_int(tag,defval);
	*par=rv;
}

void aaspi_get_param_int64(const char *tag, aaspi_int64 *par, aaspi_int64 defval)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_get_param_int64" << endl;
		return;
	}
	aaspi_int64 rv=global_afw.get_param_int64(tag,defval);
	*par=rv;
}

void aaspi_get_param_float(const char *tag, float *par, float defval)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_get_param_float" << endl;
		return;
	}
	float rv=global_afw.get_param_float(tag,defval);
	*par=rv;
}

void aaspi_get_param_double(const char *tag, double *par, double defval)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_get_param_double" << endl;
		return;
	}
	double rv=global_afw.get_param_double(tag,defval);
	*par=rv;
}

void aaspi_get_param_boolean(const char *tag, int *par, int defval)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_get_param_boolean" << endl;
		return;
	}
	bool dval=(defval != 0);
	bool rv=global_afw.get_param_boolean(tag,dval);
	*par=rv?1:0;
}

bool aaspi_has_param(const char *tag)
{
	if (!tag) {
		cerr << "Warning: Empty tag in aaspi_has_param" << endl;
		return false;
	}
	return global_afw.has_param(tag);
}


//------------------------------------------------------------------------

int aaspi_get_esize(const char *file_tag, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_esize" << endl;
		*stat=-2;
		return 0;
	}
	AASPI_File *af=global_afw.get_file_opened(file_tag);
	if (!af) { *stat=-1; return 0; }
	return af->get_esize();
}

int aaspi_get_data_format(const char *file_tag, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_data_format" << endl;
		*stat=-2;
		return 0;
	}
	AASPI_File *af=global_afw.get_file_opened(file_tag);
	if (!af) { *stat=-1; return 0; }
	return af->get_data_format();
}

void aaspi_get_hist_string(const char *file_tag, const char *tag, char *par, const char *defval, int maxlen, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_hist_string" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_get_hist_string" << endl;
		*stat=-3;
		return;
	}
	if (!defval) defval="";
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return; }
	string rv=af->getDict().get_string(tag,defval);
	copy_fort_string(par,rv,maxlen);
}

void aaspi_get_hist_int(const char *file_tag, const char *tag, int *par, int defval, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_hist_int" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_get_hist_int" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return; }
	*par=af->getDict().get_int(tag,defval);
}

void aaspi_get_hist_int64(const char *file_tag, const char *tag, aaspi_int64 *par, aaspi_int64 defval, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_hist_int64" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_get_hist_int64" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return; }
	*par=af->getDict().get_int64(tag,defval);
}

void aaspi_get_hist_float(const char *file_tag, const char *tag, float *par, float defval, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_hist_float" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_get_hist_float" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return; }
	*par=af->getDict().get_float(tag,defval);
}

void aaspi_get_hist_double(const char *file_tag, const char *tag, double *par, double defval, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_hist_double" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_get_hist_double" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return; }
	*par=af->getDict().get_double(tag,defval);
}

void aaspi_get_hist_boolean(const char *file_tag, const char *tag, int *par, int defval, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_hist_boolean" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_get_hist_boolean" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return; }
	bool dval=(defval != 0);
	bool rv=af->getDict().get_boolean(tag,dval);
	*par=rv?1:0;
}

bool aaspi_hist_has_param(const char *file_tag, const char *tag, int *stat) {
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_hist_has_param" << endl;
		*stat=-2;
		return false;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_hist_has_param" << endl;
		*stat=-3;
		return false;
	}
	AASPI_File *af=global_afw.get_file_in(file_tag);
	if (!af) { *stat=-1; return false; }
	return af->hasParam(tag);
}


//------------------------------------------------------------------------

void aaspi_put_hist_string(const char *file_tag, const char *tag, const char *par, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_hist_string" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_put_hist_string" << endl;
		*stat=-3;
		return;
	}
	if (!par) par="";
	AASPI_File *af=global_afw.get_file_out(file_tag);
	if (!af) { *stat=-1; return; }
	if (par) {
		af->putParam(tag,par);
	} else {
		af->putParam(tag,"");
	}
}

void aaspi_put_hist_int(const char *file_tag, const char *tag, int par, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_hist_int" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_put_hist_int" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_out(file_tag);
	if (!af) { *stat=-1; return; }
	af->putParam(tag,par);
}

void aaspi_put_hist_int64(const char *file_tag, const char *tag, aaspi_int64 par, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_hist_int64" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_put_hist_int64" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_out(file_tag);
	if (!af) { *stat=-1; return; }
	af->putParam(tag,par);
}

void aaspi_put_hist_float(const char *file_tag, const char *tag, float par, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_hist_float" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_put_hist_float" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_out(file_tag);
	if (!af) { *stat=-1; return; }
	af->putParam(tag,par);
}

void aaspi_put_hist_double(const char *file_tag, const char *tag, double par, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_hist_double" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_put_hist_double" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_out(file_tag);
	if (!af) { *stat=-1; return; }
	af->putParam(tag,par);
}

void aaspi_put_hist_boolean(const char *file_tag, const char *tag, int par, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_hist_boolean" << endl;
		*stat=-2;
		return;
	}
	if (!tag) {
		cerr << "Warning: Empty tag name in aaspi_put_hist_boolean" << endl;
		*stat=-3;
		return;
	}
	AASPI_File *af=global_afw.get_file_out(file_tag);
	if (!af) { *stat=-1; return; }
	bool bval=(par != 0);
	af->putParam(tag,bval);
}


//------------------------------------------------------------------------

int aaspi_get_num_axes(const char *file_tag, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_num_axes" << endl;
		*stat=-2;
		return 0;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return 0; }
        return af->get_num_axes();
}

void aaspi_get_axis_par(const char *file_tag, int iax, int *n, float *o, float *d, char *label, int maxlen, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_axis_par" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	string lab;
	int rv=af->get_axis_par(iax,*n,*o,*d,lab);
	if (rv) { *stat=-2; return; }
	copy_fort_string(label,lab,maxlen);
}

void aaspi_put_axis_par(const char *file_tag, int iax, int n, float o, float d, const char *label, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_axis_par" << endl;
		*stat=-3;
		return;
	}
	if (!label) label="";
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	string lab;
	if (label) lab=label;
	int rv=af->put_axis_par(iax,n,o,d,lab);
	if (rv) { *stat=-2; return; }
}



void aaspi_copy_data_pointer(const char *file_tag_src, const char *file_tag_dst, int *stat)
{
	*stat=0;
	if (!file_tag_src) {
		cerr << "Warning: Empty src file tag in aaspi_copy_data_pointer" << endl;
		*stat=-3;
		return;
	}
	if (!file_tag_dst) {
		cerr << "Warning: Empty dst file tag in aaspi_copy_data_pointer" << endl;
		*stat=-4;
		return;
	}
        AASPI_File *af1=global_afw.get_file_in(file_tag_src);
        if (!af1) { *stat=-1; return; }
        AASPI_File *af2=global_afw.get_file_out(file_tag_dst);
        if (!af2) { *stat=-2; return; }
	if (! af2->CopyDataPointer(*af1)) { *stat=-3; return; }
}

void aaspi_copy_history(const char *file_tag_src, const char *file_tag_dst, int *stat)
{
	*stat=0;
	if (!file_tag_src) {
		cerr << "Warning: Empty src file tag in aaspi_copy_history" << endl;
		*stat=-3;
		return;
	}
	if (!file_tag_dst) {
		cerr << "Warning: Empty dst file tag in aaspi_copy_history" << endl;
		*stat=-4;
		return;
	}
        AASPI_File *af1=global_afw.get_file_in(file_tag_src);
        if (!af1) { *stat=-1; return; }
        AASPI_File *af2=global_afw.get_file_out(file_tag_dst);
        if (!af2) { *stat=-2; return; }
	if (! af2->CopyHistFrom(*af1)) { *stat=-3; return; }
}

// Forcing AASPI binary output when copying history info
void aaspi_copy_history_force_aaspi_binary(const char *file_tag_src, const char *file_tag_dst, int *stat)
{
	*stat = 0;
	if (!file_tag_src) {
		cerr << "Warning: Empty src file tag in aaspi_copy_history" << endl;
		*stat = -3;
		return;
	}
	if (!file_tag_dst) {
		cerr << "Warning: Empty dst file tag in aaspi_copy_history" << endl;
		*stat = -4;
		return;
	}
	AASPI_File *af1 = global_afw.get_file_in(file_tag_src);
	if (!af1) { *stat = -1; return; }
	AASPI_File *af2 = global_afw.get_file_out_force_aaspi_binary(file_tag_dst);
	if (!af2) { *stat = -2; return; }
	if (!af2->CopyHistFrom(*af1)) { *stat = -3; return; }
}


//------------------------------------------------------------------------

void aaspi_read_raw(const char *file_tag, void *dst, int n, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_read_raw" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	aaspi_ssize_t nread=af->Read(dst,n);
	if (nread <= 0) {*stat=-2; return; }
}

void aaspi_write_raw(const char *file_tag, void *src, int n, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_write_raw" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	aaspi_ssize_t nwritten=af->Write((char *) src,n);
	if (nwritten <= 0) {*stat=-2; return; }
}

// Forcing aaspi binary write raw procedure
void aaspi_write_raw_force_aaspi_binary(const char *file_tag, void *src, int n, int *stat)
{
	*stat = 0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_write_raw_force_aaspi_binary" << endl;
		*stat = -3;
		return;
	}
	AASPI_File *af = global_afw.get_file_out_force_aaspi_binary(file_tag);
	if (!af) { *stat = -1; return; }
	aaspi_ssize_t nwritten = af->Write((char *)src, n);
	if (nwritten <= 0) { *stat = -2; return; }
}

void aaspi_seek(const char *file_tag, aaspi_int64 pos, int whence, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_seek" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_opened(file_tag);
        if (!af) { *stat=-1; return; }
	if (! af->Seek(pos,whence)) *stat=-2;
}

aaspi_int64 aaspi_tell(const char *file_tag, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_tell" << endl;
		*stat=-2;
		return 0;
	}
        AASPI_File *af=global_afw.get_file_opened(file_tag);
        if (!af) { *stat=-1; return aaspi_int64(0); }
	return af->Tell();
}


//------------------------------------------------------------------------

int aaspi_get_number_keys(const char *file_tag, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_number_keys" << endl;
		*stat=-2;
		return 0;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return 0; }
	int nkeys=0;
	af->get_number_keys(nkeys);
	return nkeys;
}

void aaspi_get_header_axis(const char *file_tag, int iax,
                           int *n, float *o, float *d,
                           char *label, int maxlen,int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_header_axis" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	string lab;
	int rv=af->get_header_axis_par(iax,*n,*o,*d,lab);
	copy_fort_string(label,lab,maxlen);
	if (rv) *stat=-2;
}

void aaspi_get_key_name(const char *file_tag, int keyidx, char *keyname,
                        int maxlen, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_key_name" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	string keyn;
	af->get_key_name(keyidx,keyn);
        if (keyn.empty()) { *stat=-2; return; }
	copy_fort_string(keyname,keyn,maxlen);
}

void aaspi_get_key_index(const char *file_tag, const char *keyname,
                         int *keyidx, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_key_index" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	af->get_key_index(keyname,*keyidx);
	if (*keyidx == 0) { *stat=-2; return; }
}

void aaspi_get_key_format(const char *file_tag, int keyidx,
                          int *keyfmt, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_key_format" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
        af->get_key_format(keyidx,*keyfmt);
	if (keyfmt == 0) { *stat=-2; return; }
}

void aaspi_get_key_format_string(const char *file_tag, int keyidx,
                                 char *keyfmt, int maxlen, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_key_format_string" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	string keyf;
        af->get_key_format(keyidx,keyf);
        if (keyf.empty()) { *stat=-2; return; }
	copy_fort_string(keyfmt,keyf,maxlen);
}

void aaspi_get_key_type(const char *file_tag, int keyidx,
                        char *keytyp, int maxlen, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_key_type" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	string keyt;
        af->get_key_type(keyidx,keyt);
        if (keyt.empty()) { *stat=-2; return; }
	copy_fort_string(keytyp,keyt,maxlen);
}

void aaspi_get_val_by_index(const char *file_tag, int recno, int keyidx,
                                int nval, int *vals, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_val_by_index" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	af->get_key_val_by_index(recno,keyidx,nval,vals);
}

void aaspi_get_val_by_name(const char *file_tag, int recno,
                               const char *keyname, int nval,
                               int *vals, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_val_by_name" << endl;
		*stat=-3;
		return;
	}
	if (!keyname) {
		cerr << "Warning: Empty key name in aaspi_get_val_by_name" << endl;
		*stat=-4;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	af->get_key_val_by_name(recno,keyname,nval,vals);
}

void aaspi_get_val_headers(const char *file_tag, int recno, int nhdr,
                           int *vals, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_get_val_headers" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af=global_afw.get_file_in(file_tag);
        if (!af) { *stat=-1; return; }
	af->get_val_headers(recno,nhdr,vals);
}

void aaspi_copy_hff(const char *file_tag_src, const char *file_tag_dst, int *stat)
{
	*stat=0;
	if (!file_tag_src) {
		cerr << "Warning: Empty src file tag in aaspi_copy_hff" << endl;
		*stat=-3;
		return;
	}
	if (!file_tag_dst) {
		cerr << "Warning: Empty dst file tag in aaspi_copy_hff" << endl;
		*stat=-3;
		return;
	}
        AASPI_File *af1=global_afw.get_file_in(file_tag_src);
        if (!af1) { *stat=-1; return; }
        AASPI_File *af2=global_afw.get_file_out(file_tag_dst);
        if (!af2) { *stat=-2; return; }
	if (! af2->CopyHeaderFrom(*af1)) { *stat=-3; return; }
}

// Forcing AASPI binary output when copying header history
void aaspi_copy_hff_force_aaspi_binary(const char *file_tag_src, const char *file_tag_dst, int *stat)
{
	*stat = 0;
	if (!file_tag_src) {
		cerr << "Warning: Empty src file tag in aaspi_copy_hff" << endl;
		*stat = -3;
		return;
	}
	if (!file_tag_dst) {
		cerr << "Warning: Empty dst file tag in aaspi_copy_hff" << endl;
		*stat = -3;
		return;
	}
	AASPI_File *af1 = global_afw.get_file_in(file_tag_src);
	if (!af1) { *stat = -1; return; }
	AASPI_File *af2 = global_afw.get_file_out_force_aaspi_binary(file_tag_dst);
	if (!af2) { *stat = -2; return; }
	if (!af2->CopyHeaderFrom(*af1)) { *stat = -3; return; }
}

void aaspi_put_number_keys(const char *file_tag, int nkeys, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_number_keys" << endl;
		*stat=-2;
		return;
	}
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	af->put_number_keys(nkeys);
}

void aaspi_put_header_axis(const char *file_tag, int iax, int n,
                           float o, float d, const char *label, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_header_axis" << endl;
		*stat=-2;
		return;
	}
	if (!label) label="";
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	af->put_header_axis_par(iax,n,o,d,label);
}

void aaspi_put_key(const char *file_tag, const char *keyname,
                   const char *keytyp, const char *keyfmt, int keyidx,
                   int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_key" << endl;
		*stat=-2;
		return;
	}
	if (!keyname) {
		cerr << "Warning: Empty keyname in aaspi_put_key" << endl;
		*stat=-3;
		return;
	}
	if (!keytyp) {
		cerr << "Warning: Empty keytype in aaspi_put_key" << endl;
		*stat=-4;
		return;
	}
	if (!keyfmt) {
		cerr << "Warning: Empty keyfmt in aaspi_put_key" << endl;
		*stat=-4;
		return;
	}
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	af->put_key(keyname,keytyp,keyfmt,keyidx);
}

void aaspi_put_val_by_index(const char *file_tag, int recno,
                            int keyidx, int nval, int *vals, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_val_by_index" << endl;
		*stat=-2;
		return;
	}
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	af->put_val_by_index(recno,keyidx,nval,vals);
}

void aaspi_put_val_headers(const char *file_tag, int recno,
                           int nhdr, int *vals, int *stat)
{
	*stat=0;
	if (!file_tag) {
		cerr << "Warning: Empty file tag in aaspi_put_val_headers" << endl;
		*stat=-2;
		return;
	}
        AASPI_File *af=global_afw.get_file_out(file_tag);
        if (!af) { *stat=-1; return; }
	af->put_val_headers(recno,nhdr,vals);
}