/* NewROMs (C)2002 B Y T E  THE BIG  O  N  E
*
* This program examines the files listinfo_new.txt and listinfo_old.txt
* (the output from a -listinfo from two versions of mame), compares the
* two files, and generates a download list of roms that changed with the
* new version of Mame.
*
*
* Written Feb 9, 2002 - Feb 18, 2002
* By Darryl P. Hirschler
* dphirschler@hotmail.com
*
* ChangedROMs Ver 1.00 - Initial release (beta)
*   - list changed roms
*   - list removed roms
*   - check for presence of changed rom file
*
* Ver 1.10 - bug fix
*   - fixed backwards colors on action items.
*
* Ver 1.50 - enhancements - trying to make it "front-end friendly"
*   - removed the -S arg.
*   - more filename options including: rfile_new, rfile_old, html_file (from command line).
*   - somehow add a meaningful title to the html file.
*   - should count roms not present better.
*
* Ver 2.00 - add more enhancements.  heading towards whole enchilada
*   - add 1-byte flag to struct (new, removed, changed, present)
*   - keep database of both old (shortened to only changed roms) and new (shortened to only new roms) listinfo files.
*   - as a side effect of the new enchancements, the code got a little cleaner, the logic was spelled out better, and the discovery that previous versions' output was incomplete(!)
*
* NewROMs Ver 3.00 - the whole enchilada
*   - encompass NewROMs' duties and assume new name.  Move to ver 3.00 to avoid confusion with existing NewROMs ver 2.00.
*
* Ver 3.10 - major bug fix
*   - bug fix.  Was including good roms as "removed".  I solved a major accounting problem and also removed the "removed roms" code.
*
* Ver 3.20 - minor enhancements
*   - need to add quick jumps to new and changed roms
*   - it was counting needed new roms wrong
*   - cosmetic changes, cleaned up text output.
* 
* Future enhancements to consider
*   o should really have two directories to look into for existing roms
*   o I may put "removed roms" code back in as is seems removed roms are still getting counted.
*   o routine that searches for matching rominfo strings indicating a "renamed" rom.  Is this even useful or desired?
*   o consider creating bat file for deleting and renaming.
*   o add the rom filesize information back to the structure to eventually show the romfile size in the html document.
*
* Program limitations:
* NewROMs supports up to 20,000 games (defined as MAXGAMES).
* Each game can have up to 100 rom files (defined in the struct temprom).
* If temprom is ever increased or changed in any way, check the rominfo string length defined in the game struct
*
*/

#define PROGNAME	NewROMs
#define PROGVER     3.20
#define MAXGAMES    20000	/* max number of games (increase this number if MAME ever supports more). */

#define BYTE unsigned char
#define WORD unsigned int

/*flags */
// #define RESOURCE     0x01
#define GAME         0x02
#define SHORT        0x04
#define PATH         0x10	/* rompath present in command line */

// flag |= GAME;		/* turn flag on */
// flag &= ~GAME;		/* turn flag off */

#define RESOURCE    0x01
#define NEW         0x02
#define CHANGED     0x04
#define PRESENT     0x10
#define RENAMED     0x20
#define REMOVED     0x40

#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>
#include <stdlib.h>
#include <dir.h>

void helpme(void);	/* help screen */
void wr(int, BYTE[]);	/* writes data to a file */
void dit(BYTE *, BYTE *, BYTE *, BYTE *);	/* do it - this is the meat of the program */
void filereaderror(BYTE[]);
int  getachar(BYTE *, int);	/* gets a char from a 4k buffer or from disk */
int  getline(BYTE *, int);
void perr(BYTE[]);	/* print error message */
int  match(BYTE[], BYTE[]);	// string matching
long int filesize(BYTE[]);	// returns the filesize
int pathexists(BYTE[]);	// returns 1 if path exists
int  join(BYTE *, BYTE *, BYTE *, BYTE *, BYTE *);	// joins 4 strings, returns length
BYTE *readkey(BYTE *, BYTE, BYTE);	/* reads what is between keyopen and keyclos */
int keyfits(BYTE *, BYTE *, BYTE *);	/* checks line against key */
int subkeyfits(BYTE *, BYTE *, BYTE *);	/* looks for subkey in line*/

