/* ROMorg (C)2001 B Y T E  THE BIG  O  N  E
 *
 * This program examines the "listinfo.txt" file (generated by Mame) and
 * outputs a custom tab-delimited file that can be loaded into Excel.
 * Rom files are sorted alphabetically, then sorted again by certain
 * criteria and then grouped with clones.
 *
 *
 * Written June 7, 2001
 * By Darryl P. Hirschler
 * Ver 0.91 - Beta release.
 * Ver 1.0  - Initial release after bug fixes found through Mame version 057
 *
 * Need to add these features:
 * - Make use of config file
 *
 * ROMorg c:\mame36 [options]
 */

#define BYTE unsigned char
#define WORD unsigned int

/*flags */
#define GAME         0x01
#define ORIGINAL     0x02
#define SORTNAME     0x04
#define SORTYEAR     0x10
#define SORTSIZE     0x20

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

#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[]);	/* do it */
void filereaderror(BYTE[]);
int  getachar(BYTE *);	/* gets a char from a 4k buffer or from disk */
int  getline(BYTE *);
void perr(BYTE[]);	/* print error message */
int  match(BYTE[], BYTE[]);	// string matching
long int filesize(BYTE[]);	// returns the filesize
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;	// file handle for read file
BYTE flag=0x00;	// flag byte
BYTE keyopen='[';
BYTE keyclos=']';

struct
{
	BYTE dir[9];
	BYTE name[256];
	BYTE cloneof[9];
	BYTE romof[9];
	BYTE sampleof[9];
	BYTE year[5];
	BYTE manufacturer[256];
	BYTE sample;
	BYTE screen;
	BYTE orientation;
	BYTE xresolution[5];
	BYTE yresolution[5];
	BYTE colors[33];
	BYTE control[64];
	long int romsize;
	long int samplesize;
	long int artworksize;
} game[10000];


void main(BYTE argc, BYTE *argv[])
{
	int  a;	//counter

	if(argc<2 || argc>3) helpme();
	if(argc==3)
	{
		/* checking for optional argument */
		if     (match(strupr(argv[2]),"-N")) flag |= SORTNAME;
		else if(match(strupr(argv[2]),"-Y")) flag |= SORTYEAR;
		else if(match(strupr(argv[2]),"-S")) flag |= SORTSIZE;
		else if(match(strupr(argv[2]),"-?")) helpme();
		else helpme();
	}
	else flag |= SORTNAME;

	printf("ROMorg...\n");
	printf("args: ");

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

	printf("\n");
	if(flag&SORTNAME) printf("sort by NAME\n");
	if(flag&SORTSIZE) printf("sort by SIZE\n");
	if(flag&SORTYEAR) printf("sort by YEAR\n");
	printf("\n");

	dit(argv[1]);
	printf("ROMorg is done.\n");
}

