#include <stdio.h>
#include <stdarg.h>

/*
*	The function of this package is to provide a simple, uniform,
*	and somewhat flexible tool for producing printout (mostly, for
*	debugging purposes) from C code.  The functions in the package
*	print data on two files, whose names are specified by the user
*	in a call to the function cprini (see below).  Normally, one of
*	the files is "stdout", causing the data to be printed on the
*	screen.  The second file is whatever the user likes; it will
*	contain a copy of whatever has been printed on the screen.
*	The author likes to name his file "fort.13", to match the default
*	FORTRAN name for output file 13.
*
*	If cprini is called a second time, it will keep the old files
*	open, remembering their names; if it is called yet again
*	to switch back to the first set of files, it will not
*	reopen them but will pick up writing where it left off.
*	(This obsoletes the functions cprinstart and cprinstop, which
*	however are provided for compatibility reasons.)
*
*
*   The following functions are provided:
*
*   cprini is the initialization function (see description below).
*   cprintff has exactly the same calling sequence as printf, but
*	prints on both files simultaneously.
*
*   cprin, cprinf, cprin2, cprinq, and cprina are array printing
*	 routines; their calling sequences are identical, except
*	 for the types of data they print. Specifically, 
*   cprin prints floating point data
*   cprinf prints integer data
*   cprin2 prints double precision data
*   cprinq prints extended precision data
*   cprina prints character data (but it is probably preferable to
*		use cprintff for this, instead.)
*
*        Of these five functions, only cprin has a complete description
*        below (see); the rest are identical (except for the type of data
*        they print).
*
*   cprinstop stops the printing on both files, until further notice,
*        to be given by a call to cprinstart
*
*   cprinstart resumes printing previously suspended by a call the 
*        cprinstop; if the printing had not been suspended, cprinstart
*        has no effect.
*
*   cprclose closes files opened by cprini, in order to free up open file
*        slots (of which the system only provides a limited number).
*
*/

void cprintff(char *s, ...);		/* forward declaration */

 /*
  *        This function prints a real *4 array of length n, 
  *        preceded by a user message. A typical invocation 
  *        looks like 
  *
  *        cprin("printing real array a of length 10, a=",a,10);
  *
  *        to print an array, or
  *
  *        cprin("printing real array number a; a=",&a,1);
  *
  *        to print a real number.
  *
  *                 Input parameters:
  *
  *  mes - a character array to be printed
  *  ap - the real array to be printed
  *  n - the length of array arr
  *
  */

cprin(mes,ap,n)
char *mes;
int n;
float *ap;
{
    int i,c;

    if(mes) cprintff("%s\n",mes);

    for(i=0; i<n; i++) {
	cprintff("  %11.4le", (double) *ap++);
	if(i%6==5 || i==n-1)
	    cprintff("\n");
    }
}




cprinf(mes,ip,n)
char *mes;
int *ip,n;
{
    int i,c;

    if(mes) cprintff("%s\n",mes);

    for(i=0; i<n; i++) {
	cprintff(" %7d", *ip++);
	if(i%10==9 || i==n-1)
	    cprintff("\n");
    }
}




cprin2(mes,ap,n)
char *mes;
int n;
double *ap;
{
    int i,c;

    if(mes) cprintff("%s\n",mes);

    for(i=0; i<n; i++) {
	cprintff("  %11.4le", *ap++);
	if(i%6==5 || i==n-1)
	    cprintff("\n");
    }
}




cprinq(mes,ap,n)
char *mes;
int n;
long double *ap;
{
    int i,c;

    if(mes) cprintff("%s\n",mes);

    for(i=0; i<n; i++) {
	cprintff("  %11.4le", (double) *ap++);
	if(i%6==5 || i==n-1)
	    cprintff("\n");
    }
}




cprina(mes,cp,n)
char *mes;
int n;
char *cp;
{
    int i,c;

    if(mes) cprintff("%s\n",mes);

    for(i=0; i<n; i++) {
	cprintff("%c", *cp++);
	if(i%60==59 || i==n-1)
	    cprintff("\n");
    }
}


/*
 * The following static variables are for the internal use of the
 * code; they contain lists of output files, among other things.
 */

static int ini=0;			/* whether or not the following
					   arrays have been initialized */
static char *fnames[FOPEN_MAX];		/* filenames of all currently open
					   files */
static FILE *fps[FOPEN_MAX];		/* all currently open files */
static FILE *fpcur[2];			/* the two current files */
static int istop=0;			/* whether or not printing has
					   been suspended */



