/****************************************************************/
/*								*/
/*			      main.c				*/
/*			      DOS-C				*/
/*								*/
/*			Main IPL Functions			*/
/*								*/
/*			Copyright (c) 1991			*/
/*			Pasquale J. Villani			*/
/*			All Rights Reserved			*/
/*								*/
/* This file is part of DOS-C.					*/
/*								*/
/* DOS-C is free software; you can redistribute it and/or	*/
/* modify it under the terms of the GNU General Public License	*/
/* as published by the Free Software Foundation; either version	*/
/* 2, or (at your option) any later version.			*/
/*								*/
/* DOS-C is distributed in the hope that it will be useful, but	*/
/* WITHOUT ANY WARRANTY; without even the implied warranty of	*/
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See	*/
/* the GNU General Public License for more details.		*/
/*								*/
/* You should have received a copy of the GNU General Public	*/
/* License along with DOS-C; see the file COPYING.  If not,	*/
/* write to the Free Software Foundation, 675 Mass Ave,		*/
/* Cambridge, MA 02139, USA.					*/
/****************************************************************/


#define MAIN
#include "../../hdr/portab.h"
#include "globals.h"

/* $Logfile:   C:/dos-c/src/ipl/main.c_v  $ */
#ifndef IPL
static BYTE *mainRcsId = "$Header:   C:/dos-c/src/ipl/main.c_v   1.2   01 Sep 1995 17:44:38   patv  $";
#endif

/*
 * $Log:   C:/dos-c/src/ipl/main.c_v  $
 *	
 *	   Rev 1.2   01 Sep 1995 17:44:38   patv
 *	First GPL release.
 *	
 *	   Rev 1.1   30 Jul 1995 20:48:10   patv
 *	Eliminated version strings in ipl
 * 
 *    Rev 1.0   02 Jul 1995  8:25:52   patv
 * Initial revision.
 *
 */

COUNT ver(), help(), dir(), type(), prompt(), boot_kernel(), mon86();
COUNT unknown();
VOID init_ipl(), signon(), ipl();

struct table
{
	BYTE	*entry;
	COUNT	(*func)();
};

struct table  commands[] =
{
	{"?", help},
	{"help", help},
	{"ver", ver},
	{"dir", dir},
	{"type", type},
	{"prompt", prompt},
	{"boot", boot_kernel},
	{"", unknown}
};

static COUNT BlockIndex = 0;
static BYTE *tail;		/* an MS-DOS wart emulation		*/

static BYTE pr_string[LINESIZE];
static BYTE *dflt_pr_string = "\n$n$g ";
static BYTE *psignon = "\nDOS-C IPL v%d.%02d\n";
BYTE *id = "wb2gbf";
static BYTE *szDefaultKernel = "kernel.exe";


/* function protypes				*/
#ifdef PROTO
VOID signon(VOID);
VOID init_ipl(VOID);
VOID init_device(struct dhdr FAR *);
struct dhdr FAR *link_dhdr(struct dhdr FAR *, struct dhdr FAR *);
COUNT boot_kernel(VOID);
VOID ipl(VOID);
struct table *lookup(struct table *, BYTE *);
COUNT unknown(VOID);
COUNT ver(VOID);
COUNT help(VOID);
COUNT type(COUNT, BYTE *[]);
COUNT dir(COUNT, BYTE *[]);
#else
VOID signon();
VOID init_ipl();
VOID init_device();
struct dhdr FAR *link_dhdr();
COUNT boot_kernel();
VOID ipl();
struct table *lookup();
COUNT unknown();
COUNT ver();
COUNT help();
COUNT type();
COUNT dir();
#endif
VOID init_ipl(), signon(), ipl();


VOID main()
{
	BYTE szDrive[2] =
		{ '@', 0 };

#ifdef DEBUG
	MarkStack();
	printf("\n*** IPL started ***\nStack at 0x%04x:%04x\n",
		MarkSS, MarkSP);
#endif
	init_ipl();
#ifdef DEBUG
	MarkStack();
	printf("\n*** IPL initialized ***\nStack at 0x%04x:%04x\n",
		MarkSS, MarkSP);
#endif
	signon();
	szDrive[0] += BootDrive;
	printf("\nIPL Booting %s from drive %s\n", szDefaultKernel, szDrive);
	boot_kernel();
	ipl();
}

static VOID signon()
{
	printf(psignon, MAJOR_RELEASE, MINOR_RELEASE);
}