// these functions not used
// int  str_count_to(BYTE *, BYTE);	/* counts characters in line until character c occurs */
// int  strfind(BYTE *, BYTE *);	// finds a string within a line


int  ii=4096;	// 4k buffer index
int  fh_read_new;	// file handle for read file
int  fh_read_old;	// file handle for read file
BYTE flag=0x00;	// flag byte
BYTE keyopen='[';
BYTE keyclos=']';
BYTE rompath[256] = "";

struct
{
	BYTE dir[9];
	BYTE name[50];
	BYTE rominfo[3400]; // this number will need to be increased if anything in temprom ever increases.
	// long int romsize;
	BYTE flag;
} game[MAXGAMES];


void main(BYTE argc, BYTE *argv[])
{
	int  a;	//counter
	BYTE rfile_new[256]="listinfo_new.txt";	// readfile - the default datafile (new mame -listinfo)
	BYTE rfile_old[256]="listinfo_old.txt";	// readfile - the default datafile (old mame -listinfo)
	BYTE html_file[256]="newroms.htm";	// the default output file newroms.htm

	printf("NewROMs start ('-?' for help)...\n");

	printf("args: ");
	for(a=1; a<argc; a++)
	{
		printf("[%s]", argv[a]);
	}
	printf("\n");

	for(a=1; a<argc; a++) // Read all args, set appropriate flags, then set the path names
	{
		if(match("-", argv[a]) && strlen(argv[a])==2)	// found an argument
		{
			if(match(argv[a],"-?") || match(argv[a],"-H") || match(argv[a],"-h")) helpme();
		}
		else
		{
			if(match(argv[a],"N=") || match(argv[a],"n=")) // rfile_new
			{
				strset(rfile_new,0);
				strcpy(rfile_new, argv[a]+2);
			}
			if(match(argv[a],"O=") || match(argv[a],"o=")) // rfile_old
			{
				strset(rfile_old,0);
				strcpy(rfile_old, argv[a]+2);
			}
			if(match(argv[a],"W=") || match(argv[a],"w=")) // html_file
			{
				strset(html_file,0);
				strcpy(html_file, argv[a]+2);
			}
			if(match(argv[a],"R=") || match(argv[a],"r=")) // rompath
			{
				strset(rompath,0);
				strcpy(rompath, argv[a]+2);

				if(rompath[strlen(rompath)-1] != '\\') // added a backslash '\' to the path if not already there
				{
					join(rompath, rompath, "\\", "", "");
					// printf("corrected path: [%s]\n", rompath);
					printf("\n");
					flag |= PATH;
				}
			}
		}
	}
	dit(rompath, rfile_new, rfile_old, html_file);

	printf("NewROMs end.\n");
}

