/*
readfiles.c
Copyright © 2009 William Astle

This file is part of LWLINK.

LWLINK 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 3 of the License, or (at your option) any later
version.

This program 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
this program. If not, see <http://www.gnu.org/licenses/>.


Reads input files

*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <argp.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#include "lwlink.h"
#include "util.h"

void read_lwobj16v0(fileinfo_t *fn);

/*
The logic of reading the entire file into memory is simple. All the symbol
names in the file are NUL terminated strings and can be used directly without
making additional copies.
*/
void read_files(void)
{
	int i;
	long size;
	FILE *f;
	long bread;
	for (i = 0; i < ninputfiles; i++)
	{
		f = fopen(inputfiles[i] -> filename, "rb");
		if (!f)
		{
			fprintf(stderr, "Can't open file %s:", inputfiles[i] -> filename);
			perror("");
			exit(1);
		}
		fseek(f, 0, SEEK_END);
		size = ftell(f);
		rewind(f);
		
		inputfiles[i] -> filedata = lw_malloc(size);
		inputfiles[i] -> filesize = size;
		
		bread = fread(inputfiles[i] -> filedata, 1, size, f);
		if (bread < size)
		{
			fprintf(stderr, "Short read on file %s (%ld/%ld):", inputfiles[i] -> filename, bread, size);
			perror("");
			exit(1);
		}
			
		fclose(f);
		
		if (!memcmp(inputfiles[i] -> filedata, "LWOBJ16", 8))
		{
			// read v0 LWOBJ16 file
			read_lwobj16v0(inputfiles[i]);
		}
		else
		{
			fprintf(stderr, "%s: unknown file format\n", inputfiles[i] -> filename);
			exit(1);
		}
	}
}

// this macro is used to bail out if we run off the end of the file data
// while parsing - it keeps the code below cleaner
#define NEXTBYTE()	do { cc++; if (cc >= fn -> filesize) { fprintf(stderr, "%s: invalid file format\n", fn -> filename); exit(1); } } while (0)
// this macro is used to refer to the current byte in the stream
#define CURBYTE()	(fn -> filedata[cc])
// this one will leave the input pointer past the trailing NUL
#define CURSTR()	read_lwobj16v0_str(&cc, fn)
unsigned char *read_lwobj16v0_str(long *cc1, fileinfo_t *fn)
{
	int cc = *cc1;
	unsigned char *fp;
	fp = &CURBYTE();
	while (CURBYTE())
		NEXTBYTE();
	NEXTBYTE();
	*cc1 = cc;
	return fp;
}
// the function below can be switched to dealing with data coming from a
// source other than an in-memory byte pool by adjusting the input data
// in "fn" and the above two macros
void read_lwobj16v0(fileinfo_t *fn)
{
	unsigned char *fp;
	long cc;
	section_t *s;
	int val;
	symtab_t *se;
	
	// start reading *after* the magic number
	cc = 7;
	
	// init data
	fn -> sections = NULL;
	fn -> nsections = 0;

	while (1)
	{
		NEXTBYTE();
		// bail out if no more sections
		if (!(CURBYTE()))
			break;
		
		fp = CURSTR();
		
		// we now have a section name in fp
		// create new section entry
		fn -> sections = lw_realloc(fn -> sections, sizeof(section_t) * (fn -> nsections + 1));
		s = &(fn -> sections[fn -> nsections]);
		fn -> nsections += 1;
		
		s -> localsyms = NULL;
		s -> flags = 0;
		s -> codesize = 0;
		s -> name = fp;
		s -> loadaddress = 0;
		s -> localsyms = NULL;
		s -> exportedsyms = NULL;
		s -> incompletes = NULL;
		s -> processed = 0;
		s -> file = fn;
		
		// read flags
		while (CURBYTE())
		{
			switch (CURBYTE())
			{
			case 0x01:
				s -> flags |= SECTION_BSS;
				break;

			default:
				fprintf(stderr, "%s (%s): unrecognized section flag %02X\n", fn -> filename, s -> name, (int)(CURBYTE()));
				exit(1);
			}
			NEXTBYTE();
		}
		// skip NUL terminating flags
		NEXTBYTE();
		
		// now parse the local symbol table
		while (CURBYTE())
		{
			fp = CURSTR();

			// fp is the symbol name
			val = (CURBYTE()) << 8;
			NEXTBYTE();
			val |= (CURBYTE());
			NEXTBYTE();
			// val is now the symbol value
			
			// create symbol table entry
			se = lw_malloc(sizeof(symtab_t));
			se -> next = s -> localsyms;
			s -> localsyms = se;
			se -> sym = fp;
			se -> offset = val;
			se -> realval = val;
		}

		// now parse the exported symbol table
		while (CURBYTE())
		{
			fp = CURSTR();

			// fp is the symbol name
			val = (CURBYTE()) << 8;
			NEXTBYTE();
			val |= (CURBYTE());
			NEXTBYTE();
			// val is now the symbol value
			
			// create symbol table entry
			se = lw_malloc(sizeof(symtab_t));
			se -> next = s -> exportedsyms;
			s -> localsyms = se;
			se -> sym = fp;
			se -> offset = val;
			se -> realval = val;
		}
		
		// now parse the incomplete references and make a list of
		// external references that need resolution
		while (CURBYTE())
		{
			reloc_t *rp;
			lw_expr_term_t *term;
			
			// we have a reference
			rp = lw_malloc(sizeof(reloc_t));
			rp -> next = s -> incompletes;
			s -> incompletes = rp;
			rp -> offset = 0;
			rp -> expr = lw_expr_stack_create();
			
			// parse the expression
			while (CURBYTE())
			{
				int tt = CURBYTE();
				NEXTBYTE();
				switch (tt)
				{
				case 0x01:
					// 16 bit integer
					tt = CURBYTE() << 8;
					NEXTBYTE();
					tt |= CURBYTE();
					NEXTBYTE();
					// normalize for negatives...
					if (tt > 0x7fff)
						tt -= 0x10000;
					term = lw_expr_term_create_int(tt);
					break;
				
				case 0x02:
					// external symbol reference
					term = lw_expr_term_create_sym(CURSTR(), 0);
					break;
					
				case 0x03:
					// internal symbol reference
					term = lw_expr_term_create_sym(CURSTR(), 1);
					break;
				
				case 0x04:
					// operator
					term = lw_expr_term_create_oper(CURBYTE());
					NEXTBYTE();
					break;

				case 0x05:
					// section base reference (NULL internal reference is
					// the section base address
					term = lw_expr_term_create_sym(NULL, 0);
					break;
					
				default:
					fprintf(stderr, "%s (%s): bad relocation expression\n", fn -> filename, s -> name);
					exit(1);
				}
				lw_expr_stack_push(rp -> expr, term);
				lw_expr_term_free(term);
			}
		}
		// skip the NUL terminatin
		NEXTBYTE();
				
		// now set code location and size and verify that the file
		// contains data going to the end of the code (if !SECTION_BSS)
		s -> codesize = CURBYTE() << 8;
		NEXTBYTE();
		s -> codesize |= CURBYTE();
		NEXTBYTE();
		
		s -> code = &(CURBYTE());
		
		// skip the code if we're not in a BSS section
		if (!(s -> flags & SECTION_BSS))
		{
			int i;
			for (i = 0; i < s -> codesize; i++)
				NEXTBYTE();
		}
	}
}