void dit(BYTE mamepath[])	/* do it */
{
	BYTE rfilename[]="listinfo.txt";	// readfile - the datafile (from mame -listinfo)
	BYTE wfilename[]="ROMorg.txt";	// output file - the table.
	BYTE line[2048]="";
	BYTE temp1[2048]="";
	BYTE integer[33]="";
	BYTE tmp[]=" \t";
	int  err;	// errors
	int  fh_write;	// file handle for write file
	int  counter_games=0;
	int  len;		// string length
	int  a;	// counter for sorting
	int  b;	// counter for sorting
	int  c;	// clone counter

	if(mamepath[strlen(mamepath)-1] != '\\')
	{
		join(mamepath, mamepath, "\\", "", "");
		printf("corrected mamepath: [%s]\n", mamepath);
		// mamepath[strlen(mamepath) = '\\';
	}
	
	// printf("opening configuration file: %s\n", "ROMorg.cfg");
	// if((fh_read = _open(temp1,O_RDONLY|O_BINARY)) == -1) perr("cfg file open error");

	join(temp1, mamepath, rfilename, "", "");
	printf("fullpath: [%s]\n", temp1);
	printf("opening readfile: %s\n", temp1);
	if((fh_read = _open(temp1,O_RDONLY|O_BINARY)) == -1) perr("readfile open error");

	_fmode=O_TEXT;
	printf("opening writefile: %s\n", wfilename);
	if((fh_write = creat("ROMorg.txt", S_IREAD|S_IWRITE)) == -1) perr("writefile open error");

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

	/* read the file here */
	while(getline(line))
	{
		if(match("game (", line))		
		{
			flag |= GAME;	// on
			/* reset struct */
			strset(game[counter_games].dir,0);
			strset(game[counter_games].name,0);
			strset(game[counter_games].cloneof,0);
			strset(game[counter_games].romof,0);
			strset(game[counter_games].sampleof,0);
			strset(game[counter_games].year,0);
			strset(game[counter_games].manufacturer,0);
			game[counter_games].sample=' ';
			game[counter_games].screen=' ';
			game[counter_games].orientation=' ';
			strset(game[counter_games].xresolution,0);
			strset(game[counter_games].yresolution,0);
			strset(game[counter_games].colors,0);
			strset(game[counter_games].control,0);
			game[counter_games].romsize=0;
			game[counter_games].samplesize=0;
			game[counter_games].artworksize=0;
		}

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

				// mamepath instead of winmame
				join(temp1, mamepath, "roms\\", game[counter_games].dir, ".zip");
				game[counter_games].romsize = filesize(temp1);

				// mamepath instead of winmame
				join(temp1, mamepath, "samples\\", game[counter_games].dir, ".zip");
				game[counter_games].samplesize = filesize(temp1); 

				// mamepath instead of winmame
				join(temp1, mamepath, "artwork\\", game[counter_games].dir, ".zip");
				game[counter_games].artworksize = filesize(temp1); 
			}
			if(keyfits(line, "\tdescription \"%s\"", temp1))
				strncpy(game[counter_games].name, temp1, 49);
			if(keyfits(line, "\tyear %s", temp1))
				strcpy(game[counter_games].year, temp1);
			if(keyfits(line, "\tmanufacturer \"%s\"", temp1))
				strncpy(game[counter_games].manufacturer, temp1, 49);
			if(keyfits(line, "\tchip ( type audio [ name %s ])", temp1))
			{
				if(match(temp1, "Samples")) game[counter_games].sample='Y';
				else game[counter_games].sample=' ';
			}
			if(keyfits(line, "\tcloneof %s", temp1))
				strcpy(game[counter_games].cloneof, temp1);
			if(keyfits(line, "\tromof %s", temp1))
				strcpy(game[counter_games].romof, temp1);
			if(keyfits(line, "\tsampleof %s", temp1))
				strcpy(game[counter_games].sampleof, temp1);
			if(keyfits(line, "\tvideo ([ screen %s ])", temp1))
			{
				if(match(temp1, "raster")) game[counter_games].screen='R';
				if(match(temp1, "vector")) game[counter_games].screen='V';
			}
			if(keyfits(line, "\tvideo ([ orientation %s ])", temp1))
			{
				if(match(temp1, "horizontal")) game[counter_games].orientation='H';
				if(match(temp1, "vertical")) game[counter_games].orientation='V';
			}
			if(keyfits(line, "\tvideo ([ x %s ])", temp1))
				strcpy(game[counter_games].xresolution, temp1);
			if(keyfits(line, "\tvideo ([ y %s ])", temp1))
				strcpy(game[counter_games].yresolution, temp1);
			if(keyfits(line, "\tvideo ([ colors %s ])", temp1))
				strcpy(game[counter_games].colors, temp1);
			if(keyfits(line, "\tinput ([ control %s ])", temp1))
				strcpy(game[counter_games].control, temp1);

			if(match(")", line))
			{
				flag &= ~GAME;	// flag off
				printf("%04d [%8s]\r", counter_games+1, game[counter_games].dir);
				counter_games++;
			}
		}
	}
	_close(fh_read);
	printf("\n");

	/* sort structure here */
	printf("Sorting the data (initial sort)...\n");
	for(a=0; a<counter_games; a++)
	{
		for(b=a+1; b<counter_games; b++)
		{
			if(strcmpi(game[b].name, game[a].name) < 0)
			{
				game[counter_games+1]=game[a];
				game[a]=game[b];
				game[b]=game[counter_games+1];
			}
		}
		printf("%04d [%8s]\r", a+1, game[a].dir);
	}
	printf("\n");

	if(flag&SORTYEAR)
	{
		printf("Sorting by YEAR...\n");
		for(a=0; a<counter_games; a++)
		{
			for(b=a+1; b<counter_games; b++)
			{
				if(strcmpi(game[b].year, game[a].year) < 0)
				{
					game[counter_games+1]=game[a];
					game[a]=game[b];
					game[b]=game[counter_games+1];
				}
			}
			printf("%04d [%8s]\r", a+1, game[a].dir);
		}
	}
	if(flag&SORTSIZE)
	{
		printf("Sorting by SIZE...\n");
		for(a=0; a<counter_games; a++)
		{
			for(b=a+1; b<counter_games; b++)
			{
				if((game[b].romsize+game[b].samplesize+game[b].artworksize) < (game[a].romsize+game[a].samplesize+game[a].artworksize))
				{
					game[counter_games+1]=game[a];
					game[a]=game[b];
					game[b]=game[counter_games+1];
				}
			}
			printf("%04d [%8s]\r", a+1, game[a].dir);
		}
	}

	/* group clones with originals */
	printf("Grouping clones with originals\n");
	for(a=0; a<counter_games; a++)
	{
		if(strcmp(game[a].cloneof, "") == 0)
		{
			flag |= ORIGINAL;	// it is an original
			// printf("Original: %8s\t", game[a].dir);
		}
		else	// it is a clone
		{
			flag &= ~ORIGINAL;	// flag off
			b=a+1;

			/* find the next original */
			while(!(flag&ORIGINAL) && b<counter_games)
			{
				if(strcmp(game[b].cloneof, "") == 0)	// found an original
				{
					game[counter_games+1] = game[a];
					game[a] = game[b];
					game[b] = game[counter_games+1];
					flag |= ORIGINAL;	// on
				}
				else b++;
			}
		}

		c = a+1;
		/* search rest of list for clones */
		for(b=c; b<counter_games; b++)
		{
			if(strcmp(game[b].cloneof, game[a].dir) == 0) // found a match
			{
				game[counter_games+1] = game[c];
				game[c] = game[b];
				game[b] = game[counter_games+1];
				c++;
			}
		}
		a=c-1;
		// printf("\n");
		flag &= ~ORIGINAL;	// flag off
	}
	printf("\n");

	/* write table file here */
	printf("Writing table file: ROMorg.txt\n");
	wr(fh_write, "Dir\tName\tCloneof\tROMof\tSampleof\tYear\tManufacturer\tSamples\tScreen\tOrientation\tResolution\tColors\tControl\tROMsize\tSampleSize\tArtworkSize"); // column headings

	for(a=0; a<counter_games; a++)
	{
		strset(line,0);
		strcpy(line, game[a].dir);	strcat(line, "\t");
		strcat(line, game[a].name);	strcat(line, "\t");
		strcat(line, game[a].cloneof);	strcat(line, "\t");
		strcat(line, game[a].romof);	strcat(line, "\t");
		strcat(line, game[a].sampleof);	strcat(line, "\t");
		strcat(line, game[a].year);	strcat(line, "\t");
		strcat(line, game[a].manufacturer);	strcat(line, "\t");
		tmp[0]= game[a].sample;	strcat(line, tmp);
		tmp[0]= game[a].screen;	strcat(line, tmp);
		tmp[0]= game[a].orientation;	strcat(line, tmp);

		if(strlen(game[a].xresolution) && strlen(game[a].yresolution))	
		{
			strcat(line, game[a].xresolution);
			strcat(line, "x");
			strcat(line, game[a].yresolution);
		}
		strcat(line, "\t");
		strcat(line, game[a].colors);	strcat(line, "\t");
		strcat(line, game[a].control);	strcat(line, "\t");
		strcat(line, ltoa(game[a].romsize, integer, 10));	strcat(line, "\t");
		strcat(line, ltoa(game[a].samplesize, integer, 10));	strcat(line, "\t");
		strcat(line, ltoa(game[a].artworksize, integer, 10));

		wr(fh_write, line);
	}

	_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[2048]="";

	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[2048]="";
	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 str_count_to(BYTE *line, BYTE c)