void dit(BYTE *rompath, BYTE *rfile_new, BYTE *rfile_old, BYTE *html_file)	/* do it */
{
	BYTE integer[33]="";
	BYTE line[4096]="";
	BYTE temp1[4096]="";
	int  err;	// errors
	int  fh_write;	// file handle for write file
	int  counter_ogames=0;
	int  counter_ngames=0;
	int  counter_newgames=0;
	int  counter_changed=0;
	int  counter_resource=0;
	int  counter_renamed=0;
	int  counter_present=0;
	int  counter_roms;
	int  counter_removed=0;
	int  len;		// string length
	int  a;	// counter for sorting
	int  b;	// counter for sorting
	int  c=0;	// counter for roms not present

	struct
	{
		BYTE name[13];
		BYTE size[9];
		BYTE crc[9];
	} temprom[100]; // no more than 100 roms per game (increase this if a game has more than 100)


	/* read old file */
	printf("opening readfile: %s\n", rfile_old);
	if((fh_read_old = _open(rfile_old,O_RDONLY|O_BINARY)) == -1)	perr("readfile open error");

	printf("Gathering data...\n");

	/* read the file here */
	while(getline(line,fh_read_old))
	{
		if(match("game (", line))
		{
			counter_roms=0;
			flag |= GAME;	// on
			/* reset struct */
			strset(game[counter_ogames].dir,0);
			strset(game[counter_ogames].name,0);
		}
		if(match("resource (", line))
		{
			counter_roms=0;
			flag |= GAME;	// on
			game[counter_ogames].flag |= RESOURCE;	// on
			/* reset struct */
			strset(game[counter_ogames].dir,0);
			strset(game[counter_ogames].name,0);
		}

		if(flag&GAME)
		{
			if(keyfits(line, "\tname %s", temp1))
				strncpy(game[counter_ogames].dir, temp1, 8);

			if(keyfits(line, "\tdescription \"%s\"", temp1))
				strncpy(game[counter_ogames].name, temp1, 49);

			// This is the beginning of where the magic happens.  This routine needs to gather
			// the rom name, size, and crc and put it in a temporary struct.  There could be
			// several rom lines, so when they are done, they will be sorted, compressed, and 
			// added to the main struct as a single string.  That string will later be compared
			// to its counterpart in the listinfo_new file.  If the string differs, then it is
			// a changed rom.

			if(keyfits(line, "\trom ([%s])", temp1))
			{
				if(keyfits(line, "\trom ([ name %s ])", temp1))
					strncpy(temprom[counter_roms].name, temp1, 12);
				if(keyfits(line, "\trom ([ size %s ])", temp1))
					strncpy(temprom[counter_roms].size, temp1, 8);
				if(keyfits(line, "\trom ([ crc %s ])", temp1))
					strncpy(temprom[counter_roms].crc, temp1, 8);
				counter_roms++;
			}

			if(match(")", line))
			{
				flag &= ~GAME;	// flag off

				strset(game[counter_ogames].rominfo,0);

				// sort the rom info
				for(a=0; a<counter_roms; a++)
				{
					for(b=a+1; b<counter_roms; b++)
					{
						if(strcmpi(temprom[b].name, temprom[a].name) < 0)
						{
							temprom[counter_roms+1]=temprom[a];
							temprom[a]=temprom[b];
							temprom[b]=temprom[counter_roms+1];
						}
					}
					// construct a string
					join(temp1, temprom[a].name, " ", temprom[a].size, " ");
					join(temp1, temp1, temprom[a].crc, "\n", "");
					strcat(game[counter_ogames].rominfo,temp1);
				}
				for(a=0; a<100; a++) // reset the temp struct.  This may not be necessary, but I like to be safe.
				{
					strset(temprom[a].name,0);
					strset(temprom[a].size,0);
					strset(temprom[a].crc,0);
				}
				// printf("%s\n------------\n%s\n", game[counter_ogames].dir, game[counter_ogames].rominfo);
				printf("%05d [%8s]\r", counter_ogames+1, game[counter_ogames].dir);
				counter_ogames++;
				counter_roms=0;

				// if(counter_ogames==2) exit(0); // end after two games (for test purposes)
			}
		}
	}
	_close(fh_read_old);
	printf("\n\n");
	ii=4096;	// reset 4k buffer index
	// counter_ngames=counter_ogames;

	/* read new file */
	printf("opening readfile: %s\n", rfile_new);
	if((fh_read_new = _open(rfile_new,O_RDONLY|O_BINARY)) == -1)	perr("readfile open error");

	printf("Gathering data...\n");

	/* read the file here */
	while(getline(line, fh_read_new))
	{
		c = (counter_ngames+counter_ogames);	// this is important
		if(match("game (", line) || match("resource (", line))
		{
			counter_roms=0;
			flag |= GAME;	// on
		}

		if(flag&GAME)
		{
			if(keyfits(line, "\tname %s", temp1))
				strncpy(game[c].dir, temp1, 8);

			if(keyfits(line, "\tdescription \"%s\"", temp1))
				strncpy(game[c].name, temp1, 49);

			// More magic happens here.  This is where the incoming new rominfo will be stuck into a temporary
			// structure, sorted, and compared to info already stored.
			if(keyfits(line, "\trom ([%s])", temp1))
			{
				if(keyfits(line, "\trom ([ name %s ])", temp1))
					strncpy(temprom[counter_roms].name, temp1, 12);
				if(keyfits(line, "\trom ([ size %s ])", temp1))
					strncpy(temprom[counter_roms].size, temp1, 8);
				if(keyfits(line, "\trom ([ crc %s ])", temp1))
					strncpy(temprom[counter_roms].crc, temp1, 8);
				counter_roms++;
			}

			if(match(")", line))
			{
				strset(game[c].rominfo,0);

				// sort the rom info
				for(a=0; a<counter_roms; a++)
				{
					for(b=a+1; b<counter_roms; b++)
					{
						if(strcmpi(temprom[b].name, temprom[a].name) < 0)
						{
							temprom[counter_roms+1]=temprom[a];
							temprom[a]=temprom[b];
							temprom[b]=temprom[counter_roms+1];
						}
					}
					// construct a string
					join(temp1, temprom[a].name, " ", temprom[a].size, " ");
					join(temp1, temp1, temprom[a].crc, "\n", "");
					strcat(game[c].rominfo,temp1); // game[c] is a temporary placeholder
				}

				// printf("%s\n------------\n%s\n", game[a].dir, game[a].rominfo);

				b=counter_ogames;
				for(a=0; a<b; a++)	// compare the temporarily stored record (c) with all records of old games stored
				{
					if(strcmpi(game[a].dir, game[c].dir) == 0)	// Found a matching name.
					{
						// printf("%8s %8s", game[a].dir, game[c].dir);
						// Now check to see if the roms are different
						// printf("\n[%s]\n[%s]\n", game[a].rominfo, game[c].rominfo); exit(0);// test line
						if(strcmpi(game[a].rominfo, game[c].rominfo) == 0) // no changes
						{
							game[a]=game[counter_ogames-1];	// remove record by copying last record over it
							if(counter_ngames)
							{
								game[counter_ogames-1]=game[c-1];  // put last ngame in this place.
								game[c-1]=game[c+1];	// remove last record by copying empty record over it
							}
							else game[counter_ogames-1]=game[c+1];  // erase it
							counter_ogames--;  // there is now one less record stored.
						}
						else  // it's different
						{
							printf("%05d [%8s]\r", counter_ngames+1, game[c].dir);
							
							// strset(game[a].name,0);
							strncpy(game[a].name, game[c].name, 49); // copy over the new name
							// strset(game[a].rominfo,0);
							game[a].flag |= CHANGED; // on
						}
						a=b;	// exit the loop since it already found a match
					}
				}

				if(a==b) // it never found a match.  It must be a new game.
				{
					game[c].flag |= NEW; // on
					// game[c]=game[c+1];	// remove last record (the new game)
					printf("%05d [        ][%8s]\r", counter_ngames+1, game[c].dir);
					counter_ngames++;
				}

				// reset counters and temp struct
				for(a=0; a<counter_roms; a++) // reset the temp struct.  This may not be necessary, but I like to be safe.
				{
					strset(temprom[a].name,0);
					strset(temprom[a].size,0);
					strset(temprom[a].crc,0);
				}			
				counter_roms=0;	// reset counter
				flag &= ~GAME;	// flag off
			}
		}
	}
	_close(fh_read_new);

	printf("\n\n");

	/* sort structure here */
	c = (counter_ngames+counter_ogames);
	printf("Sorting the list...\n");
	for(a=0; a<c; a++)
	{
		for(b=a+1; b<c; b++)
		{
			if(strcmpi(game[b].name, game[a].name) < 0)
			{
				game[c+1]=game[a];
				game[a]=game[b];
				game[b]=game[c+1];
			}
		}
		if(game[a].flag&CHANGED) counter_changed++;
		else if(game[a].flag&NEW) counter_newgames++;
		printf("%05d [%8s]\r", a+1, game[a].dir);
	}
	printf("\n\n");
	printf("counter_ogames=%d\n", counter_ogames);
	printf("counter_ngames=%d\n", counter_ngames);
	printf("\n");

	/* write table file here */
	_fmode=O_TEXT;
	printf("opening writefile: %s\n", html_file);
	if((fh_write = creat(html_file, S_IREAD|S_IWRITE)) == -1) perr("writefile open error");

	printf("Writing html file...\n");

	wr(fh_write, "<HTML>");
	wr(fh_write, "<HEAD>");
	wr(fh_write, "<TITLE>NewROMs</TITLE>");
	wr(fh_write, "</HEAD>");
	wr(fh_write, "<BODY link=\"#0000ff\" vlink=\"#999999\" alink=\"#ff0000\">");
	wr(fh_write, "<font face=\"arial\" size=1>");
	wr(fh_write, "<center><font size=3><b>MAME <a href=\"#new\"><font color=\"#000000\">new</font></a> and <a href=\"#changed\"><font color=\"#000000\">changed</font></a> roms download list</b></font></center>");

	// attempt to give some sort of meaningful identity to this html file
	join(line, "<center><font size=1>File1: ", rfile_old, " &nbsp; File2: ", rfile_new);
	join(line, line, "</font></center><p>", "", "");
	wr(fh_write, line);

	// ChangedROMs section
	wr(fh_write, "<a name=\"#changed\"></a>");
	wr(fh_write, "<table width=\"100%\" border=0 cellspacing=0 cellpadding=0><tr><td bgcolor=\"#999999\"><center><font size=2 color=\"#ffffff\"><b>Changed roms</b></font></center></td></tr></table>");
	wr(fh_write, "<table width=\"100%\" border=0 cellspacing=0 cellpadding=10><tr><td>");
	wr(fh_write, "<font face=\"arial\" size=1>");

	b=0;	// counts total records printed.
	c=(counter_ogames+counter_ngames);
	for(a=0; a<c; a++)
	{
		strset(line,0);

		// check for presence of romfile
		join(temp1, rompath, game[a].dir, ".zip", "");
		// printf("%s\n",temp1);

		if(game[a].flag&CHANGED) // must be a changed rom
		{
			if(filesize(temp1)) // black or red text?
			{
				strcpy(line, "<font color=\"#000000\">"); // make it black
				strcat(line, ltoa(b+1, integer, 10)); // the number (no color)
				strcat(line, "</font>");
			}
			else
			{
				strcpy(line, "<font color=\"#FF0000\">"); // make it red (action item)
				strcat(line, ltoa(b+1, integer, 10)); // the number
				strcat(line, "</font>");
				// if(strcmp(game[a].rominfo,"") == 0) c++;
			}
			if(filesize(temp1)) // does the file exist?
				game[a].flag |= PRESENT;	// on

			strcat(line, " <a target=\"_blank\" href=\"http://www.mame.dk/download/rom/");
			strcat(line, game[a].dir);
			strcat(line, "\">");
			strcat(line, game[a].name);
			if(game[a].flag&CHANGED) strcat(line, "!");	// testing to see if the flag works
			strcat(line, "</a><br>");

			b++;
			wr(fh_write, line);
			if(b == (counter_changed >> 1)) // split into two columns
			{
				wr(fh_write, "</font>");
				wr(fh_write, "</td><td>");
				wr(fh_write, "<font face=\"arial\" size=1>");
			}
		}

		if(game[a].flag&RESOURCE) counter_resource++;
		if(game[a].flag&RENAMED) counter_renamed++;
		if(game[a].flag&PRESENT) counter_present++;
	}
	wr(fh_write, "</font>");
	wr(fh_write, "</td></tr></table>\n");

	// Changed and removed roms totals
	strset(line,0);
	wr(fh_write, "<font face=\"arial\" size=2><b>Totals</b>");
	wr(fh_write, "<table width=\"80%\" border=0 cellspacing=0 cellpadding=0>");

	wr(fh_write, "<tr>");
	strcpy(line, "<td width=\"50%\"><font face=\"arial\" size=2>Changed roms/resources: ");
	strcat(line, ltoa(counter_changed, integer, 10));
	strcat(line, "</font></td>");
	wr(fh_write, line);

	strset(line,0);
	strcpy(line, "<td width=\"50%\"><font face=\"arial\" size=2>Needed: ");
	if((counter_changed - counter_present) > 0)
		strcat(line, "<font color=\"#FF0000\">");
	else strcat(line,"<font color=\"#000000\">");
	// strcat(line, ltoa(c, integer, 10));
	strcat(line, ltoa(counter_changed - counter_present, integer, 10));
	strcat(line, "</font></font></td>");
	wr(fh_write, line);
	wr(fh_write, "</tr>");

	strset(line,0);
	wr(fh_write, "<tr>");
	strcpy(line, "<td width=\"50%\"><font face=\"arial\" size=2>Removed roms/resources: ");
	strcat(line, ltoa(counter_removed, integer, 10));
	strcat(line, "</font></td>");
	wr(fh_write, line);

	wr(fh_write, "<td width=\"50%\"><font face=\"arial\" size=2>&nbsp;</font></td>");
	wr(fh_write, "</tr>");
	wr(fh_write, "</td></tr></table><p>");


	counter_present=0;

	// NewROMs section
	wr(fh_write, "<a name=\"#new\"></a>");
	wr(fh_write, "<table width=\"100%\" border=0 cellspacing=0 cellpadding=0><tr><td bgcolor=\"#999999\"><center><font size=2 color=\"#ffffff\"><b>New roms</b></font></center></td></tr></table>");
	// wr(fh_write, "<center><font size=2><b>New roms</b></font></center>");
	wr(fh_write, "<table width=\"100%\" border=0 cellspacing=0 cellpadding=10><tr><td>");
	wr(fh_write, "<font face=\"arial\" size=1>");

	b=0;
	for(a=0; a<c; a++)
	{
		strset(line,0);

		// check for presence of romfile
		join(temp1, rompath, game[a].dir, ".zip", "");
		// printf("%s\n",temp1);

		if(game[a].flag&NEW) // must be a new rom
		{
			if(filesize(temp1)) // does the file exist?
			{
				strcpy(line, "<font color=\"#000000\">"); // make it black
				strcat(line, ltoa(b+1, integer, 10)); // the number (no color)
				strcat(line, "</font>");
				game[a].flag |= PRESENT;	// on
				counter_present++;
			}
			else
			{
				strcpy(line, "<font color=\"#FF0000\">"); // make it red (action item)
				strcat(line, ltoa(b+1, integer, 10)); // the number
				strcat(line, "</font>");
				// if(strcmp(game[a].rominfo,"") == 0) c++;
			}
			strcat(line, " <a target=\"_blank\" href=\"http://www.mame.dk/download/rom/");
			strcat(line, game[a].dir);
			strcat(line, "\">");
			strcat(line, game[a].name);
			if(game[a].flag&NEW) strcat(line, "!");	// testing to see if the flag works
			strcat(line, "</a><br>");

			b++;
			wr(fh_write, line);
			if(b == (counter_ngames >> 1)) // split into two columns
			{
				wr(fh_write, "</font>");
				wr(fh_write, "</td><td>");
				wr(fh_write, "<font face=\"arial\" size=1>");
			}
		}
		// if(game[a].flag&NEW) counter_newgames++;
	}
	wr(fh_write, "</font>");
	wr(fh_write, "</td></tr></table>\n");


	// New roms totals
	strset(line,0);
	wr(fh_write, "<font face=\"arial\" size=2><b>Totals</b>");
	wr(fh_write, "<table width=\"80%\" border=0 cellspacing=0 cellpadding=0>");

	wr(fh_write, "<tr>");
	strcpy(line, "<td width=\"50%\"><font face=\"arial\" size=2>New roms/resources: ");
	strcat(line, ltoa(counter_newgames, integer, 10));
	strcat(line, "</font></td>");
	wr(fh_write, line);

	strset(line,0);
	strcpy(line, "<td width=\"50%\"><font face=\"arial\" size=2>Needed: ");
	if((counter_newgames - counter_present) > 0)  // this number is wrong
		strcat(line, "<font color=\"#FF0000\">");
	else strcat(line,"<font color=\"#000000\">");
	// strcat(line, ltoa(c, integer, 10));
	strcat(line, ltoa(counter_newgames - counter_present, integer, 10));  // this number is wrong
	strcat(line, "</font></font></td>");
	wr(fh_write, line);
	wr(fh_write, "</tr>");

	wr(fh_write, "</table>");
	wr(fh_write, "</font>");

	wr(fh_write, "</font>");
	wr(fh_write, "</BODY>");
	wr(fh_write, "</HTML>");

	_close(fh_write);
	printf("\n");
}