static VOID init_ipl()
{
	REG struct dhdr FAR *dhp = (struct dhdr FAR *)&nul_dev;
	REG COUNT i;
	struct dhdr FAR *link_dhdr();

	/* Initialize driver chain			*/
#ifdef DEBUG
	MarkStack();
	printf("Initialize driver chain\nStack at 0x%04x:%04x\n",
		MarkSS, MarkSP);
	printf("Device driver chain starts at 0x%04x:%04x\n",
		FP_SEG(dhp), FP_OFF(dhp));
#endif
	dhp = link_dhdr(dhp, (struct dhdr FAR *)&con_dev);
	dhp = link_dhdr(dhp, (struct dhdr FAR *)&blk_dev);
	syscon = (struct dhdr FAR *)&con_dev;

	/* Initialize the screen handler for backspaces			*/
#ifdef DEBUG
	MarkStack();
	printf("Initialize the screen handler for backspaces\n");
#endif
	scr_pos = 0;

	/* Initialize the file tables					*/
#ifdef DEBUG
	printf("Initialize the file tables\n");
#endif
	for(i = 0; i < NFILES; i++)
		f_nodes[i].f_count = 0;
	/* Log-in the default drive.					*/
	default_drive = 0;

	/* Initialzie the current directory structures			*/
	for(i = 0; i < NDEVS; i++)
		scopy("\\", blk_devices[i].dpb_path);

	/* Initialze the disk buffer management functions		*/
	init_buffers();

	/* Now to initialize all special flags, etc.			*/
	mem_access_mode = FIRST_FIT;
	break_ena = TRUE;
	verify_ena = FALSE;
	InDOS = 0;
	version_flags = 0;

	/* Figure out 'A' or 'C' drive					*/
	if(BootDrive != 0)
		BootDrive = 3;
	else
		BootDrive = 1;
}


VOID init_device(dhp)
struct dhdr FAR *dhp;
{
	request rq;

	rq.r_unit = 0;
	rq.r_status = 0;
	rq.r_command = C_INIT;
	rq.r_length = sizeof(request);
#ifdef DEBUG
	printf("init_device: Initializing device with packet at 0x%04x:%04x\n",
		FP_SEG(&rq), FP_OFF(&rq));
#endif
	execrh((request FAR *)&rq, dhp);
#ifdef DEBUG
	printf("init_device: execrh returned with status = 0x%04x\n",
		rq.r_status);
#endif

	/* check for a block device and update device control block	*/
	if(!(dhp -> dh_attr & ATTR_CHAR) && (rq.r_nunits != 0))
	{
		REG COUNT Index;

		for(Index = 0; Index < rq.r_nunits; Index++, BlockIndex++)
		{
#ifdef DEBUG
			printf("init_device: building blk_devices[%d]\n",
				lastdrive);
#endif
			blk_devices[lastdrive].dpb_unit = lastdrive;
			blk_devices[lastdrive].dpb_subunit = Index;
			blk_devices[lastdrive].dpb_device = dhp;
			blk_devices[lastdrive].dpb_flags = M_CHANGED;
			++lastdrive;
		}
	}
#ifdef DEBUG
	printf("init_device: complete.\n");
#endif
}


struct dhdr FAR *link_dhdr(lp, dhp)
struct dhdr FAR *dhp, FAR *lp;
{
	lp -> dh_next = dhp;
#ifdef DEBUG
	printf("link_dhdr: initializing device at 0x%04x:%04x\n",
		FP_SEG(dhp), FP_OFF(dhp));
#endif
	init_device(dhp);
#ifdef DEBUG
	printf("link_dhdr: init_device complete\n");
#endif
	return dhp;
}


static COUNT boot_kernel()
{
	COUNT rc;
	exec_blk exb;

	/* Test for user break				*/
	if(con_break())
		return TRUE;
	printf("\nBooting DOS-C ");

#ifndef IPLDBG
	/* If not - initialize the exec block		*/
	/* and go for it!				*/
	exb.exec.env_seg = 0;
	exb.exec.cmd_line = "";
	exb.exec.fcb_1 = exb.exec.fcb_2 = (fcb far *)0;
	rc = DosExec(P_WAIT, (exec_blk far *)&exb, (BYTE far *)szDefaultKernel);

	/* if we're here, unable to load the kernel, so	*/
	/* give the user the reason and exit		*/
	printf("IPL cannot load kernel\n\n");
	switch(rc)
	{
	case DE_FILENOTFND:
		printf("File %s not found\n", szDefaultKernel);
		break;

	case DE_INVLDDATA:
		printf("Inavlid data\n");
		break;

	default:
		printf("Unknown reason (rc = %d)\n", rc);
		break;
	}
#endif
	return FALSE;
}


