#include <stdio.h>
#include <ctype.h>
#include "arc.h"

#ifdef VAXC
#include <stsdef.h>
#include <ssdef.h>
#include <rms.h>
#include <descrip.h>
#include "dir.h"
int long sys$setddir();
int lib$spawn();
int lib$find_file();
int lib$find_file_end();
int long lib$init_timer();
int long lib$show_timer();
int long lib$show_vm();
int long zero = 0;
int long four = 4;
#endif

/*
 * Misc routines to emulate IBM MSDOS functions under BSD
 *
 * Hack-attack 1.3  86/12/20  01:23:45  wilhite@usceast.uucp
 * 	Bludgeoned into submission for VAX 11/780 BSD4.2
 *	(ugly code, but fewer core dumps)
 */
INT upper(string)
char *string;
{
    register char *p;

    for(p = string; *p != NULL; p++)
	if(islower(*p))
	    *p = toupper(*p);
}
char *setmem(dest,size,c)
char *dest,c;
INT size;
{
 INT i;

    for(i = 0; i < size; dest[i] = c, i++);
    return(&dest[0]);
}
char *gcdir(dirname)
char *dirname;

{
#ifdef VAXC
	struct dsc$descriptor_s dsc;
	unsigned int def_len;
	long int ret;
	int slen;

	slen = strlen(dirname);
#endif
	if(dirname == NULL || strlen(dirname) == 0)
#ifdef VAXC
	{
		slen = 1024;
#endif
		dirname = (char *)malloc(1024);
#ifdef VAXC
	}
#endif

#ifdef VAXC
	dsc.dsc$w_length = slen;	/* length of work area */
	dsc.dsc$a_pointer = dirname;	/* Address of string */
	dsc.dsc$b_class = DSC$K_CLASS_S;
	dsc.dsc$b_dtype = DSC$K_DTYPE_T;
	ret = sys$setddir(0,&def_len,&dsc);
      	if (!(ret & STS$M_SUCCESS))
	{
       		fprintf(stderr,"%%VAXARC-F, Error in getting default account\n");
       		fprintf(stderr,"RMS_STATUS = %ld\n",ret);
		exit(ret);
	}
#else
	getwd(dirname);
#endif
	return(dirname);
}
#ifdef VMS
INT vabort(s,arg1,arg2,arg3)
#else
INT abort(s,arg1,arg2,arg3)
#endif
char *s;
{
    fprintf(stderr,"ARC: ");
    fprintf(stderr,s,arg1,arg2,arg3);
    fprintf(stderr,"\n");
#if BSD
    perror("BSD");
#endif
    exit(1);
}

#ifdef VAXC
/*
 * Do a forward index using a byte into a string.
 * return = 0 if not found
 *	  = address if found
 */

char *index(str1, str2)
char *str1;
char str2;
{
	return((char *) strchr(str1,str2));
}

/*
 * Do a reverse index using a byte into a string.
 * return = 0 if not found
 *	  = address if found
 */

char *rindex(str1, str2)
char *str1;
char str2;
{
	return((char *) strrchr(str1,str2));
}

/*
 * Do the MS-DOS/UNIX System command.
 */

#ifdef abc123

int system(buf)
char *buf;
{
	struct dsc$descriptor_s dsc_cmd;
	long int rms_stat, spawn_flags, spawn_status;
	char cmd[100];

	strcpy(cmd, "RUN ");
	strcat(cmd, buf);
	spawn_flags = 0;

	dsc_cmd.dsc$w_length = strlen(cmd);	/* length of work area */
	dsc_cmd.dsc$a_pointer = cmd;		/* Address of string */
	dsc_cmd.dsc$b_class = DSC$K_CLASS_S;
	dsc_cmd.dsc$b_dtype = DSC$K_DTYPE_T;

	rms_stat = lib$spawn(	dsc_cmd,
				0,		/* input file */
				0,		/* Output file */
				&spawn_flags,	/* Spawn flags */
				0,		/* Process name */
				0,		/* Process id */
				&spawn_status,	/* Returned program status */
				0,		/* Completion EFN */
				0,		/* Completion ASTADR */
				0,		/* Completion ASTARG */
				0,		/* Prompt */
				0);		/* CLI */
	return(spawn_status);
}
#endif

/*
 * For VAXC we need the functions scandir and alphasort
 */

char *pattern;	/* External pointer to file name */

