/*
 * COMM1.C
 *
 * Matthew Dillon, August 1986
 *
 * Version 2.07M by Steve Drew 10-Sep-87
 *
 * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
 *
 */

#define DIR_SHORT 0x01
#define DIR_FILES 0x02
#define DIR_DIRS  0x04
#define DIR_NOCOL 0x08
#define DIR_NAMES 0x10

extern int has_wild;

/*
	Parse the options specified in sw[]
	Setting a bit in global variable options
	for each one found
*/

get_opt(sw,count)
char *sw;
int *count;
{
register char *c,*s;
unsigned int l,i = 0;

options=0;
while((++i < ac) && (av[i][0] == '-')) {
	for (c = av[i]+1; *c ; c++) {
		for(l = 0,s = sw;*s && *s != *c; ++s) ++l;
		if (*s) options |= (1 << l);
		}
	}
*count = i;
}

do_sleep()
{
register int i;

if (ac == 2) for (i=atoi(av[1]); i>0 && !CHECKBREAK(); i-=2) Delay(100L);
return 0;
}

do_protect()
{
register long mask=0xf;
register char *s, *p;
static char flags[]="DEWRAPSH";
register unsigned short i;

for (s=av[--ac]; *s; s++)
	if (p=index(flags, toupper(*s))) mask^=(1 << (p-flags));
	else ierror(av[ac],500);
for (i=1; i<ac; i++) if (!SetProtection(av[i],mask)) pError(av[i]);
return 0;
}

do_filenote()
{
char *note=av[--ac];
register unsigned int i;

for (i=1; i<ac; i++) if (!SetComment(av[i], note)) pError(av[i]);
return 0;
}

do_cat()
{
FILE *fopen(), *fi;
register unsigned int lctr;
unsigned int i;
char buf[256];

get_opt("n",&i);
if (i>=ac) {
	if (has_wild) { printf("No files matching\n"); return 20; }
	lctr=0;
	while (gets(buf) && !dobreak()) {
		if (options) printf("%4d ",++lctr);
		puts(buf);
		}
	}
for (; i<ac; i++)
	if (fi = fopen (av[i], "r")) {
		lctr=0;
		while (fgets(buf,256,fi) && !dobreak()) {
			if (options) printf("%4d ",++lctr);
			printf("%s",buf);
			}
		fclose (fi);
		}
	else pError(av[i]);
return 0;
}

do_info()
{
BPTR lock;
struct InfoData *info;
long size, free;
char *p, buf[130], *state;
struct DirectoryEntry *de_head=NULL, *de;

info=(struct InfoData *)AllocMem((long)sizeof(struct InfoData),MEMF_PUBLIC);
AddDADevs(&de_head, DLF_DEVICES | DLF_DISKONLY );
Myprocess->pr_WindowPtr = (APTR)(-1);
printf ("Unit  Size  Bytes  Used Blk/By-Free Full Errs  Status    Name\n");
for (de=de_head; de; de=de->de_Next) {
	printf("%-5s",de->de_Name);
	if (lock=Lock(de->de_Name,ACCESS_READ)) {
	    if (Info(lock, info)) {
		PathName(lock, buf, 128L);
		if (p=index(buf,':')) *p = '\0';
		size = ((info->id_NumBlocks + 2)* info->id_BytesPerBlock)/ 1024;
		free = (((info->id_NumBlocks-info->id_NumBlocksUsed))*
			   info->id_BytesPerBlock)/ 1024;
		switch(info->id_DiskState) {
			case ID_WRITE_PROTECTED: state="Read Only "; break;
			case ID_VALIDATED:	 state="Read/Write"; break;
			case ID_VALIDATING:	 state="Validating"; break;
			}
		printf("%4ld%c%6ld%7ld%7ld%4ld%c%4ld%%%4ld  %s %s\n",
			(size>1024) ? ((size+512) >> 10) : size,
			(size>1024) ? 'M' : 'K',
			info->id_BytesPerBlock,
			info->id_NumBlocksUsed,
			info->id_NumBlocks-info->id_NumBlocksUsed,
			(free>1024) ? ((free+512) >> 10) : free,
			(free>1024) ? 'M' : 'K',
			(info->id_NumBlocksUsed * 100)/info->id_NumBlocks,
			info->id_NumSoftErrors,
			state,
			buf);
		}
	    else pError (de->de_Name);
	    UnLock(lock);
	    }
	else puts("  No disk present");
	}
FreeDAList(&de_head);
Myprocess->pr_WindowPtr = NULL;
FreeMem(info,(long)sizeof(struct InfoData));
return 0;
}