int subkeyfits(BYTE *line, BYTE *key, BYTE *subkey)
{
	int llen;	// length of line
	int a;
	int b=0;
	int c=0;

	llen=strlen(line);

	for(a=0; a<llen; a++)
	{
		if(key[b] == '%' && key[b+1] == 's')	// found %s
		{
			b += 2;
			while(line[a] != key[b])
			{
				subkey[c++]=line[a++];
				if(a>llen) return(0);
			}
			subkey[c]=0;
		}
		if(line[a] == key[b])
		{
			b++;	// a match
		}
		else
		{
			b=0;
			c=0;
		}
	}
	return(strlen(subkey));
}

int keyfits(BYTE *line, BYTE *key, BYTE *string)
/* checks line against key */
{
	int llen;	// length of line
	int klen;	// length of key
	int slen;	// length of subkey
	int a;
	int b=0;
	int c=0;
	int d=0;
	BYTE subkey[1024]="";

	llen=strlen(line);
	klen=strlen(key);

	strset(string,0);
	for(a=0; a<llen; a++)
	{
		if(key[b] == keyopen)	// found keyopen
		{
			b++;
			while(key[b] != keyclos)
			{
				subkey[d++]=key[b++];
			}
			subkey[d]=0;	// store subkey until finished
			// resume search
			a = (llen-(klen-b))+1;	// the rest of key
			b++;
		}
		if(key[b] == '%' && key[b+1] == 's')	// found %s
		{
			b += 2;
			while(line[a] != key[b])
			{
				string[c++]=line[a++];
				if(a>llen) return(0);
			}
			string[c]=0;
		}
		if(line[a] == key[b]) b++;	// still a match
		else return(0);
	}
	if(strlen(subkey))
	{
		subkeyfits(line, subkey, string);
	}
	return(strlen(string));
}

