Subversion Repositories lxp32

/*
 * Copyright (c) 2016 by Alex I. Kuznetsov.
 *
 * Part of the LXP32 CPU IP core.
 *
 * Main translation unit for the LXP32 disassembler.
 */
 
#ifdef _MSC_VER
	#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include "disassembler.h"
 
#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <ctime>
 
static void displayUsage(std::ostream &os,const char *program) {
	os<<std::endl;
	os<<"Usage:"<<std::endl;
	os<<"    "<<program<<" [ option(s) | input file ]"<<std::endl<<std::endl;
 
	os<<"Options:"<<std::endl;
	os<<"    -b <addr>    Base address (for comments only)"<<std::endl;
	os<<"    -f <fmt>     Input format (bin, textio, dec, hex), default: autodetect"<<std::endl;
	os<<"    -h, --help   Display a short help message"<<std::endl;
	os<<"    -na          Do not use instruction and register aliases"<<std::endl;
	os<<"    -o <file>    Output file name, default: standard output"<<std::endl;
	os<<"    --           Do not interpret subsequent arguments as options"<<std::endl;
}
 
static Disassembler::Format detectInputFormat(std::istream &in) {
	static const std::size_t Size=256;
	static const char *textio="01\r\n \t";
	static const char *dec="0123456789\r\n \t";
	static const char *hex="0123456789ABCDEFabcdef\r\n \t";
 
	char buf[Size];
	in.read(buf,Size);
	auto s=static_cast<std::size_t>(in.gcount());
	in.clear();
	in.seekg(0);
 
	Disassembler::Format fmt=Disassembler::Textio;
 
	for(std::size_t i=0;i<s;i++) {
		if(fmt==Disassembler::Textio&&!strchr(textio,buf[i])) fmt=Disassembler::Dec;
		if(fmt==Disassembler::Dec&&!strchr(dec,buf[i])) fmt=Disassembler::Hex;
		if(fmt==Disassembler::Hex&&!strchr(hex,buf[i])) {
			fmt=Disassembler::Bin;
			break;
		}
	}
 
	return fmt;
}
 
int main(int argc,char *argv[]) try {
	std::string inputFileName,outputFileName;
 
	std::cerr<<"LXP32 Platform Disassembler"<<std::endl;
	std::cerr<<"Copyright (c) 2016-2019 by Alex I. Kuznetsov"<<std::endl;
 
	Disassembler::Format fmt=Disassembler::Bin;
	bool noMoreOptions=false;
	bool formatSpecified=false;
	Disassembler::Word base=0;
	bool noAliases=false;
 
	if(argc<=1) {
		displayUsage(std::cout,argv[0]);
		return 0;
	}
 
	for(int i=1;i<argc;i++) {
		if(argv[i][0]!='-'||noMoreOptions) {
			if(inputFileName.empty()) inputFileName=argv[i];
			else throw std::runtime_error("Only one input file name can be specified");
		}
		else if(!strcmp(argv[i],"--")) noMoreOptions=true;
		else if(!strcmp(argv[i],"-b")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			try {
				base=std::stoul(argv[i],nullptr,0);
				if(base%4!=0) throw std::exception();
			}
			catch(std::exception &) {
				throw std::runtime_error("Invalid base address");
			}
		}
		else if(!strcmp(argv[i],"-f")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			if(!strcmp(argv[i],"bin")) fmt=Disassembler::Bin;
			else if(!strcmp(argv[i],"textio")) fmt=Disassembler::Textio;
			else if(!strcmp(argv[i],"dec")) fmt=Disassembler::Dec;
			else if(!strcmp(argv[i],"hex")) fmt=Disassembler::Hex;
			else throw std::runtime_error("Unrecognized input format");
			formatSpecified=true;
		}
		else if(!strcmp(argv[i],"-h")||!strcmp(argv[i],"--help")) {
			displayUsage(std::cout,argv[0]);
			return 0;
		}
		else if(!strcmp(argv[i],"-na")) {
			noAliases=true;
		}
		else if(!strcmp(argv[i],"-o")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			outputFileName=argv[i];
		}
		else throw std::runtime_error(std::string("Unrecognized option: \"")+argv[i]+"\"");
	}
 
	if(!formatSpecified) { // auto-detect input file format
		std::ifstream in(inputFileName,std::ios_base::in|std::ios_base::binary);
		fmt=detectInputFormat(in);
	}
 
	std::ifstream in;
 
	if(fmt==Disassembler::Bin) in.open(inputFileName,std::ios_base::in|std::ios_base::binary);
	else in.open(inputFileName,std::ios_base::in);
	if(!in) throw std::runtime_error("Cannot open \""+inputFileName+"\"");
 
	std::ofstream out;
	std::ostream *os=&std::cout;
	if(!outputFileName.empty()) {
		out.open(outputFileName,std::ios_base::out);
		if(!out) throw std::runtime_error("Cannot open \""+outputFileName+"\"");
		os=&out;
	}
 
	auto t=std::time(NULL);
	char szTime[256];
	auto r=std::strftime(szTime,256,"%c",std::localtime(&t));
	if(r==0) szTime[0]='\0';
 
	*os<<"/*"<<std::endl;
	*os<<" * Input file: "<<inputFileName<<std::endl;
	*os<<" * Input format: ";
 
	switch(fmt) {
	case Disassembler::Bin:
		*os<<"bin";
		break;
	case Disassembler::Textio:
		*os<<"textio";
		break;
	case Disassembler::Dec:
		*os<<"dec";
		break;
	case Disassembler::Hex:
		*os<<"hex";
		break;
	default:
		break;
	}
 
	if(!formatSpecified) *os<<" (autodetected)";
	*os<<std::endl;
	*os<<" * Base address: 0x"<<Disassembler::hex(base)<<std::endl;
	*os<<" * Disassembled by lxp32dump at "<<szTime<<std::endl;
	*os<<" */"<<std::endl<<std::endl;
 
	Disassembler disasm(in,*os);
	disasm.setFormat(fmt);
	disasm.setBase(base);
	disasm.setPreferAliases(!noAliases);
 
	try {
		disasm.dump();
	}
	catch(std::exception &) {
		if(!outputFileName.empty()) {
			out.close();
			std::remove(outputFileName.c_str());
		}
		throw;
	}
}
catch(std::exception &ex) {
	std::cerr<<"Error: "<<ex.what()<<std::endl;
	return EXIT_FAILURE;
}