f256/header/header.c

#include <arpa/inet.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>

#include "stddclmr.h"


/*
 * This program assumes it is being run on a little endian machine.
 */


int utilStricmp(char *a, char *b) {
	for (;; a++, b++) {
		int d = tolower((unsigned char)*a) - tolower((unsigned char)*b);
		if (d != 0 || !*a) {
			return d;
		}
	}
}


int main(int argc, char *argv[]) {
	FILE    *in       = NULL;
	FILE    *out      = NULL;
	int32_t  reserved = 0;
	int32_t  start;
	int32_t  length;
	int32_t  count;
	int      c;
	int8_t   addr;

	if (argc < 2) {
		printf("Usage:  %s [mode] {opts}\n\n", argv[0]);
		printf("  Where [mode] is:  KUP, PGX, or PGZ\n");
		return 1;
	}

	// Add MicroKernel header.
	if (utilStricmp((char *)"kup", argv[1]) == 0) {
		/*
		 * MicroKernel Application
		 *
		 *  Byte  0    signature: $F2
		 *  Byte  1    signature: $56
		 *  Byte  2    the size of program in 8k blocks
		 *  Byte  3    the starting slot of the program (cannot be zero)
		 *  Bytes 4-5  the start address of the program
		 *  Byte  6    header structure version (0 or 1)
		 *  Bytes 7-9  reserved
		 *  Bytes 10-  the zero-terminated name of the program
		 *  Bytes ?-   the zero-terminated arguments for the program (version >= 1)
		 *  Bytes ?-   the zero-terminated description of the program (version >= 1)
		 */
		if (argc != 9) {
			printf("Usage:  %s KUP INPUT.BIN OUTPUT.KUP SLOT START \"NAME\" \"ARG LIST\" \"DESC\"\n", argv[0]);
			return 1;
		}
		in = fopen(argv[2], "rb");
		if (!in) {
			printf("Unable to open input file.\n");
			return 1;
		}
		out = fopen(argv[3], "wb");
		if (!out) {
			fclose(in);
			printf("Unable to open output file.\n");
			return 1;
		}
		// Get binary size in blocks.
		fseek(in, 0, SEEK_END);
		length = ceil((float)ftell(in) / 8192.0);
		fseek(in, 0, SEEK_SET);
		// Write header.
		fputc(0xf2, out);
		fputc(0x56, out);
		fputc((int8_t)length, out);
		fputc((int8_t)atoi(argv[4]), out);
		start = (int16_t)strtol(argv[5], NULL, 0);
		fwrite(&start, sizeof(int16_t), 1, out);
		fputc(0x01, out);  // version
		fwrite(&reserved, sizeof(char), 3, out);
		fputs(argv[6], out);
		fputc(0x00, out);
		if (strlen(argv[7]) > 0) fputs(argv[7], out);
		fputc(0x00, out);
		fputs(argv[8], out);
		fputc(0x00, out);
		// Copy binary into output.
		while ((c = fgetc(in)) != EOF) fputc(c, out);
		fclose(out);
		fclose(in);
	}

	// Add PGX header.
	if (utilStricmp((char *)"pgx", argv[1]) == 0) {
		/*
		 * PGX Program
		 *
		 *  Byte 0-2  signature: PGX
		 *  Byte 3    CPU Type (1=65816, 2=M680x0, 3=6502)
		 *  Byte 4-7  load address - big endian!
		 *  Byte 8-   data
		 */
		if (argc != 5) {
			printf("Usage:  %s PGX INPUT.BIN OUTPUT.PGX START\n", argv[0]);
			return 1;
		}
		in = fopen(argv[2], "rb");
		if (!in) {
			printf("Unable to open input file.\n");
			return 1;
		}
		out = fopen(argv[3], "wb");
		if (!out) {
			fclose(in);
			printf("Unable to open output file.\n");
			return 1;
		}
		// Write header.
		fputc('P', out);
		fputc('G', out);
		fputc('X', out);
		fputc(0x03, out);
		start = htonl((int32_t)strtol(argv[4], NULL, 0));
		fwrite(&start, sizeof(int32_t), 1, out);
		// Copy binary into output.
		while ((c = fgetc(in)) != EOF) fputc(c, out);
		fclose(out);
		fclose(in);
	}

	// Create PGZ package.
	if (utilStricmp((char *)"pgz", argv[1]) == 0) {
		/*
		 * PGZ Program
		 *
		 *  Byte 0    signature ("Z" = 24 bit addresses, "z" = 32 bit)
		 *  Byte 1-3  address of segment #1 (24 bit example)
		 *  Byte 4-6  size of segment #1
		 *  Byte 7-   data
		 *  ...       repeat address/size/data for more segments
		 *  Byte ?    start address
		 *  Byte ?    zeros to indicate this is the start address
		 */
		if (argc < 7) {
			printf("Usage:  %s PGZ [32|24] OUTPUT.PGZ START SEG1.BIN ADDR1 ... SEGx.BIN ADDRx\n", argv[0]);
			return 1;
		}
		// Must specify 32 or 24 bit addressing.
		addr = atoi(argv[2]);
		if (addr != 24 && addr != 32) {
			printf("Addressing bits must be 24 or 32.\n");
			return 1;
		}
		// Must have argument pairs.
		if ((argc - 5) % 2 != 0) {
			printf("Must provide an even number of segment arguments.\n");
			return 1;
		}
		// Start of segment arguments.
		count = 5;
		// Open file to write.
		out = fopen(argv[3], "wb");
		if (!out) {
			printf("Unable to open output file.\n");
			return 1;
		}
		// Header.
		if (addr == 24) fputc('Z', out); else fputc('z', out);
		// Assemble segments.
		while (count < argc) {
			// Open segment to read.
			in = fopen(argv[count], "rb");
			if (!in) {
				fclose(out);
				printf("Unable to open segment %s.\n", argv[count]);
				return 1;
			}
			count++;
			// Get segment size.
			fseek(in, 0, SEEK_END);
			length = ftell(in);
			fseek(in, 0, SEEK_SET);
			// Write segment info.
			start = (int32_t)strtol(argv[count], NULL, 0);
			count++;
			if (addr == 24) {
				fwrite(&start, sizeof(char), 3, out);
				fwrite(&length, sizeof(char), 3, out);
			} else {
				fwrite(&start, sizeof(int32_t), 1, out);
				fwrite(&length, sizeof(int32_t), 1, out);
			}
			// Copy binary into output.
			while ((c = fgetc(in)) != EOF) fputc(c, out);
			fclose(in);
		}
		// Write start address.
		start = (int32_t)strtol(argv[4], NULL, 0);
		if (addr == 24) {
			fwrite(&start, 3, 1, out);
			fwrite(&reserved, 3, 1, out);
		} else {
			fwrite(&start, sizeof(int32_t), 1, out);
			fwrite(&reserved, sizeof(int32_t), 1, out);
		}
		fclose(out);
	}

	return 0;
}