INT scandir(delim,namelist,match,sort)
char *delim;
struct direct ***namelist;
char (*match)();
char (*sort)();
{
    struct direct dd;
    struct dsc$descriptor_s dsc_in, dsc_out;
    long int rms_stat, find_file_context;
    int out_len, file_cnt = 0;
    char out_file[255], *cp, **pnt=0;

    INT parsedir();

    dsc_in.dsc$w_length = strlen(pattern);	/* length of work area */
    dsc_in.dsc$a_pointer = pattern;		/* Address of string */
    dsc_in.dsc$b_class = DSC$K_CLASS_S;
    dsc_in.dsc$b_dtype = DSC$K_DTYPE_T;

    dsc_out.dsc$w_length = 0;			/* length of work area */
    dsc_out.dsc$a_pointer = 0;			/* Address of string */
    dsc_out.dsc$b_class = DSC$K_CLASS_D;
    dsc_out.dsc$b_dtype = DSC$K_DTYPE_T;

    *namelist = (char *)malloc(sizeof(char *));
    find_file_context = 0;			/* No Context on start */

    while ((rms_stat = lib$find_file(
				&dsc_in,	/* File spec */
				&dsc_out,	/* Result file spec */
				&find_file_context, /* Context */
				0,		/* Default file spec */
				0,		/* Related spec */
				0,		/* STV error */
				0)) == RMS$_NORMAL)
	{
	file_cnt++;		/* Increment the file count */
	strncpy(out_file, dsc_out.dsc$a_pointer,(unsigned int)dsc_out.dsc$w_length);
	*(&out_file + dsc_out.dsc$w_length) = '\0';
	(void) parsedir(out_file, 0, PARSE_NAME|PARSE_TYPE);
	out_len = strlen(out_file);
#ifdef xyzzy
	out_len = 0;
	cp = &out_file;
	while(*cp++ != ' ') out_len++;
	*(--cp) = NULL;		/* Make string null terminated */
	out_len--;		/* Just file name, not the NULL */
#endif
/* Allocate space for filename */

	*namelist = (char *)realloc(*namelist,file_cnt*sizeof(char *));
#ifdef abc123
	(*namelist)[file_cnt-1] = (char *)malloc(sizeof(struct direct));
#endif
	(*namelist)[file_cnt-1] =(struct direct *)malloc(sizeof(struct direct));
	(*namelist)[file_cnt-1]->d_namlen = out_len;	/* Length of filename */
	strcpy((*namelist)[file_cnt-1]->d_name, out_file);
	};		/* flags */
    return(file_cnt);		/* Return file count */
    {
/*
 * Process file names
 */

    }
/*
 * If call went well, rms_stat == RMS$_NORMAL
 */

/*
 * On exit, we need to clear the internal fields used by RMS.
 */
    rms_stat = lib$find_file_end(&find_file_context);
}

INT alphasort()
{
}

INT parsedir(cp, defnam, flag)
char *cp;		/* Pointer to file spec to parse */
char *defnam;		/* Default file spec */
int flag;		/* Flag word PARSE_xxx */
{
	struct FAB fab;
	struct NAM nam;
	char expanded_name[NAM$C_MAXRSS];
	int long rms_status;
	int cp_len;

	cp_len = strlen(cp);

	fab = cc$rms_fab;
	fab.fab$l_nam = &nam;
	fab.fab$l_fna = cp;
	fab.fab$b_fns = strlen(cp);
	fab.fab$l_dna = defnam;
	if (defnam) fab.fab$b_dns = strlen(defnam);

	nam = cc$rms_nam;
	nam.nam$l_esa = &expanded_name;
	nam.nam$b_ess = sizeof(expanded_name);

	if ((rms_status = sys$parse(&fab)) != RMS$_NORMAL)
	{
		printf("%%PARSEDIR-F-PRSERR, Parse error %s\n",cp);
		exit(rms_status);
	}

	*cp = NULL;			/* Make a zero length string */
	if ((PARSE_NODE & flag) && (int)nam.nam$b_node)
		strncat(cp, nam.nam$l_node, (int)nam.nam$b_node);
	if ((PARSE_DEVICE & flag) && (int)nam.nam$b_dev)
		strncat(cp, nam.nam$l_dev, (int)nam.nam$b_dev);
	if ((PARSE_DIRECTORY & flag) && (int)nam.nam$b_dir)
		strncat(cp, nam.nam$l_dir, (int)nam.nam$b_dir);
	if ((PARSE_NAME & flag) && (int)nam.nam$b_name)
		strncat(cp, nam.nam$l_name, (int)nam.nam$b_name);
	if ((PARSE_TYPE & flag) && (int)nam.nam$b_type)
		strncat(cp, nam.nam$l_type, (int)nam.nam$b_type);
	if ((PARSE_VERSION & flag) && (int)nam.nam$b_ver)
		strncat(cp, nam.nam$l_ver, (int)nam.nam$b_ver);
	return(0);
}

void initvmsstats()
{
	if (vmsstats) lib$init_timer();
}

void printvmsstats()
{
	if (vmsstats)
	{
	    lib$show_timer();
	    lib$show_vm(&zero);
	    lib$show_vm(&four);
	}
}

/*
 * Get RMS attributes so that we can save them in the file.
 * This will allow us to restore the file to an RMS envirement with
 * original attributes.
 */
void get_attr(file, atr)
char *file;
struct atr;
{

	return;
}
#endif