// counts characters in line until character c occurs
{
	int a=0;

	while(line[a] && line[a] != c)
	{
		a++;
	}
	return(a);
}

int strfind(BYTE *string, BYTE *line)
// finds a string within line
{	
	int a=0;	// counter
	int llen;	// length of line
	int slen;	// length of string
	int l;

	llen=strlen(line);
	slen=strlen(string);
	if((l=(llen-slen)) < 0) return(0);

	for( ; a <= l; a++)
		if(match(string,(line+a))) return(a+slen);
	return(0);
}
*/

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)
/* gets a line of data from the readfile.  Line must be < 2048 chars in length*/
{
	BYTE bdata=0;
	BYTE *temp;
	int count=0;
	int g;

	temp= (BYTE *) malloc(2048);
	while(bdata != 13 && bdata != 10)	// 13=CR 10=LF
	{
		if((g=getachar(&bdata))== -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 == 2048) perr("getline failed: line too long");
		}
	} 
	return(count);
}

int getachar(BYTE *p)
/* 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_read, 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("Usage: ROMorg mamepath [option]\n"
		   "where:\n"
		   "     mamepath=the path where...\n"
		   "         listinfo.txt is stored,\n"
		   "         roms, samples, and artwork folders are\n"
		   "\n"
		   "     option=\n"
		   "         -N Sort by game name(full name)\n"
		   "         -Y Sort by year\n"
		   "         -S Sort by size (rom+sample+artwork)\n"
		   "\n"
		   "Warning!  ROMorg will die after 10,000 games.  Email dphirschler@hotmail.com\n"
		   "for an update or for the C source code.\n");
	exit(0);
}