/* things shared with display_file */

BPTR lastlock;
int filecount, col;
long bytes, blocks;

/*
 * the args passed to do_dir will never be expanded
 */
do_dir()
{
int i, c, eac;
char **eav;

col = filecount = 0;
bytes = blocks = 0L;
lastlock=NULL;

get_opt("sfdcn",&i);

if (ac == i) { ++ac; av[i]=""; }
if (!(options & (DIR_FILES | DIR_DIRS))) options|=(DIR_FILES | DIR_DIRS);

for (; i<ac && !CHECKBREAK(); ++i)
	if (eav = expand(av[i], &eac)) {
		QuickSort(eav, eac);
		for(c=0; c<eac && !CHECKBREAK(); ++c)
			if (options & DIR_NAMES)
				puts(eav[c]);
			else
				display_file(eav[c]);
		free_expand (eav);
		}
if (col) printf("\n");
if (filecount>1) {
	blocks += filecount; /* account for dir blocks */
	printf(" %ld Blocks, %ld Bytes used in %d files\n",
		blocks, bytes, filecount);
	}
if (lastlock) UnLock(lastlock);
return 0;
}

display_file(filestr)
char *filestr;
{
long atol();
int isadir,slen;
char sc, *fi, *base, buf[130];
BPTR thislock;

base=BaseName(filestr);
sc = *base;
*base = '\0';
thislock=Lock(filestr,SHARED_LOCK);
/* if (thislock==NULL) return; */
if (lastlock==NULL || CompareLock(thislock,lastlock)) {
	if (col) printf("\n");
	col = 0;
	PathName(thislock, buf, 128L);
	printf("Directory of %s\n", buf);
	if (lastlock) UnLock(lastlock);
	lastlock=thislock;
	}
else UnLock(thislock);
*base = sc;
slen = strlen(base);
fi = base + slen + 1;
isadir = (fi[12] =='D');

if (!(((options & DIR_FILES) && !isadir) ||
	((options & DIR_DIRS) &&  isadir)))
		return;
if (isadir && !(options & DIR_NOCOL)) printf ("\23333m");
if (options & DIR_SHORT) {
	if (col==3 && slen>18) { printf("\n"); col = 0; }
	if (slen>18) { printf(" %-37s",base); col+= 2; }
		else { printf(" %-18s",base); col++; }
	if (col > 3) { printf("\n"); col=0; }
	}
else printf("   %-24s %s",base ,fi);
if (isadir && !(options & DIR_NOCOL)) printf("\2330m");
fi[16] = fi[21] = '\0';
bytes  += atol(fi+10);
blocks += atol(fi+17);
filecount++;
}

do_quit()
{
if (Src_stack) {
	Quit = 1;
	return(do_return());
	}
main_exit(0);
}

do_echo()
{
int i;

get_opt("n",&i);
for ( ; i<ac; i++) {
	printf("%s", av[i]);
	if (i != ac-1) printf(" ");
	}
if (!options) printf("\n");
return 0;
}

/* gets a line from file, joining two lines if the first ends in '\' */

char *myfgets(buf, buflen, file)
char *buf;
FILE *file;
{
char *bufptr=buf, *limit=buf+buflen;

do {
	if (fgets(bufptr, limit-bufptr, file)==NULL) {
		if (bufptr != buf)
			fprintf(stderr,"Source: file ends in '\\'\n");
		return NULL;
		}
	bufptr = bufptr+strlen(bufptr)-2;
    } while (*bufptr=='\\');
return buf;
}

do_source(str)
char *str;
{
register FILE *fi;
char buf[256];
int len;

if (Src_stack == MAXSRC) {
	ierror(NULL,217);
	return -1;
	}
if ((fi = fopen (av[1], "r")) == 0) { pError(av[1]); return -1;	}
set_var(LEVEL_SET, v_passed, next_word(next_word(str)));
++H_stack;
Src_pos[Src_stack] = 0;
Src_base[Src_stack] = (long)fi;
++Src_stack;
while (myfgets (buf, 256, fi) && !dobreak()) {
	len = strlen(buf);
	buf[len-1] = '\0';
	Src_pos[Src_stack - 1] += len;
	if (Verbose && !forward_goto) fprintf(stderr,"%s\n",buf);
	exec_command (buf);
	}
--H_stack;
--Src_stack;
if (forward_goto) ierror(NULL,501);
forward_goto = 0;
unset_level(LEVEL_LABEL + Src_stack);
unset_var(LEVEL_SET, v_gotofwd);
unset_var(LEVEL_SET, v_passed);
fclose (fi);
return 0;
}