BYTE *readkey(BYTE *cline, BYTE keyop, BYTE keycl)
/* reads what is between keyopen and keyclos */
{
	BYTE key[1024]="";
	int  clen;
	int  a;
	int  b=0;
	int  kread=0;

	//cline="[ name %s]";	// for testing

	clen=strlen(cline);
	for(a=0; a<clen; a++)
	{
		if     (cline[a] == keyop) kread = (keyopen==keycl ? kread^1: kread+1);
		else if((int) cline[a] == keycl) kread--;
		else if(kread == 1) key[b++]=cline[a];
	}
	key[b]=0;
	return(key);
}

int join(BYTE *st, BYTE *st1, BYTE *st2, BYTE *st3, BYTE *st4)
{
	int a;
	int b=0;

	for(a=0 ; a < (int) strlen(st1); a++) st[b++] = st1[a];
	for(a=0 ; a < (int) strlen(st2); a++) st[b++] = st2[a];
	for(a=0 ; a < (int) strlen(st3); a++) st[b++] = st3[a];
	for(a=0 ; a < (int) strlen(st4); a++) st[b++] = st4[a];
	st[b] = 0;
	return(b);
}

long int filesize(BYTE filename[])
{
	struct ffblk ffblk;

	if(findfirst(filename, &ffblk, 0) == -1) return(0);
	else return(ffblk.ff_fsize);
}
int pathexists(BYTE pathname[])
{
	struct ffblk ffblk;

	if(findfirst(pathname, &ffblk, 0) == -1) return(-1);
	else return(1);
}

