Subversion Repositories copyblaze

/*
 *  Copyright © 2003..2008 : Henk van Kampen <henk@mediatronix.com>
 *
 *	This file is part of pBlazASM.
 *
 *  pBlazASM 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.
 *
 *  pBlazASM 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 pBlazASM.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/**
 * pBlaze assembler
 * @file pBlazASM.c
 * @author Henk van Kampen
 */
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <unistd.h>
 
#include "pbTypes.h"
#include "pbParser.h"
#include "pbLibgen.h"
 
#ifdef TCC
#include "getopt.h"
#endif
 
/**
 * usage prints usage text
 * @param text application name
 */
static void usage( char * text ) {
	printf( "\n%s - %s\n", text, "Picoblaze Assembler V1.2" ) ;
	printf( "\nUSAGE:\n" ) ;
	printf( "   pBlazASM [-m[<MEMfile>]] [-l[<LSTfile>]] [-k] [-v] [-f] <input file> <input file> <input file> ...\n"
		"   where:\n"
		"         -m/-M   creates a MEM file (not in combo with -x)\n"
		"         -x/-X   creates a HEX file (not in combo with -m)\n"
		"         -l      creates a LST file\n"
		"         -k      to select KCPSM mode with limited expression handling\n"
		"         -v      generates verbose reporting\n"
		"         -f      with -l creates a list file without code, to replace the source\n" ) ;
	printf( "\nNote: All (max 255) input files are assembled to one output.\n" ) ;
}
 
/**
 * main entry
 * processes command line and
 * calls actual assembler()
 */
int main( int argc, char **argv ) {
	char * src_filenames[ 256 ] =
		{ NULL } ;
	char mem_filename[ 256 ] =
		{ 0 } ;
	char list_filename[ 256 ] =
		{ 0 } ;
	char * pfile, *ppath ;
	int result = 0 ;
	int nInputfile = 0 ;
 
	// KCPSM mode, accepts 'NAMEREG' etc
	bool bKCPSM_mode = false ;
	bool bList_mode = true ;
	bool bOptErr = false ;
	bool bWantMEM = false ;
	bool bWantHEX = false ;
	bool bWantLST = false ;
	bool bVerbose = false ;
	bool bWantZEROs = false ;
 
	extern char * optarg ;
	extern int optind, optopt ;
	int optch ;
 
	while ( ( optch = getopt( argc, argv, "fhkl::m::M::vx::X::" ) ) != -1 ) {
		switch ( optch ) {
		case 'f' :
			bList_mode = false ;
			break ;
		case 'h' :
			bOptErr = true ;
			break ;
		case 'm' :
			if ( bWantHEX ) {
				fprintf( stderr, "? conflicting option -%c\n", optch ) ;
				bOptErr = true ;
			} else {
				bWantMEM = true ;
				if ( optarg != NULL )
					strcpy( mem_filename, optarg ) ;
		    }
			break ;
		case 'x' :
			if ( bWantMEM ) {
				fprintf( stderr, "? conflicting option -%c\n", optch ) ;
				bOptErr = true ;
			} else {
				bWantHEX = true ;
				if ( optarg != NULL )
					strcpy( mem_filename, optarg ) ;
			}
			break ;
		case 'M' :
			if ( bWantHEX ) {
				fprintf( stderr, "? conflicting option -%c\n", optch ) ;
				bOptErr = true ;
			} else {
				bWantMEM = true ;
				bWantZEROs = true ;
				if ( optarg != NULL )
					strcpy( mem_filename, optarg ) ;
		    }
			break ;
		case 'X' :
			if ( bWantMEM ) {
				fprintf( stderr, "? conflicting option -%c\n", optch ) ;
				bOptErr = true ;
			} else {
				bWantHEX = true ;
				bWantZEROs = true ;
				if ( optarg != NULL )
					strcpy( mem_filename, optarg ) ;
			}
			break ;
		case 'l' :
			bWantLST = true ;
			if ( optarg != NULL )
				strcpy( list_filename, optarg ) ;
			break ;
		case 'k' :
			bKCPSM_mode = true ;
			break ;
		case 'v' :
			bVerbose = true ;
			break ;
		case ':' :
			fprintf( stderr, "? missing option -%c\n", optopt ) ;
			bOptErr = true ;
			break ;
		default :
			fprintf( stderr, "? unknown option -%c\n", optopt ) ;
			bOptErr = true ;
			break ;
		}
	}
 
	if ( bOptErr ) {
		usage( basename( argv[ 0 ] ) ) ;
		result = -1 ;
		goto finally ;
	}
 
	if ( bVerbose && bKCPSM_mode )
		fprintf( stdout, "! KCPSM3 compatible mode selected\n" ) ;
 
	if ( argv[ optind ] == NULL ) {
		fprintf( stderr, "? source file(s) missing\n" ) ;
		usage( basename( argv[ 0 ] ) ) ;
		result = -1 ;
		goto finally ;
	}
 
	for ( nInputfile = 0 ; argv[ optind ] != NULL && nInputfile < 256 ; nInputfile += 1, optind += 1 ) {
		src_filenames[ nInputfile ] = calloc( strlen( argv[ optind ] ) + 16, sizeof(char) ) ;
		strcpy( src_filenames[ nInputfile ], argv[ optind ] ) ;
 
		if ( strrchr( src_filenames[ nInputfile ], '.' ) == NULL )
			strcat( src_filenames[ nInputfile ], ".psm" ) ;
		if ( bVerbose )
			fprintf( stdout, "! Sourcefile: %s\n", src_filenames[ nInputfile ] ) ;
	}
 
	if ( bWantMEM || bWantHEX ) {
		if ( strlen( mem_filename ) == 0 ) {
			pfile = filename( src_filenames[ nInputfile - 1 ] ) ;
			ppath = dirname( src_filenames[ nInputfile - 1 ] ) ;
			strcpy( mem_filename, ppath ) ;
			strcat( mem_filename, "/" ) ;
			strcat( mem_filename, pfile ) ;
			strcat( mem_filename, bWantHEX ? ".hex" : ".mem" ) ;
			free( ppath ) ;
			free( pfile ) ;
		}
		if ( strrchr( mem_filename, '.' ) == NULL )
			strcat( mem_filename, bWantHEX ? ".hex" : ".mem" ) ;
		if ( bVerbose )
			fprintf( stdout, "! MEM file: %s\n", mem_filename ) ;
	}
 
	if ( bWantLST ) {
		if ( strlen( list_filename ) == 0 ) {
			pfile = filename( src_filenames[ nInputfile - 1 ] ) ;
			ppath = dirname( src_filenames[ nInputfile - 1 ] ) ;
			strcpy( list_filename, ppath ) ;
			strcat( list_filename, "/" ) ;
			strcat( list_filename, pfile ) ;
			strcat( list_filename, ".lst" ) ;
			free( ppath ) ;
			free( pfile ) ;
		}
		if ( strrchr( list_filename, '.' ) == NULL )
			strcat( list_filename, ".lst" ) ;
		if ( bVerbose )
			fprintf( stdout, "! LST file: %s\n", list_filename ) ;
	}
 
	if ( assembler( src_filenames, mem_filename, list_filename, bKCPSM_mode, bList_mode, bWantHEX, bWantZEROs ) )
		result = 0 ;
	else
		result = -1 ;
 
	finally: {
		int i ;
 
		for ( i = 0 ; i < nInputfile ; i += 1 ) {
			free( src_filenames[ i ] ) ;
		}
	}
	exit( result ) ;
}