static VOID ipl()
{
	register struct table *p;
	register BYTE *lp;
	struct table *lookup();
	BYTE *scan(), *skipwh();
	static COUNT argc;
	static BYTE *argv[16];
	static BYTE args[16][LINESIZE];

	scopy(dflt_pr_string, pr_string);
	for(;;)
	{
		put_prompt(pr_string);
		kb_buf.kb_size = LINESIZE - 1;
		kb_buf.kb_count = 0;
		sti((keyboard far *)&kb_buf);
		kb_buf.kb_buf[kb_buf.kb_count] = '\0';
		for(argc = 0; argc < 16; argc++)
		{
			argv[argc] = (BYTE *)0;
			args[argc][0] = '\0';
		}
		lp = scan(kb_buf.kb_buf, args[0]);
		argv[0] = args[0];
		/* this kludge is for an MS-DOS wart emulation */
		tail = skipwh(lp);
		for(argc = 1; ; argc++)
		{
			lp = scan(lp, args[argc]);
			if(*args[argc] == '\0')
				break;
			else
				argv[argc] = args[argc];
		}
		if(*argv[0] != '\0')
		{
			p = lookup(commands, argv[0]);
			(*(p -> func))(argc, argv);
		}
	}
}


COUNT prompt(argc, argv)
COUNT argc;
BYTE *argv[];
{
	if(argc == 1)
		scopy(dflt_pr_string, pr_string);
	else
	{
		pr_string[0] = '\n';
		/* should be */
		/* scopy(argv[1], &pr_string[1]); */
		/* but to emulate an MS-DOS wart, is */
		scopy(tail, &pr_string[1]);
	}
	return TRUE;
}


/* put_prompt - print prompt obeying $x commands */
COUNT put_prompt(fmt)
register BYTE *fmt;
{
	register BYTE c;
	BYTE *s;

	while ((c = *fmt++) != '\0')
	{
		if (c != '$')
		{
			put_console(c);
			continue;
		}
		switch (c = *fmt++)
		{
		case 'p':
			put_console('A' + default_drive);
			put_console(':');
			for(s = blk_devices[default_drive].dpb_path; *s != '\0'; s++)
				put_console(*s);
			continue;

		case 'n':
			put_console('A' + default_drive);
			continue;

		case 'g':
			put_console('>');
			continue;

		case 'l':
			put_console('<');
			continue;

		case 'b':
			put_console('|');
			continue;

		case 'e':
			put_console('=');
			continue;

		default:
			put_console(c);
			continue;
		}
	}
	return TRUE;
}


struct table *lookup(p, token)
struct table *p;
BYTE *token;
{
	while(*(p -> entry) != '\0')
	{
		if(strcmp(p -> entry, token) == 0)
			break;
		else
			++p;
	}
	return p;
}


COUNT unknown()
{
	printf("\nBad command or file name");
	return FALSE;
}


COUNT ver()
{
	printf(psignon, MAJOR_RELEASE, MINOR_RELEASE);
	return TRUE;
}


COUNT help()
{
	printf("\nSorry, help is not available");
	return TRUE;
}


COUNT type(argc, argv)
COUNT argc;
BYTE *argv[];
{
	COUNT fd;
	BYTE c;

	if(argc != 2)
	{
		printf("\nInvalid number of parameters\n");
		return FALSE;
	}
	if((fd = dos_open((BYTE far *)argv[1], 0)) < 0)
	{
		printf("\nFile not found");
		return FALSE;
	}
	else
		printf("\n");
	while(dos_read(fd, (BYTE far *)&c, 1) == 1)
		printf("%c", c);
	dos_close(fd);
	return TRUE;
}


COUNT dir(argc, argv)
COUNT argc;
BYTE *argv[];
{
	REG struct f_node *fnp;
	BYTE buf[13];
	COUNT count = 0;


	if(argc == 1)
	{
		if((fnp = dir_open((BYTE FAR *)".")) == (struct f_node *)0)
			goto quit;
	}
	else
	{
		if((fnp = dir_open((BYTE FAR *)argv[1])) == (struct f_node *)0)
			goto quit;
	}
	while(dir_read(fnp) == sizeof(struct dirent))
	{
		if(fnp -> f_dir.dir_name[0] != '\0' && fnp -> f_dir.dir_name[0] != DELETED)
		{
			WORD hour = TM_HOUR(fnp -> f_dir.dir_time);

			bcopy(fnp -> f_dir.dir_name, &buf[0], 8);
			buf[8] = ' ';
			bcopy(fnp -> f_dir.dir_ext, &buf[9], 3);
			buf[12] = '\0';
			printf("\n   %s %-10ld  %-2d-%-02d-%-02d  %-2d:%-02d%c",
				buf, fnp -> f_dir.dir_size,
				DT_MONTH(fnp -> f_dir.dir_date),
				DT_DAY(fnp -> f_dir.dir_date),
				(DT_YEAR(fnp -> f_dir.dir_date) + 1980) % 100,
				hour > 12 ? hour - 12 : (hour == 0) ? 12 : hour,
				TM_MIN(fnp -> f_dir.dir_time),
				hour >= 12 ? 'p' : 'a');
			++count;
		}
	}
	printf("\n%-10d file(s)\n", count);
quit:	dir_close(fnp);
	return TRUE;
}