int  match(BYTE string[], BYTE line[])
/* looks for string in line from beginning.  returns 1 if match, 0 if no 
match */
{
	int a=0;	// counter
	int len;	// length of string;

	len = min(strlen(string),strlen(line));	// length of shorter string
	for( ; a<len; a++)
	{
		if(string[a] != line[a]) return(0);
	}
	return(len);
}

int getline(BYTE *line, int fh)
/* gets a line of data from the readfile.  Line must be < 1024 chars in 
length*/
{
	BYTE bdata=0;
	BYTE *temp;
	int count=0;
	int g;

	temp= (BYTE *) malloc(4096);
	while(bdata != 13 && bdata != 10)	// 13=CR 10=LF
	{
		if((g=getachar(&bdata, fh))== -1) perr("getline: getachar failed");
		if(bdata == 13 || bdata == 10)
		{
			if(count>0)
			{
				strcpy(line,temp);
				free(temp);
			}
			else bdata=0;
		}
		else
		{
			temp[count++] = bdata;
			temp[count]=0;
			if(g==0) return(0);
			if(count == 4096) perr("getline failed: line too long");
		}
	}
	return(count);
}

int getachar(BYTE *p, int fh)
/* Loads data in 4k blocks and returns one byte at a time.  This speeds up
   disk reads a lot. */
{
	static char buf[4096];
	static int count;

	if(ii==4096)
	{
		// printf("-");
		if((count= read(fh, buf, 4096))== -1) return(-1);
		ii=0;
	}
	if(ii == count) return(0);
	*p=buf[ii++];
	return(1);
}