/*
 *        This function initializes the printing functions 
 *        cprintff, cprin, cprin2, cprinq, cprinf, cprina (see).
 *	  It takes as input the names str1, str2 of the two files on
 *	  which the output will be written.  Several names are
 *	  treated specially, as follows:
 *
 *		strX==NULL or strX=="      ":
 *			no output is to be written for file X,
 *			where X is either 1 or 2 (or both).
 *
 *		strX=="stdout":
 *			output for file X is to be written on
 *			standard output.
 *
 *		strX=="stderr":
 *			output for file X is to be written on
 *			standard error.
 *
 *        The outputs written on the files str1 and str2 will be
 *        identical.
 *
 *
 *                         Input parameters:
 *
 *  str1, str2 - strings containing the names of files on which the 
 *        output will be printed
 *
 *                         Output parameters: none
 */


cprini(str1,str2)
char *str1,*str2;
{
    char *s[2];
    int i,k;

    /*
     * if this is the very first call, set up the arrays of filenames
     * and file pointers.
     */

    if(ini==0) {
	for(i=0;i<FOPEN_MAX;i++) {
	    fnames[i]=NULL;
	    fps[i]=NULL;
	}
	ini=1;
    }

    /*
     * check each filename in turn
     */

    s[0]=str1;
    s[1]=str2;

    for(k=0;k<2;k++) {

	/*
	 * check if either of the two filenames is NULL, stdout, or
	 * stderr
	 */

	if(!s[k] || !strcmp(s[k],"      ")) {
	    fpcur[k]=NULL;
	    goto found;
	}
	if(!strcmp(s[k],"stdout")) {
	    fpcur[k]=stdout;
	    goto found;
	}
	if(!strcmp(s[k],"stderr")) {
	    fpcur[k]=stderr;
	    goto found;
	}

	/*
	 * check if the file is already open
	 */

	for(i=0;i<FOPEN_MAX;i++) {
	    if(fnames[i] && !strcmp(fnames[i],s[k])) {
	        fpcur[k]=fps[i];
	        goto found;
	    }
	}

	/*
	 * look for an empty space for the file to fit into; and if
	 * found, open the file and put the file pointer there.  Set
	 * the buffering to line-mode.
	 */

	for(i=0;i<FOPEN_MAX;i++) {
	    if(!fnames[i]) {
	        fpcur[k]=fps[i]=fopen(s[k],"w");
	        if(!fps[i]) {
		    fprintf(stderr,"cprini: couldn't open %s\n",s[k]);
		    goto found;
	        }
	        setlinebuf(fps[i]);
		fnames[i]=s[k];
	        goto found;
	    }
	}

	/*
	 * search revealed no empty slots
	 */

	fprintf(stderr,"cprini: no free slots for new output file\n");
	fpcur[k]=NULL;
 found: ;
    }
}



/*
 * The following function closes a file opened by the routine cprini.  It
 * takes one parameter, the name of the file to close.  This file must have
 * previously been opened using cprini.  This routine works even if the
 * file is presently designated as an output stream (in that case, of
 * course, no more data is written to it).
 */

cprclose(s)
char *s;
{
    int i,err;

    /*
     * if this routine was not initialized yet by any call to cprini, bug
     * out
     */

    if(ini==0) {
	fprintf(stderr,"cprclose: called before any call to cprini\n");
	return;
    }

    /*
     * search the list of open files for the file to close
     */

    for(i=0;i<FOPEN_MAX;i++) {
	if(fnames[i] && !strcmp(fnames[i],s)) {
	    if(fclose(fps[i]))
	        perror("cprclose: couldn't close file\n");
	    fnames[i]=NULL;
	    if(fpcur[0]==fps[i]) fpcur[0]=NULL;
	    if(fpcur[1]==fps[i]) fpcur[1]=NULL;
	    fps[i]=NULL;
	    return;
	}
    }

    /*
     * ...not found, complain.
     */

    fprintf(stderr,"cprclose: file %s not open\n",s);
}




/*
 * The following function has an identical calling sequence to that of
 * printf; however, it prints simultaneously on both of the files
 * designated by the routine cprini (see).  In addition it has a limit
 * of 512 characters output per call.  (Additional characters
 * are silently truncated.)
 */

#define MBUFSIZE 512

void cprintff(char *s, ...)
{
    va_list ap;
    char buf[MBUFSIZE];
    int lbuf;

    va_start(ap,s);
    if(istop || ini==0) return;
    lbuf=vsnprintf(buf,MBUFSIZE,s,ap);
    va_end(ap);

    if(lbuf>MBUFSIZE) lbuf=MBUFSIZE;

    if(fpcur[0]) fwrite(buf,lbuf,1,fpcur[0]);
    if(fpcur[1]) fwrite(buf,lbuf,1,fpcur[1]);
}



cprinstop()
{
    istop=1;
}

cprinstart()
{
    istop=0;
}