/*
 * set process cwd name and $_cwd, if str != NULL also print it.
 */
do_pwd(str)
char *str;
{
char pwd[130];

PathName(Myprocess->pr_CurrentDir, pwd, 128L);
if (str) puts(pwd);
set_var(LEVEL_SET, v_cwd, pwd);
/* put the current dir name in our CLI task structure */
CtoBStr(pwd, Mycli->cli_SetName, 128L);
return 0;
}

/*
 * CD
 *
 * CD(str, 0)      -do CD operation.
 *
 */

do_cd(str)
char *str;
{
BPTR oldlock, filelock;

str=next_word(str);
if (!strcmp("..",str)) str="/";
filelock=Lock(str,ACCESS_READ);
if (filelock==NULL) { pError(str); return 20; }
if (!isdir(str)) { UnLock(filelock); ierror(str,212); return 20; }
if (oldlock=CurrentDir(filelock)) UnLock(oldlock);
do_pwd(NULL);
return 0;
}

do_mkdir()
{
register unsigned int i;
BPTR lock;

for (i=1; i<ac; ++i) {
	if (exists(av[i])) ierror(av[i],203);
	else if (lock=CreateDir(av[i])) UnLock (lock);
	else pError(av[i]);
	}
return 0;
}

do_mv()
{
char *dest, buf[256];
int dirflag;
register unsigned int i;

dirflag=isdir(dest=av[--ac]);
if (ac>3 && !dirflag) { ierror(dest, 507); return (-1); }
for (i=1; i<ac; ++i) {
	strcpy(buf, dest);
	if (dirflag) TackOn(buf, BaseName(av[i]));
	if (Rename(av[i], buf)==0)
		{ pError(av[i]); return -1; }
	}
return 0;
}

int dirstoo;

all_args(args, action, dirsflag)
char *args;
int (*action)();
{
unsigned int i;

get_opt(args, &i);
dirstoo=dirsflag;
for (; i<ac && !dobreak(); ++i)
	if (isdir(av[i])) {
		if (options & 1) recurse(av[i], action);
			else if (dirstoo) (*action)(av[i]);
		}
	else (*action)(av[i]);
return 0;
}

char *searchstring;

search_file(s)
char *s;
{
FILE *fopen(), *fi;
register char *p;
register unsigned int
	nocasedep, lctr, len, excl=((options & 16) !=0 ), yesno;
char buf[256], lowbuf[256], searchit[256], first;

if (strcmp("STDIN",s)) fi=fopen(s,"r"); else fi=stdin;
if (fi==NULL) { pError(s); return; }
nocasedep=!(options & 2);
lctr=0;
if (!(options & 32)) printf("Examining %s...\n",s);
strcpy(searchit,searchstring);
if (options & 4) strcat(searchit,"\n");
len=strlen(searchit);
if (nocasedep) strupr(searchit);
first=*searchit;
while (fgets(buf,256,fi) && !dobreak()) {
	lctr++;
	if (options & 4) yesno=compare_ok(searchit, buf, options & 2);
	else {
		if (nocasedep) {
			strcpy(lowbuf,buf);
			strupr(lowbuf);
			p=lowbuf;
			}
		else p=buf;
		while ((p=index(p,first)) && strncmp(p++,searchit,len)) ;
		yesno= (p!=NULL);
		}
	if (yesno ^ excl) {
			/* default: print line numbers */
		if (!(options & 8)) printf("%4d ",lctr);
		printf("%s",buf);
		}
	}
if (fi!=stdin) fclose (fi);
}

do_search()
{
searchstring=av[--ac];
all_args("rcwneq", search_file, 0);
return 0;
}

rm_file(file)
char *file;
{
if (has_wild) printf(" %s...",file);
if (options & 2) SetProtection(file,0L);
if (!DeleteFile(file)) pError (file); else if (has_wild) printf("Deleted\n");
}

do_rm()
{
all_args("rp", rm_file, 1);
return 0;
}

recurse(name, action)
char *name;
int (*action)();
{
register BPTR lock, cwd;
register FIB *fib=(FIB *)AllocMem((long)sizeof(FIB),MEMF_PUBLIC);
char *namecopy=malloc(256);

if (name[0] =='\0') return;
namecopy[0]=0;
if (lock=Lock(name,ACCESS_READ)) {
    cwd =CurrentDir(lock);
    if (Examine(lock, fib))
	while (ExNext(lock, fib) && !CHECKBREAK()) {
	    if (*namecopy) { (*action)(namecopy); namecopy[0]=0; }
	    if (fib->fib_DirEntryType>=0) recurse(fib->fib_FileName,action);
		else strcpy(namecopy,fib->fib_FileName);
	    }
    if (*namecopy) (*action)(namecopy);
    UnLock(CurrentDir(cwd));
    if (dirstoo) (*action)(name);
    }
else pError(name);
free(namecopy);
FreeMem(fib, (long)sizeof(FIB));
}