void wr(int fh_write, BYTE stuff[])
{
	/* printf("%s\n", stuff); */
	_write(fh_write,stuff, strlen(stuff));
	_write(fh_write,"\n",1);
}

void filereaderror(BYTE rfilename[])
{
	printf("file read error: %s", rfilename);
	exit(1);
}

void perr(BYTE er[])
{
	printf("%s\n",er);
	exit(1);
}

void helpme(void)
{
	printf("NewROMs ver. 3.20\n"
		   "---------------------\n"
		   "\n"
		   "Usage: NewROMs [options]\n"
		   "where:\n"
		   "\n"
		   "     options\n"
		   "     O=filename  filename for input listinfo_old (default: listinfo_old.txt)\n"
		   "\n"
		   "     N=filename  filename for input listinfo_new (default: listinfo_new.txt)\n"
		   "\n"
		   "     W=filename  filename for output html_file (default: newroms.htm)\n"
		   "\n"
		   "     R=filename  the path where the roms are\n"
		   "\n"
		   "NewROMs looks for listinfo_new.txt and listinfo_old.txt (output from\n"
		   "mame with -listinfo option) and outputs newroms.htm\n"
		   "\n"
		   "Warning!  NewROMs will die after 20,000 games.  Email\n"
		   "dphirschler@hotmail.com for an update or for the C source code.\n");
	exit(0);
}