do_history()
{
register struct HIST *hist;
int i = H_tail_base;
int len = (av[1]) ? strlen(av[1]) : 0;

for (hist = H_tail; hist && !dobreak(); hist = hist->prev)
	if (len == 0 || !strncmp(av[1], hist->line, len))
		printf("%3d %s\n", i++, hist->line);
return 0;
}

do_mem()
{
long cfree, ffree;
extern long AvailMem();

Forbid();
cfree = AvailMem (MEMF_CHIP);
ffree = AvailMem (MEMF_FAST);
Permit();
if (ffree) printf ("FAST memory: %ld\nCHIP memory: %ld\n", ffree, cfree);
printf("Total  Free: %ld\n", cfree+ffree);
return 0;
}

do_forline()
{
char vname[33], buf[256];
register unsigned short lctr;
FILE *f;
char *cstr;

strcpy(vname,av[1]);
f=fopen(av[2],"r");
if (f==NULL) pError(av[2]);
lctr=0;
++H_stack;
cstr = compile_av (av, 3, ac, ' ', 0);
while (fgets(buf,256,f) && !dobreak()) {
	buf[strlen(buf)-1]='\0';	/* remove CR */
	lctr++;
	set_var(LEVEL_SET, vname, buf);
	sprintf(buf,"%d",lctr);
	set_var(LEVEL_SET, v_linenum, buf);
	exec_command(cstr);
	}
fclose(f);
--H_stack;
free (cstr);
unset_var (LEVEL_SET, vname);
unset_var (LEVEL_SET, v_linenum);
return 0;
}

do_fornum()
{
char vname[33], buf[16];
int n1, n2, step, i, verbose;
char *cstr;

get_opt("vs",&i);
verbose=(options & 1);
strcpy(vname,av[i++]);
n1=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
n2=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
if (options & 2) {
	step=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
	}
else
	step=1;
++H_stack;
cstr = compile_av (av, i, ac, ' ', 0);
for (i=n1; (step>=0 ? i<=n2 : i>=n2) && !CHECKBREAK(); i+=step) {
	if (verbose) fprintf(stderr, "fornum: %d\n", i);
	sprintf(buf,"%d",i);
	set_var (LEVEL_SET, vname, buf);
	exec_command(cstr);
	}
--H_stack;
free (cstr);
unset_var (LEVEL_SET, vname);
return 0;
}

/*
 * foreach var_name  ( str str str str... str ) commands
 * spacing is important (unfortunately)
 *
 * ac=0    1 2 3 4 5 6 7
 * foreach i ( a b c ) echo $i
 * foreach i ( *.c ) "echo -n "file ->";echo $i"
 */

do_foreach()
{
register int cstart, cend;
register char *cstr;
char **fav;
char vname[33];
int i, verbose;

get_opt("v",&i);
verbose=(options & 1);
strcpy(vname, av[i++]);
if (*av[i] == '(') i++;
cstart = i;
while (i<ac && *av[i] != ')') i++;
if (i > ac) { fprintf(stderr,"')' expected\n"); return 20; }
++H_stack;
cend = i;

fav = (char **)malloc(sizeof(char *) * (ac));
cstr = compile_av (av, cend + 1, ac, ' ', 0);

for (i = cstart; i < cend; ++i) fav[i] = av[i];

for (i = cstart; i<cend && !CHECKBREAK(); ++i) {
	set_var (LEVEL_SET, vname, fav[i]);
	if (verbose) fprintf(stderr, "foreach: %s\n", fav[i]);
	exec_command(cstr);
	}
--H_stack;
free (fav);
free (cstr);
unset_var (LEVEL_SET, vname);
return 0;
}

do_forever(str)
char *str;
{
int rcode = 0;
char *ptr = next_word(str);

++H_stack;
for (;;) {
	if (CHECKBREAK()) { rcode = 20; break; }
	if (exec_command (ptr) < 0) {
		str = get_var(LEVEL_SET, v_lasterr);
		rcode = (str) ? atoi(str) : 20;
		break;
		}
	}
--H_stack;
return rcode;
}

do_exec(str)
char *str;
{
return exec_command(next_word(str));
}

extern struct Window *w;
extern struct IntuitionBase *IntuitionBase;

do_window()
{
long x, y, maxwidth, maxheight, arg[5];
unsigned int i;
struct Screen *screen;
struct Window *window;

get_opt("slfbaq", &i);
if (options & 1)
	SizeWindow(w, (long)(w->MinWidth-w->Width), (long)(w->MinHeight-w->Height));
if (options & 2) {
	x=-w->LeftEdge;
	y=-w->TopEdge;
	MoveWindow(w,x,y);
	x=IntuitionBase->ActiveScreen->Width -w->Width;
	y=IntuitionBase->ActiveScreen->Height-w->Height;
	SizeWindow(w,x,y);
	}
if (options & 4) WindowToFront(w);
if (options & 8) WindowToBack(w);
if (options & 16) ActivateWindow(w);
if(ac >= 5) {
	for(i=1; i<5; i++) {
		arg[i] = myatoi(av[i],0,1023); if (atoierr) return 20;
		}
	maxwidth = w->WScreen->Width;
	maxheight= w->WScreen->Height;
	if (arg[3] > maxwidth - arg[1] || arg[4] > maxheight- arg[2]) {
		ierror(NULL, 500);
		return 20;
		}
	x = -w->LeftEdge;
	y = -w->TopEdge;
	MoveWindow(w, x, y);
	x = arg[3] - w->Width;
	y = arg[4] - w->Height;
	SizeWindow(w, x, y);
	x = arg[1];
	y = arg[2];
	MoveWindow(w, x, y);
	}
if(options & 32) {
	for (screen=IntuitionBase->FirstScreen; screen; screen=screen->NextScreen) {
	    printf("\nScreen \"%s\" (%d,%d,%dx%d):\n",
			screen->Title,
			screen->LeftEdge,
			screen->TopEdge,
			screen->Width,
			screen->Height
			);
		for (window=screen->FirstWindow; window; window=window->NextWindow) {
		printf("\tWindow\t\"%s\" (%d,%d,%dx%d)\n",
			window->Title,
			window->LeftEdge,
			window->TopEdge,
			window->Width,
			window->Height
			);
		}
	    }
	return 0;
	}
Delay(25L); /* pause 1/2 sec. before trying to print */
printf("\014");
return 0;
}

setsystemtime(ds)
struct DateStamp *ds;
{
struct timerequest tr;
long secs= ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;

if (OpenDevice(TIMERNAME, UNIT_VBLANK, &tr, 0L)) {
	fprintf(stderr,"Clock error: can't open timer device\n");
	return;
	}
tr.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
tr.tr_node.io_Message.mn_Node.ln_Pri = 0L;
tr.tr_node.io_Message.mn_Node.ln_Name = NULL;
tr.tr_node.io_Message.mn_ReplyPort = NULL;
tr.tr_node.io_Command = TR_SETSYSTIME;
tr.tr_time.tv_secs = secs;
tr.tr_time.tv_micro = 0L;
if (DoIO (&tr)) fprintf(stderr,"Clock error: can't talk to timer device\n");
CloseDevice (&tr);
}

char tday[10];

char *dates(dss)
struct DateStamp *dss;
{
static char timestr[40];
char tdate[10], ttime[10];
struct DateTime dt;
struct DateStamp *myds=&(dt.dat_Stamp);

dt.dat_Format=FORMAT_DOS;
dt.dat_StrDay=tday;
dt.dat_StrDate=tdate;
dt.dat_StrTime=ttime;
dt.dat_Flags=NULL;
myds->ds_Days=dss->ds_Days;
myds->ds_Minute=dss->ds_Minute;
myds->ds_Tick=dss->ds_Tick;
StamptoStr(&dt);
sprintf(timestr,"%s %s\n",tdate,ttime);
timestr[18]='\n';
timestr[19]='\0';	/* protection against bad timestamped files */
return timestr;
}

do_date()
{
struct DateStamp dss;
register unsigned short i;
struct DateTime dt;

dt.dat_Format=FORMAT_DOS;
if (ac==1) {
	DateStamp(&dss);
	printf("%s %s",tday,dates(&dss));
	}
else {
	DateStamp(& (dt.dat_Stamp));
	for (i=1; i<ac; i++) {
		dt.dat_StrDate=NULL;
		dt.dat_StrTime=NULL;
		dt.dat_Flags=DTF_FUTURE;
		if (index(av[i],':')) dt.dat_StrTime=av[i];
			else dt.dat_StrDate=av[i];
		if (StrtoStamp(&dt)) ierror(av[i],500);
		}
	setsystemtime( & (dt.dat_Stamp) );
	}
return 0;
}