2814 lines
105 KiB
Perl
Executable File
2814 lines
105 KiB
Perl
Executable File
#! /usr/bin/perl
|
|
#########################################################################################################
|
|
##
|
|
## Name: romtool.pl
|
|
## Created: July 2018
|
|
## Author(s): Philip Smart
|
|
## Description: Sharp MZ series rom management tool.
|
|
## This script takes a set of roms and creates the necessary MIF image for embedding
|
|
## into the FPGA during compilation.
|
|
## It can also be used to create a binary image if needed for upload via the HPS.
|
|
##
|
|
## Credits:
|
|
## Copyright: (c) 2018 Philip Smart <philip.smart@net2net.org>
|
|
##
|
|
## History: July 2018 - Initial script written.
|
|
##
|
|
#########################################################################################################
|
|
## This source file 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 source file 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/>.
|
|
#########################################################################################################
|
|
|
|
# Title and Versioning.
|
|
#
|
|
$TITLE = "ROM Tool";
|
|
$VERSION = "0.5";
|
|
$VERSIONDATE = "12.10.2018";
|
|
|
|
# Global Modules.
|
|
#
|
|
#use strict
|
|
use Getopt::Long;
|
|
use IO::File;
|
|
use File::stat;
|
|
use File::Copy;
|
|
use Time::localtime;
|
|
use POSIX qw(tmpnam);
|
|
use Env qw(KPLUSHOME3 SYBASE SYBASE_OCS DSQUERY);
|
|
use sigtrap qw(die normal-signals);
|
|
|
|
# Error return codes.
|
|
#
|
|
$ERR_BADFILENAME = 1;
|
|
$ERR_BADFILEDATA = 2;
|
|
$ERR_BADFILECREATE = 3;
|
|
$ERR_BADFUNCARGS = 4;
|
|
$ERR_BADSYSCALL = 5;
|
|
$ERR_BADCHECK = 6;
|
|
$ERR_BADENV = 7;
|
|
$ERR_SYBSERVER = 8;
|
|
$ERR_BADARGUMENTS = 9;
|
|
|
|
# Run-time constants.
|
|
#
|
|
$PROGNAME = $0;
|
|
|
|
# Run-time globals. Although in Perl you can just specify variables, keeping with most
|
|
# high-order languages it is good practise to specify non-local variables in a global header
|
|
# which aids visual variable tracking etc.
|
|
#
|
|
$dbh = 0; # Handle to a Sybase object.
|
|
$logh = 0; # Handle to open log file.
|
|
$logName = ""; # Temporary name of log file.
|
|
$logMode = "terminal"; # Default logging mode for logger.
|
|
|
|
|
|
# Configurables!!
|
|
#
|
|
$SENDMAIL = "/usr/lib/sendmail -t";
|
|
@errorMailRecipients = ( "philip.smart\@net2net.org" );
|
|
$errorMailFrom = "error\@localhost";
|
|
$errorMailSubject = "Rom tool patch Errors...";
|
|
$PERL = "perl";
|
|
$PERLFLAGS = "";
|
|
|
|
|
|
##################################################################################
|
|
# GENERIC SUB-ROUTINES
|
|
##################################################################################
|
|
|
|
# Sub-routine to close the log file and email its contents to required participants.
|
|
#
|
|
sub logClose
|
|
{
|
|
# Locals.
|
|
local( $idx, $line, @mailRecipients, $mailFrom, $mailSubject, $mailHeader );
|
|
|
|
# No point closing log if one wasnt created!!
|
|
#
|
|
if($logName eq "" || $sendEmail == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
# Back to beginning of file, to copy into email.
|
|
#
|
|
seek($logh, 0, 0);
|
|
|
|
# Build up an email to required recipients and send.
|
|
#
|
|
open(SENDMAIL, "|$SENDMAIL") or die "Cannot open $SENDMAIL: $!";
|
|
for($idx=0; $idx < @errorMailRecipients; $idx++)
|
|
{
|
|
print SENDMAIL "To: $errorMailRecipients[$idx]\n";
|
|
}
|
|
print SENDMAIL "Reply-to: $errorMailFrom\n";
|
|
print SENDMAIL "From: $errorMailFrom\n";
|
|
print SENDMAIL "Subject: $errorMailSubject\n";
|
|
print SENDMAIL "Content-type: text/plain\n\n";
|
|
while( $line = <$logh> )
|
|
{
|
|
chomp($line);
|
|
print SENDMAIL "$line\n";
|
|
}
|
|
close(SENDMAIL);
|
|
|
|
# Delete the logfile, not needed.
|
|
#
|
|
unlink($logName) or die "Couldn't unlink Error File $logName : $!";
|
|
}
|
|
|
|
# Function to write a message into a log file. The logfile is a temporary buffer, used
|
|
# to store all messages until program end. Upon completion, the buffer is emailed to required
|
|
# participants.
|
|
#
|
|
sub logWrite
|
|
{
|
|
# Get parameters, define locals.
|
|
local( $mode, $text ) = @_;
|
|
local( $date );
|
|
|
|
# Get current date and time for timestamping the log message.
|
|
#
|
|
$date = `date +'%Y.%m.%d %H:%M:%S'`;
|
|
chomp($date);
|
|
|
|
# In terminal mode (=interactive mode), always log to STDOUT.
|
|
#
|
|
if($logMode eq "terminal")
|
|
{
|
|
if(index($mode, "ND") == -1)
|
|
{
|
|
print "$date ";
|
|
}
|
|
print "$text";
|
|
if(index($mode, "NR") == -1)
|
|
{
|
|
print "\n";
|
|
}
|
|
|
|
# Die if required.
|
|
#
|
|
if (index($mode, 'die') != -1)
|
|
{
|
|
print "$date Terminating at program request.\n";
|
|
exit 1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
# If the logfile hasnt been opened, open it.
|
|
#
|
|
if($logName eq "")
|
|
{
|
|
# Try new temporary filenames until we get one that doesnt already exist.
|
|
do {
|
|
$logName = tmpnam();
|
|
} until $logh = IO::File->new($logName, O_RDWR|O_CREAT|O_EXCL);
|
|
|
|
# Automatically flush out log.
|
|
$logh->autoflush(1);
|
|
|
|
# Only send email if we explicitly die.
|
|
#
|
|
$sendEmail = 0;
|
|
|
|
# Install an atexit-style handler so that when we exit or die,
|
|
# we automatically dispatch the log.
|
|
END { logClose($logh, $logName); }
|
|
}
|
|
|
|
# Print to log with date and time stamp.
|
|
#
|
|
print $logh "$date $text\n";
|
|
|
|
# Print to stdout for user view if in debug mode.
|
|
#
|
|
if($debugMode > 0)
|
|
{
|
|
print "$date $text\n";
|
|
}
|
|
|
|
# If requested, log termination message and abort program.
|
|
#
|
|
if (index($mode, 'die') != -1)
|
|
{
|
|
print $logh "$date Terminating at program request.\n";
|
|
$sendEmail = 1;
|
|
exit 1;
|
|
}
|
|
}
|
|
|
|
# Sub-routine to truncate whitespace at the front (left) of a string, returning the
|
|
# truncated string.
|
|
#
|
|
sub cutWhiteSpace
|
|
{
|
|
local( $srcString ) = @_;
|
|
local( $c, $dstString, $idx );
|
|
$dstString = "";
|
|
|
|
for($idx=0; $idx < length($srcString); $idx++)
|
|
{
|
|
# If the character is a space or tab, delete.
|
|
#
|
|
$c = substr($srcString, $idx, 1);
|
|
if(length($dstString) == 0)
|
|
{
|
|
if($c ne " " && $c ne "\t")
|
|
{
|
|
$dstString = $dstString . $c;
|
|
}
|
|
} else
|
|
{
|
|
$dstString = $dstString . $c;
|
|
}
|
|
}
|
|
return($dstString);
|
|
}
|
|
|
|
# Perl trim function to remove whitespace from the start and end of the string
|
|
#
|
|
sub trim($)
|
|
{
|
|
my $string = shift;
|
|
$string =~ s/^\s+//;
|
|
$string =~ s/\s+$//;
|
|
return $string;
|
|
}
|
|
|
|
# Left trim function to remove leading whitespace
|
|
#
|
|
sub ltrim($)
|
|
{
|
|
my $string = shift;
|
|
$string =~ s/^\s+//;
|
|
return $string;
|
|
}
|
|
|
|
# Right trim function to remove trailing whitespace
|
|
#
|
|
sub rtrim($)
|
|
{
|
|
my $string = shift;
|
|
$string =~ s/\s+$//;
|
|
return $string;
|
|
}
|
|
|
|
# Sub-routine to test if a string is empty, and if so, replace
|
|
# with an alternative string. The case of the returned string
|
|
# can be adjusted according to the $convertCase parameter.
|
|
#
|
|
sub trString
|
|
{
|
|
local( $tstString, $replaceString, $convertCase ) = @_;
|
|
local( $dstString );
|
|
|
|
$tstString=cutWhitespace($tstString);
|
|
$replaceString=cutWhitespace($replaceString);
|
|
if($tstString eq "")
|
|
{
|
|
$dstString = $replaceString;
|
|
} else
|
|
{
|
|
$dstString = $tstString;
|
|
}
|
|
|
|
# Convert to Lower Case?
|
|
#
|
|
if($convertCase == 1)
|
|
{
|
|
$dstString =~ lc($dstString);
|
|
}
|
|
# Convert to Upper Case?
|
|
#
|
|
elsif($convertCase == 2)
|
|
{
|
|
$dstString =~ uc($dstString);
|
|
}
|
|
return($dstString);
|
|
}
|
|
|
|
# Sub-routine to test if a numeric is empty, and if so, set to a
|
|
# given value.
|
|
#
|
|
sub trNumeric
|
|
{
|
|
local( $tstNumber, $replaceNumber ) = @_;
|
|
local( $dstNumber );
|
|
|
|
if(!defined($tstNumber) || $tstNumber eq "" || cutWhitespace($tstNumber) eq "")
|
|
{
|
|
$dstNumber = $replaceNumber;
|
|
} else
|
|
{
|
|
$dstNumber = $tstNumber;
|
|
}
|
|
|
|
return($dstNumber);
|
|
}
|
|
|
|
# Function to look at a string and decide wether its contents
|
|
# indicate Yes or No. If the subroutine cannot determine a Yes,
|
|
# then it defaults to No.
|
|
#
|
|
sub yesNo
|
|
{
|
|
local( $srcString ) = @_;
|
|
local( $dstString, $yesNo );
|
|
$yesNo = "N";
|
|
|
|
$dstString=lc(cutWhiteSpace($srcString));
|
|
if($dstString eq "y" || $dstString eq "yes" || $dstString eq "ye")
|
|
{
|
|
$yesNo = "Y";
|
|
}
|
|
return( $yesNo );
|
|
}
|
|
|
|
# Sub-routine to encrypt an input string, typically a password,
|
|
# using the Collateral Management Encrypt utility.
|
|
#
|
|
sub encrypt
|
|
{
|
|
local( $srcPasswd ) = @_;
|
|
local( $encPasswd );
|
|
$encPasswd="";
|
|
|
|
# Call external function to perform the encryption.
|
|
#
|
|
if($srcPasswd ne "")
|
|
{
|
|
$encPasswd=`$PROG_ENCRYPT -p $srcPasswd 2>&1`;
|
|
chomp($encPasswd);
|
|
}
|
|
return($encPasswd);
|
|
}
|
|
|
|
# Sub-routine to test if a string is empty, and if so, replace
|
|
# with an alternative string. The case of the returned string
|
|
# can be adjusted according to the $convertCase parameter.
|
|
#
|
|
sub testAndReplace
|
|
{
|
|
local( $tstString, $replaceString, $convertCase ) = @_;
|
|
local( $dstString );
|
|
#printf("Input:$tstString,$replaceString\n");
|
|
$tstString=cutWhiteSpace($tstString);
|
|
$replaceString=cutWhiteSpace($replaceString);
|
|
if($tstString eq "")
|
|
{
|
|
$dstString = $replaceString;
|
|
} else
|
|
{
|
|
$dstString = $tstString;
|
|
}
|
|
|
|
# Convert to Lower Case?
|
|
#
|
|
if($convertCase == 1)
|
|
{
|
|
$dstString =~ lc($dstString);
|
|
}
|
|
# Convert to Upper Case?
|
|
#
|
|
elsif($convertCase == 2)
|
|
{
|
|
$dstString =~ uc($dstString);
|
|
}
|
|
#printf("Output:$dstString:\n");
|
|
return($dstString);
|
|
}
|
|
|
|
# Subroutine to generate a unique name by adding 2 digits onto the end of it. A hash of existing
|
|
# names is given to compare the new value against.
|
|
#
|
|
sub getUniqueName
|
|
{
|
|
local( $cnt, $uniqueName ) = ( 0, "" );
|
|
local( $startName, $maxLen, $usedNames ) = @_;
|
|
|
|
# Go through looping, adding a unique number onto the end of the string, then looking it
|
|
# up to see if it already exists.
|
|
#
|
|
$uniqueName = substr($startName, 0, $maxLen);
|
|
while(defined($$usedNames{$uniqueName}))
|
|
{
|
|
$uniqueName = substr($uniqueName, 0, $maxLen-2) . sprintf("%02d", $cnt);
|
|
$cnt++;
|
|
if($cnt > 99)
|
|
{
|
|
logWrite("die", "Unique identifier > 99: $uniqueName");
|
|
}
|
|
}
|
|
|
|
# Return unique name.
|
|
#
|
|
return($uniqueName);
|
|
}
|
|
|
|
# Sub-routine to process command line arguments. New style POSIX argument format used.
|
|
#
|
|
sub argOptions
|
|
{
|
|
local ( $writeUsage, $msg, $exitCode ) = @_;
|
|
|
|
if( $writeUsage == 1 )
|
|
{
|
|
print STDOUT "Usage: $PROGNAME <commands> [<options>] \n";
|
|
print STDOUT " commands= --help |\n";
|
|
print STDOUT " --command=<64KRAM|MONROM|CGROM|KEYMAP> |\n";
|
|
print STDOUT " --binout=<file> |\n";
|
|
print STDOUT " --mifout=<file> |\n";
|
|
print STDOUT " --a_mrom=<file> |\n";
|
|
print STDOUT " --b_mrom=<file> |\n";
|
|
print STDOUT " --c_mrom=<file> |\n";
|
|
print STDOUT " --k_mrom=<file> |\n";
|
|
print STDOUT " --7_mrom=<file> |\n";
|
|
print STDOUT " --8_mrom=<file> |\n";
|
|
print STDOUT " --12_mrom=<file> |\n";
|
|
print STDOUT " --20_mrom=<file> |\n";
|
|
print STDOUT " --a_80c_mrom=<file> |\n";
|
|
print STDOUT " --b_80c_mrom=<file> |\n";
|
|
print STDOUT " --c_80c_mrom=<file> |\n";
|
|
print STDOUT " --k_80c_mrom=<file> |\n";
|
|
print STDOUT " --7_80c_mrom=<file> |\n";
|
|
print STDOUT " --8_80c_mrom=<file> |\n";
|
|
print STDOUT " --12_80c_mrom=<file> |\n";
|
|
print STDOUT " --20_80c_mrom=<file> |\n";
|
|
print STDOUT " --a_userrom=<file> |\n";
|
|
print STDOUT " --b_userrom=<file> |\n";
|
|
print STDOUT " --c_userrom=<file> |\n";
|
|
print STDOUT " --k_userrom=<file> |\n";
|
|
print STDOUT " --7_userrom=<file> |\n";
|
|
print STDOUT " --8_userrom=<file> |\n";
|
|
print STDOUT " --12_userrom=<file> |\n";
|
|
print STDOUT " --20_userrom=<file> |\n";
|
|
print STDOUT " --a_fdcrom=<file> |\n";
|
|
print STDOUT " --b_fdcrom=<file> |\n";
|
|
print STDOUT " --c_fdcrom=<file> |\n";
|
|
print STDOUT " --k_fdcrom=<file> |\n";
|
|
print STDOUT " --7_fdcrom=<file> |\n";
|
|
print STDOUT " --8_fdcrom=<file> |\n";
|
|
print STDOUT " --12_fdcrom=<file> |\n";
|
|
print STDOUT " --20_fdcrom=<file> |\n";
|
|
print STDOUT " --mzffile=<file> |\n";
|
|
print STDOUT " --ramchecker=<file> |\n";
|
|
print STDOUT " --a_cgrom=<file> |\n";
|
|
print STDOUT " --b_cgrom=<file> |\n";
|
|
print STDOUT " --c_cgrom=<file> |\n";
|
|
print STDOUT " --k_cgrom=<file> |\n";
|
|
print STDOUT " --7_cgrom=<file> |\n";
|
|
print STDOUT " --12_cgrom=<file> |\n";
|
|
print STDOUT " --20_cgrom=<file> |\n";
|
|
print STDOUT " --a_keymap=<file> |\n";
|
|
print STDOUT " --b_keymap=<file> |\n";
|
|
print STDOUT " --c_keymap=<file> |\n";
|
|
print STDOUT " --k_keymap=<file> |\n";
|
|
print STDOUT " --7_keymap=<file> |\n";
|
|
print STDOUT " --8_keymap=<file> |\n";
|
|
print STDOUT " --12_keymap=<file> |\n";
|
|
print STDOUT " --20_keymap=<file> |\n";
|
|
print STDOUT " options = --debug=<1=ON, 0=OFF>\n";
|
|
print STDOUT "\n";
|
|
}
|
|
if($msg ne "")
|
|
{
|
|
print STDOUT "Error: $msg\n";
|
|
}
|
|
exit( $exitCode );
|
|
}
|
|
|
|
# Subroutine to create a Memory Initialization File.
|
|
#
|
|
sub createMIF
|
|
{
|
|
local ($Memory, $OUTPUT) = @_;
|
|
#local @Memory = @{$_[0]};
|
|
# local $OUTPUT = $_[1];
|
|
|
|
$addr = 0x0000;
|
|
$depth = scalar @$Memory;
|
|
$width = 8;
|
|
|
|
print $OUTPUT "DEPTH = $depth;\n";
|
|
print $OUTPUT "WIDTH = $width;\n";
|
|
print $OUTPUT "ADDRESS_RADIX = HEX;\n";
|
|
print $OUTPUT "DATA_RADIX = HEX;\n";
|
|
print $OUTPUT "CONTENT BEGIN\n";
|
|
|
|
for($addr=0; $addr < $depth; $addr+=16)
|
|
{
|
|
my $thisLineCount = ($depth > $addr + 16) ? 16 : $depth - $addr;
|
|
printf $OUTPUT "%04x: ", $addr;
|
|
$line = "";
|
|
for(my $byteaddr=0; $byteaddr < $thisLineCount; $byteaddr++)
|
|
{
|
|
if($byteaddr > 0) { $line .= " "; }
|
|
$line .= unpack("H2", @$Memory[$byteaddr + $addr]);
|
|
}
|
|
print $OUTPUT "$line;\n";
|
|
}
|
|
|
|
print $OUTPUT "END;\n";
|
|
}
|
|
|
|
##################################################################################
|
|
# END OF GENERIC SUB-ROUTINES
|
|
##################################################################################
|
|
|
|
|
|
##################################################################################
|
|
#
|
|
# MAIN PROGRAM
|
|
#
|
|
##################################################################################
|
|
|
|
# Locals.
|
|
#
|
|
local( $time, $date, $mzfExists, $a_mromExists, $b_mromExists, $k_mromExists, $m7_mromExists, $m8_mromExists, $m12_mromExists, $m20_mromExists,
|
|
$a_80c_mromExists, $b_80c_mromExists, $k_80c_mromExists, $m7_80c_mromExists, $m8_80c_mromExists, $m12_80c_mromExists, $m20_80c_mromExists,
|
|
$mzf_type, $mzf_filename, $mzf_size, $mzf_loadaddr, $mzf_execaddr, $mzf_comment);
|
|
|
|
# Get current time and date.
|
|
#
|
|
$time = `date +'%H:%M:%S'`;
|
|
$date = `date +'%d.%m.%Y'`;
|
|
chomp($time);
|
|
chomp($date);
|
|
|
|
# Sign-on.
|
|
#
|
|
print STDOUT "$TITLE (v$VERSION) \@ ${VERSIONDATE}\n\n";
|
|
|
|
# Parse arguments and put into required variables.
|
|
#
|
|
GetOptions( "debug=n" => \$debugMode, # Debug Mode?
|
|
"command=s" => \$command, # Command to execute.
|
|
"binout=s" => \$outFile, # Binary output file to be created.
|
|
"mifout=s" => \$mifoutFile, # MIF output file to be created.
|
|
"a_mrom=s" => \$modelA_mromFile, # MZ80A Monitor ROM file.
|
|
"b_mrom=s" => \$modelB_mromFile, # MZ80B Monitor ROM file.
|
|
"c_mrom=s" => \$modelC_mromFile, # MZ80C Monitor ROM file.
|
|
"k_mrom=s" => \$modelK_mromFile, # MZ80K Monitor ROM file.
|
|
"7_mrom=s" => \$model7_mromFile, # MZ700 Monitor ROM file.
|
|
"8_mrom=s" => \$model8_mromFile, # MZ800 Monitor ROM file.
|
|
"12_mrom=s" => \$model12_mromFile, # MZ1200 Monitor ROM file.
|
|
"20_mrom=s" => \$model20_mromFile, # MZ2000 Monitor ROM file.
|
|
"a_80c_mrom=s" => \$modelA_80c_mromFile, # MZ80A Monitor 80x25 Display ROM file.
|
|
"b_80c_mrom=s" => \$modelB_80c_mromFile, # MZ80B Monitor 80x25 Display ROM file.
|
|
"c_80c_mrom=s" => \$modelC_80c_mromFile, # MZ80C Monitor 80x25 Display ROM file.
|
|
"k_80c_mrom=s" => \$modelK_80c_mromFile, # MZ80K Monitor 80x25 Display ROM file.
|
|
"7_80c_mrom=s" => \$model7_80c_mromFile, # MZ700 Monitor 80x25 Display ROM file.
|
|
"8_80c_mrom=s" => \$model8_80c_mromFile, # MZ800 Monitor 80x25 Display ROM file.
|
|
"12_80c_mrom=s" => \$model12_80c_mromFile, # MZ1200 Monitor 80x25 Display ROM file.
|
|
"20_80c_mrom=s" => \$model20_80c_mromFile, # MZ2000 Monitor 80x25 Display ROM file.
|
|
"a_userrom=s" => \$modelA_userromFile, # MZ80A User ROM file.
|
|
"b_userrom=s" => \$modelB_userromFile, # MZ80B User ROM file.
|
|
"c_userrom=s" => \$modelC_userromFile, # MZ80C User ROM file.
|
|
"k_userrom=s" => \$modelK_userromFile, # MZ80K User ROM file.
|
|
"7_userrom=s" => \$model7_userromFile, # MZ700 User ROM file.
|
|
"8_userrom=s" => \$model8_userromFile, # MZ800 User ROM file.
|
|
"12_userrom=s" => \$model12_userromFile, # MZ1200 User ROM file.
|
|
"20_userrom=s" => \$model20_userromFile, # MZ2000 User ROM file.
|
|
"a_fdcrom=s" => \$modelA_fdcromFile, # MZ80A FDC ROM file.
|
|
"b_fdcrom=s" => \$modelB_fdcromFile, # MZ80B FDC ROM file.
|
|
"c_fdcrom=s" => \$modelC_fdcromFile, # MZ80C FDC ROM file.
|
|
"k_fdcrom=s" => \$modelK_fdcromFile, # MZ80K FDC ROM file.
|
|
"7_fdcrom=s" => \$model7_fdcromFile, # MZ700 FDC ROM file.
|
|
"8_fdcrom=s" => \$model8_fdcromFile, # MZ800 FDC ROM file.
|
|
"12_fdcrom=s" => \$model12_fdcromFile, # MZ1200 User ROM file.
|
|
"20_fdcrom=s" => \$model20_fdcromFile, # MZ2000 User ROM file.
|
|
"mzffile=s" => \$mzfFile, # MZF file.
|
|
"ramchecker=s" => \$ramcheckFile, # Ram Tester program.
|
|
"a_cgrom=s" => \$modelA_CGFile, # Model 80A CG Rom.
|
|
"b_cgrom=s" => \$modelB_CGFile, # Model 80B CG Rom.
|
|
"c_cgrom=s" => \$modelC_CGFile, # Model 80C CG Rom.
|
|
"k_cgrom=s" => \$modelK_CGFile, # Model 80K CG Rom.
|
|
"7_cgrom=s" => \$model7_CGFile, # Model 700 CG Rom.
|
|
"8_cgrom=s" => \$model8_CGFile, # Model 800 CG Rom.
|
|
"12_cgrom=s" => \$model12_CGFile, # Model 1200 CG Rom.
|
|
"20_cgrom=s" => \$model20_CGFile, # Model 2000 CG Rom.
|
|
"a_keymap=s" => \$modelA_KeyFile, # Model 80A Key Map File
|
|
"b_keymap=s" => \$modelB_KeyFile, # Model 80B Key Map File
|
|
"c_keymap=s" => \$modelC_KeyFile, # Model 80C Key Map File
|
|
"k_keymap=s" => \$modelK_KeyFile, # Model 80K Key Map File
|
|
"7_keymap=s" => \$model7_KeyFile, # Model 700 Key Map File
|
|
"8_keymap=s" => \$model8_KeyFile, # Model 800 Key Map File
|
|
"12_keymap=s" => \$model12_KeyFile, # Model 1200 Key Map File
|
|
"20_keymap=s" => \$model20_KeyFile, # Model 2000 Key Map File
|
|
"help" => \$help, # Help required on commands/options?
|
|
);
|
|
|
|
# Help required?
|
|
#
|
|
if(defined($help))
|
|
{
|
|
argOptions(1, "");
|
|
}
|
|
|
|
# Verify command.
|
|
#
|
|
if($command eq "64KRAM" || $command eq "MONROM" || $command eq "CGROM" || $command eq "KEYMAP")
|
|
{
|
|
logWrite("", "Creating binary output file for command:$command.");
|
|
}
|
|
else
|
|
{
|
|
argOptions(1, "Illegal command given on command line:$command.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
|
|
# Output file.
|
|
# #
|
|
if(defined($outFile) && $outFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $outFile ne "" && ! open(OUTFILE, ">".$outFile) )
|
|
{
|
|
argOptions(1, "Cannot create output file: $outFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
argOptions(1, "No output file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
binmode(OUTFILE);
|
|
|
|
# MIF Output file.
|
|
# #
|
|
if(defined($mifoutFile) && $mifoutFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $mifoutFile ne "" && ! open(MIFOUTFILE, ">".$mifoutFile) )
|
|
{
|
|
argOptions(1, "Cannot create MIF output file: $mifoutFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$createMIF=1;
|
|
} else
|
|
{
|
|
$createMIF=0;
|
|
}
|
|
|
|
# An MZF file is not mandatory, if it exists then we must be able to open and read, if it
|
|
# doesnt exist, zero's will be used in the initialization image.
|
|
#
|
|
if(defined($mzfFile) && $mzfFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $mzfFile ne "" && ! open(MZFFILE, "<".$mzfFile) )
|
|
{
|
|
argOptions(1, "Cannot open MZF file: $mzfFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
|
|
$mzfExists = 1;
|
|
} else
|
|
{
|
|
$mzfExists = 0;
|
|
}
|
|
|
|
# A Ram Checker program loaded into high memory.
|
|
#
|
|
if(defined($ramcheckFile) && $ramcheckFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $ramcheckFile ne "" && ! open(RAMCHECKFILE, "<".$ramcheckFile) )
|
|
{
|
|
argOptions(1, "Cannot open MZF file: $ramcheckFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
|
|
$ramcheckExists = 1;
|
|
} else
|
|
{
|
|
$ramcheckExists = 0;
|
|
}
|
|
|
|
# Verify all options, easier to use tool at a later stage when memory of the project fades!!
|
|
#
|
|
if(defined($modelA_mromFile) && $modelA_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelA_mromFile ne "" && ! open(A_MROMFILE, "<".$modelA_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $modelA_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$a_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80A Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$a_mromExists = 0;
|
|
}
|
|
if(defined($modelB_mromFile) && $modelB_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelB_mromFile ne "" && ! open(B_MROMFILE, "<".$modelB_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $modelB_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$b_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80B Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$b_mromExists = 0;
|
|
}
|
|
if(defined($modelC_mromFile) && $modelC_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelC_mromFile ne "" && ! open(C_MROMFILE, "<".$modelC_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $modelC_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80C Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$c_mromExists = 0;
|
|
}
|
|
if(defined($modelK_mromFile) && $modelK_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelK_mromFile ne "" && ! open(K_MROMFILE, "<".$modelK_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $modelK_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$k_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80K Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$k_mromExists = 0;
|
|
}
|
|
if(defined($model7_mromFile) && $model7_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model7_mromFile ne "" && ! open(M7_MROMFILE, "<".$model7_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $model7_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m7_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ700 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m7_mromExists = 0;
|
|
}
|
|
if(defined($model8_mromFile) && $model8_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model8_mromFile ne "" && ! open(M8_MROMFILE, "<".$model8_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $model8_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m8_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ800 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m8_mromExists = 0;
|
|
}
|
|
if(defined($model12_mromFile) && $model12_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model12_mromFile ne "" && ! open(M12_MROMFILE, "<".$model12_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $model12_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m12_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ1200 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m12_mromExists = 0;
|
|
}
|
|
if(defined($model20_mromFile) && $model20_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model20_mromFile ne "" && ! open(M20_MROMFILE, "<".$model20_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open Monitor ROM file: $model20_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m20_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ2000 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m20_mromExists = 0;
|
|
}
|
|
#
|
|
if(defined($modelA_80c_mromFile) && $modelA_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelA_80c_mromFile ne "" && ! open(A_80C_MROMFILE, "<".$modelA_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $modelA_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$a_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80A 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$a_80c_mromExists = 0;
|
|
}
|
|
if(defined($modelB_80c_mromFile) && $modelB_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelB_80c_mromFile ne "" && ! open(B_80C_MROMFILE, "<".$modelB_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $modelB_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$b_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80B 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$b_80c_mromExists = 0;
|
|
}
|
|
if(defined($modelC_80c_mromFile) && $modelC_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelC_80c_mromFile ne "" && ! open(C_80C_MROMFILE, "<".$modelC_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $modelC_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$c_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80C 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$c_80c_mromExists = 0;
|
|
}
|
|
if(defined($modelK_80c_mromFile) && $modelK_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelK_80c_mromFile ne "" && ! open(K_80C_MROMFILE, "<".$modelK_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $modelK_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$k_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80K 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$k_80c_mromExists = 0;
|
|
}
|
|
if(defined($model7_80c_mromFile) && $model7_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model7_80c_mromFile ne "" && ! open(M7_80C_MROMFILE, "<".$model7_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $model7_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m7_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ700 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m7_80c_mromExists = 0;
|
|
}
|
|
if(defined($model8_80c_mromFile) && $model8_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model8_80c_mromFile ne "" && ! open(M8_80C_MROMFILE, "<".$model8_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $model8_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m8_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ700 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m8_80c_mromExists = 0;
|
|
}
|
|
if(defined($model12_80c_mromFile) && $model12_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model12_80c_mromFile ne "" && ! open(M12_80C_MROMFILE, "<".$model12_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $model12_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m12_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ1200 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m12_80c_mromExists = 0;
|
|
}
|
|
if(defined($model20_80c_mromFile) && $model20_80c_mromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model20_80c_mromFile ne "" && ! open(M20_80C_MROMFILE, "<".$model20_80c_mromFile) )
|
|
{
|
|
argOptions(1, "Cannot open 80x25 Monitor ROM file: $model20_80c_mromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m20_80c_mromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ1200 80x25 Monitor ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m20_80c_mromExists = 0;
|
|
}
|
|
#
|
|
# User Rom
|
|
#
|
|
if(defined($modelA_userromFile) && $modelA_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelA_userromFile ne "" && ! open(A_USERROMFILE, "<".$modelA_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $modelA_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$a_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80A User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$a_userromExists = 0;
|
|
}
|
|
if(defined($modelB_userromFile) && $modelB_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelB_userromFile ne "" && ! open(B_USERROMFILE, "<".$modelB_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $modelB_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$b_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80B User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$b_userromExists = 0;
|
|
}
|
|
if(defined($modelC_userromFile) && $modelC_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelC_userromFile ne "" && ! open(C_USERROMFILE, "<".$modelC_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $modelC_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$c_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80C User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$c_userromExists = 0;
|
|
}
|
|
if(defined($modelK_userromFile) && $modelK_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelK_userromFile ne "" && ! open(K_USERROMFILE, "<".$modelK_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $modelK_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$k_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80K User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$k_userromExists = 0;
|
|
}
|
|
if(defined($model7_userromFile) && $model7_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model7_userromFile ne "" && ! open(M7_USERROMFILE, "<".$model7_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $model7_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m7_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ700 User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m7_userromExists = 0;
|
|
}
|
|
if(defined($model8_userromFile) && $model8_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model8_userromFile ne "" && ! open(M8_USERROMFILE, "<".$model8_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $model8_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m8_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ800 User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m8_userromExists = 0;
|
|
}
|
|
if(defined($model12_userromFile) && $model12_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model12_userromFile ne "" && ! open(M12_USERROMFILE, "<".$model12_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $model12_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m12_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ1200 User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m12_userromExists = 0;
|
|
}
|
|
if(defined($model20_userromFile) && $model20_userromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model20_userromFile ne "" && ! open(M20_USERROMFILE, "<".$model20_userromFile) )
|
|
{
|
|
argOptions(1, "Cannot open User ROM file: $model20_userromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m20_userromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ2000 User ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m20_userromExists = 0;
|
|
}
|
|
#
|
|
# Floppy Disk Controller Rom
|
|
#
|
|
if(defined($modelA_fdcromFile) && $modelA_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelA_fdcromFile ne "" && ! open(A_FDCROMFILE, "<".$modelA_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $modelA_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$a_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80A FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$a_fdcromExists = 0;
|
|
}
|
|
if(defined($modelB_fdcromFile) && $modelB_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelB_fdcromFile ne "" && ! open(B_FDCROMFILE, "<".$modelB_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $modelB_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$b_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80B FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$b_fdcromExists = 0;
|
|
}
|
|
if(defined($modelC_fdcromFile) && $modelC_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelC_fdcromFile ne "" && ! open(C_FDCROMFILE, "<".$modelC_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $modelC_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$c_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80C FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$c_fdcromExists = 0;
|
|
}
|
|
if(defined($modelK_fdcromFile) && $modelK_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelK_fdcromFile ne "" && ! open(K_FDCROMFILE, "<".$modelK_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $modelK_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$k_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ80K FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$k_fdcromExists = 0;
|
|
}
|
|
if(defined($model7_fdcromFile) && $model7_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model7_fdcromFile ne "" && ! open(M7_FDCROMFILE, "<".$model7_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $model7_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m7_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ700 FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m7_fdcromExists = 0;
|
|
}
|
|
if(defined($model8_fdcromFile) && $model8_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model8_fdcromFile ne "" && ! open(M8_FDCROMFILE, "<".$model8_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $model8_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m8_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ800 FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m8_fdcromExists = 0;
|
|
}
|
|
if(defined($model12_fdcromFile) && $model12_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model12_fdcromFile ne "" && ! open(M12_FDCROMFILE, "<".$model12_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $model12_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m12_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ1200 FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m12_fdcromExists = 0;
|
|
}
|
|
if(defined($model20_fdcromFile) && $model20_fdcromFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model20_fdcromFile ne "" && ! open(M20_FDCROMFILE, "<".$model20_fdcromFile) )
|
|
{
|
|
argOptions(1, "Cannot open FDC ROM file: $model20_fdcromFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
$m20_fdcromExists = 1;
|
|
} else
|
|
{
|
|
if($command eq "MONROM")
|
|
{
|
|
argOptions(1, "No MZ2000 FDC ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
$m20_fdcromExists = 0;
|
|
}
|
|
#
|
|
# Checks
|
|
#
|
|
if($command eq "64KRAM" && $a_mromExists == 0 && $b_mromExists && $c_mromExists && $k_mromExists && $m7_mromExists && $m8_mromExists && $m12_mromExists && $m20_mromExists &&
|
|
$a_80c_mromExists == 0 && $b_80c_mromExists && $c_80c_mromExists && $k_80c_mromExists && $m7_80c_mromExists && $m8_80c_mromExists && $m12_80c_mromExists && $m20_80c_mromExists &&
|
|
$a_userromExists == 0 && $b_userromExists && $c_userromExists && $k_userromExists && $m7_userromExists && $m8_userromExists && $m12_userromExists && $m20_userromExists &&
|
|
$a_fdcromExists == 0 && $b_fdcromExists && $c_fdcromExists && $k_fdcromExists && $m7_fdcromExists && $m8_fdcromExists && $m12_fdcromExists && $m20_fdcromExists
|
|
)
|
|
{
|
|
argOptions(1, "No Monitor ROM file given for 64K RAM mode..\n",$ERR_BADARGUMENTS);
|
|
}
|
|
#
|
|
if($command eq "64KRAM" && ($a_mromExists + $b_mromExists + $c_mromExists + $k_mromExists + $m7_mromExists + $m8_mromExists + $m12_mromExists + $m20_mromExists +
|
|
$a_80c_mromExists + $b_80c_mromExists + $c_80c_mromExists + $k_80c_mromExists + $m7_80c_mromExists + $m8_80c_mromExists + $m12_80c_mromExists + $m20_80c_mromExists
|
|
) > 1)
|
|
{
|
|
argOptions(1, "You must only specify one Monitor ROM for 64K RAM mode..\n",$ERR_BADARGUMENTS);
|
|
}
|
|
if($command eq "64KRAM" && ($a_userromExists + $b_userromExists + $c_userromExists + $k_userromExists + $m7_userromExists + $m8_userromExists + $m12_userromExists + $m20_userromExists
|
|
) > 1)
|
|
{
|
|
argOptions(1, "You must only specify one User ROM for 64K RAM mode..\n",$ERR_BADARGUMENTS);
|
|
}
|
|
if($command eq "64KRAM" && ($a_fdcromExists + $b_fdcromExists + $c_fdcromExists + $k_fdcromExists + $m7_fdcromExists + $m8_fdcromExists + $m12_fdcromExists + $m20_fdcromExists
|
|
) > 1)
|
|
{
|
|
argOptions(1, "You must only specify one FDC ROM for 64K RAM mode..\n",$ERR_BADARGUMENTS);
|
|
}
|
|
|
|
if(defined($modelA_CGFile) && $modelA_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelA_CGFile ne "" && ! open(A_CGFILE, "<".$modelA_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $modelA_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ80A CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($modelB_CGFile) && $modelB_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelB_CGFile ne "" && ! open(B_CGFILE, "<".$modelB_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $modelB_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ80B CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($modelC_CGFile) && $modelC_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelC_CGFile ne "" && ! open(C_CGFILE, "<".$modelC_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $modelC_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ80C CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($modelK_CGFile) && $modelK_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelK_CGFile ne "" && ! open(K_CGFILE, "<".$modelK_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $modelK_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ80K CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model7_CGFile) && $model7_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model7_CGFile ne "" && ! open(M7_CGFILE, "<".$model7_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $model7_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ700 CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model8_CGFile) && $model8_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model8_CGFile ne "" && ! open(M8_CGFILE, "<".$model8_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $model8_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ800 CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model12_CGFile) && $model12_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model12_CGFile ne "" && ! open(M12_CGFILE, "<".$model12_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $model12_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ1200 CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model20_CGFile) && $model20_CGFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model20_CGFile ne "" && ! open(M20_CGFILE, "<".$model20_CGFile) )
|
|
{
|
|
argOptions(1, "Cannot open CG ROM file: $model20_CGFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "CGROM")
|
|
{
|
|
argOptions(1, "No MZ2000 CG ROM file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
|
|
if(defined($modelA_KeyFile) && $modelA_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelA_KeyFile ne "" && ! open(A_KEYFILE, "<".$modelA_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $modelA_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ80A Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($modelB_KeyFile) && $modelB_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelB_KeyFile ne "" && ! open(B_KEYFILE, "<".$modelB_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $modelB_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ80B Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($modelC_KeyFile) && $modelC_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelC_KeyFile ne "" && ! open(C_KEYFILE, "<".$modelC_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $modelC_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ80C Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($modelK_KeyFile) && $modelK_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $modelK_KeyFile ne "" && ! open(K_KEYFILE, "<".$modelK_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $modelK_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ80K Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model7_KeyFile) && $model7_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model7_KeyFile ne "" && ! open(M7_KEYFILE, "<".$model7_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $model7_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ700 Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model8_KeyFile) && $model8_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model8_KeyFile ne "" && ! open(M8_KEYFILE, "<".$model8_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $model8_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ800 Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model12_KeyFile) && $model12_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model12_KeyFile ne "" && ! open(M12_KEYFILE, "<".$model12_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $model12_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ1200 Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
if(defined($model20_KeyFile) && $model20_KeyFile ne "")
|
|
{
|
|
# If defined, can we open it?
|
|
#
|
|
if( $model20_KeyFile ne "" && ! open(M20_KEYFILE, "<".$model20_KeyFile) )
|
|
{
|
|
argOptions(1, "Cannot open Key Map file: $model20_KeyFile.\n",$ERR_BADFILENAME);
|
|
}
|
|
} else
|
|
{
|
|
if($command eq "KEYMAP")
|
|
{
|
|
argOptions(1, "No MZ2000 Key Map file given.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
}
|
|
|
|
##############################################################################################################
|
|
# Commands:
|
|
# 64KRAM = Create Image for 64K RAM initialisation.
|
|
# MROM + MZF + ZERO
|
|
# MONROM = Create Image for Monitor ROM initialisation.
|
|
# MROM(K) + MROM(C) + MROM(1200) + MROM(A) + MROM(700) + MROM(B)
|
|
# CGROM = Create Image for Character Generator ROM initialisation.
|
|
# CGROM(K) + CGROM(C) + CGROM(1200) + CGROM(A) + CGROM(700) + CGROM(B)
|
|
# KEYMAP = Create Image for Key Map ROM initialization.
|
|
# KEYMAP(K) + KEYMAP(C) + KEYMAP(1200) + KEYMAP(A) + KEYMAP(700) + KEYMAP(B)
|
|
##############################################################################################################
|
|
|
|
# Read all opened files into memory, dirty but easier to process.
|
|
#
|
|
if($command eq "64KRAM" || $command eq "MONROM")
|
|
{
|
|
# Read in MZF file if given.
|
|
if($mzfExists == 1)
|
|
{
|
|
@A_MZF = ();
|
|
binmode(MZFFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <MZFFILE> )
|
|
{
|
|
$A_MZF[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_MZF_SIZE = $cnt;
|
|
}
|
|
|
|
# Read in MZF file if given.
|
|
if($ramcheckExists == 1)
|
|
{
|
|
@RAMCHECK = ();
|
|
binmode(RAMCHECKFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <RAMCHECKFILE> )
|
|
{
|
|
$RAMCHECK[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$RAMCHECK_SIZE = $cnt;
|
|
}
|
|
|
|
if($a_mromExists == 1)
|
|
{
|
|
@A_MROM = ();
|
|
binmode(A_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <A_MROMFILE> )
|
|
{
|
|
$A_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($b_mromExists == 1)
|
|
{
|
|
@B_MROM = ();
|
|
binmode(B_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <B_MROMFILE> )
|
|
{
|
|
$B_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$B_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($c_mromExists == 1)
|
|
{
|
|
@C_MROM = ();
|
|
binmode(C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <C_MROMFILE> )
|
|
{
|
|
$C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($k_mromExists == 1)
|
|
{
|
|
@K_MROM = ();
|
|
binmode(K_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <K_MROMFILE> )
|
|
{
|
|
$K_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$K_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m7_mromExists == 1)
|
|
{
|
|
@M7_MROM = ();
|
|
binmode(M7_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M7_MROMFILE> )
|
|
{
|
|
$M7_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M7_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m8_mromExists == 1)
|
|
{
|
|
@M8_MROM = ();
|
|
binmode(M8_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M8_MROMFILE> )
|
|
{
|
|
$M8_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M8_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m12_mromExists == 1)
|
|
{
|
|
@M12_MROM = ();
|
|
binmode(M12_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M12_MROMFILE> )
|
|
{
|
|
$M12_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M12_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m20_mromExists == 1)
|
|
{
|
|
@M20_MROM = ();
|
|
binmode(M20_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M20_MROMFILE> )
|
|
{
|
|
$M20_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M20_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($a_80c_mromExists == 1)
|
|
{
|
|
@A_80C_MROM = ();
|
|
binmode(A_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <A_80C_MROMFILE> )
|
|
{
|
|
$A_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($b_80c_mromExists == 1)
|
|
{
|
|
@B_80C_MROM = ();
|
|
binmode(B_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <B_80C_MROMFILE> )
|
|
{
|
|
$B_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$B_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($c_80c_mromExists == 1)
|
|
{
|
|
@C_80C_MROM = ();
|
|
binmode(C_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <C_80C_MROMFILE> )
|
|
{
|
|
$C_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$C_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($k_80c_mromExists == 1)
|
|
{
|
|
@K_80C_MROM = ();
|
|
binmode(K_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <K_80C_MROMFILE> )
|
|
{
|
|
$K_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$K_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m7_80c_mromExists == 1)
|
|
{
|
|
@M7_80C_MROM = ();
|
|
binmode(M7_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M7_80C_MROMFILE> )
|
|
{
|
|
$M7_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M7_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m8_80c_mromExists == 1)
|
|
{
|
|
@M8_80C_MROM = ();
|
|
binmode(M8_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M8_80C_MROMFILE> )
|
|
{
|
|
$M8_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M8_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m12_80c_mromExists == 1)
|
|
{
|
|
@M12_80C_MROM = ();
|
|
binmode(M12_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M12_80C_MROMFILE> )
|
|
{
|
|
$M12_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M12_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m20_80c_mromExists == 1)
|
|
{
|
|
@M20_80C_MROM = ();
|
|
binmode(M20_80C_MROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M20_80C_MROMFILE> )
|
|
{
|
|
$M20_80C_MROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M20_80C_MROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($a_userromExists == 1)
|
|
{
|
|
@A_USERROM = ();
|
|
binmode(A_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <A_USERROMFILE> )
|
|
{
|
|
$A_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($b_userromExists == 1)
|
|
{
|
|
@B_USERROM = ();
|
|
binmode(B_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <B_USERROMFILE> )
|
|
{
|
|
$B_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$B_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($c_userromExists == 1)
|
|
{
|
|
@C_USERROM = ();
|
|
binmode(C_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <C_USERROMFILE> )
|
|
{
|
|
$C_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$C_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($k_userromExists == 1)
|
|
{
|
|
@K_USERROM = ();
|
|
binmode(K_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <K_USERROMFILE> )
|
|
{
|
|
$K_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$K_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m7_userromExists == 1)
|
|
{
|
|
@M7_USERROM = ();
|
|
binmode(M7_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M7_USERROMFILE> )
|
|
{
|
|
$M7_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M7_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m8_userromExists == 1)
|
|
{
|
|
@M8_USERROM = ();
|
|
binmode(M8_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M8_USERROMFILE> )
|
|
{
|
|
$M8_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M8_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m12_userromExists == 1)
|
|
{
|
|
@M12_USERROM = ();
|
|
binmode(M12_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M12_USERROMFILE> )
|
|
{
|
|
$M12_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M12_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m20_userromExists == 1)
|
|
{
|
|
@M20_USERROM = ();
|
|
binmode(M20_USERROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M20_USERROMFILE> )
|
|
{
|
|
$M20_USERROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M20_USERROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($a_fdcromExists == 1)
|
|
{
|
|
@A_FDCROM = ();
|
|
binmode(A_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <A_FDCROMFILE> )
|
|
{
|
|
$A_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($b_fdcromExists == 1)
|
|
{
|
|
@B_FDCROM = ();
|
|
binmode(B_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <B_FDCROMFILE> )
|
|
{
|
|
$B_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$B_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($c_fdcromExists == 1)
|
|
{
|
|
@C_FDCROM = ();
|
|
binmode(C_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <C_FDCROMFILE> )
|
|
{
|
|
$C_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$C_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($k_fdcromExists == 1)
|
|
{
|
|
@K_FDCROM = ();
|
|
binmode(K_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <K_FDCROMFILE> )
|
|
{
|
|
$K_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$K_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m7_fdcromExists == 1)
|
|
{
|
|
@M7_FDCROM = ();
|
|
binmode(M7_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M7_FDCROMFILE> )
|
|
{
|
|
$M7_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M7_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m8_fdcromExists == 1)
|
|
{
|
|
@M8_FDCROM = ();
|
|
binmode(M8_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M8_FDCROMFILE> )
|
|
{
|
|
$M8_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M8_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m12_fdcromExists == 1)
|
|
{
|
|
@M12_FDCROM = ();
|
|
binmode(M12_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M12_FDCROMFILE> )
|
|
{
|
|
$M12_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M12_FDCROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($m20_fdcromExists == 1)
|
|
{
|
|
@M20_FDCROM = ();
|
|
binmode(M20_FDCROMFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M20_FDCROMFILE> )
|
|
{
|
|
$M20_FDCROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M20_FDCROM_SIZE = $cnt;
|
|
}
|
|
}
|
|
|
|
if($command eq "CGROM")
|
|
{
|
|
@A_CGROM = ();
|
|
binmode(A_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <A_CGFILE> )
|
|
{
|
|
$A_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_CGROM_SIZE = $cnt;
|
|
|
|
@B_CGROM = ();
|
|
binmode(B_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <B_CGFILE> )
|
|
{
|
|
$B_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$B_CGROM_SIZE = $cnt;
|
|
|
|
@C_CGROM = ();
|
|
binmode(C_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <C_CGFILE> )
|
|
{
|
|
$C_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$C_CGROM_SIZE = $cnt;
|
|
|
|
@K_CGROM = ();
|
|
binmode(K_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <K_CGFILE> )
|
|
{
|
|
$K_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$K_CGROM_SIZE = $cnt;
|
|
|
|
@M7_CGROM = ();
|
|
binmode(M7_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M7_CGFILE> )
|
|
{
|
|
$M7_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M7_CGROM_SIZE = $cnt;
|
|
|
|
@M8_CGROM = ();
|
|
binmode(M8_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M8_CGFILE> )
|
|
{
|
|
$M8_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M8_CGROM_SIZE = $cnt;
|
|
|
|
@M12_CGROM = ();
|
|
binmode(M12_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M12_CGFILE> )
|
|
{
|
|
$M12_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M12_CGROM_SIZE = $cnt;
|
|
|
|
@M20_CGROM = ();
|
|
binmode(M20_CGFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M20_CGFILE> )
|
|
{
|
|
$M20_CGROM[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M20_CGROM_SIZE = $cnt;
|
|
}
|
|
|
|
if($command eq "KEYMAP")
|
|
{
|
|
@A_KEYMAP = ();
|
|
binmode(A_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <A_KEYFILE> )
|
|
{
|
|
$A_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$A_KEYMAP_SIZE = $cnt;
|
|
|
|
@B_KEYMAP = ();
|
|
binmode(B_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <B_KEYFILE> )
|
|
{
|
|
$B_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$B_KEYMAP_SIZE = $cnt;
|
|
|
|
@C_KEYMAP = ();
|
|
binmode(C_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <C_KEYFILE> )
|
|
{
|
|
$C_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$C_KEYMAP_SIZE = $cnt;
|
|
|
|
@K_KEYMAP = ();
|
|
binmode(K_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <K_KEYFILE> )
|
|
{
|
|
$K_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$K_KEYMAP_SIZE = $cnt;
|
|
|
|
@M7_KEYMAP = ();
|
|
binmode(M7_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M7_KEYFILE> )
|
|
{
|
|
$M7_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M7_KEYMAP_SIZE = $cnt;
|
|
|
|
@M8_KEYMAP = ();
|
|
binmode(M8_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M8_KEYFILE> )
|
|
{
|
|
$M8_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M8_KEYMAP_SIZE = $cnt;
|
|
|
|
@M12_KEYMAP = ();
|
|
binmode(M12_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M12_KEYFILE> )
|
|
{
|
|
$M12_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M12_KEYMAP_SIZE = $cnt;
|
|
|
|
@M20_KEYMAP = ();
|
|
binmode(M20_KEYFILE);
|
|
local $/ = \1;
|
|
$cnt = 0;
|
|
$skip = 0;
|
|
while ( my $byte = <M20_KEYFILE> )
|
|
{
|
|
$M20_KEYMAP[$cnt] = $byte;
|
|
$cnt++;
|
|
}
|
|
$M20_KEYMAP_SIZE = $cnt;
|
|
}
|
|
|
|
if($command eq "64KRAM")
|
|
{
|
|
# Location Loc. in Location in Length Meaning
|
|
# in tape monitor's S-BASIC
|
|
# header work area 1Z-013B
|
|
# $00 (0) $10F0 $0FFC 1 attribute of the file:
|
|
# 01 machine code program file
|
|
# 02 MZ-80 BASIC program file
|
|
# 03 MZ-80 data file
|
|
# 04 MZ-700 data file
|
|
# 05 MZ-700 BASIC program file
|
|
# $01 (1) $10F1 $0FFD 17 file name ( end = $0D )
|
|
# $12 (18) $1102 $100E 2 byte size of the file
|
|
# $14 (20) $1104 $1010 2 load address of a program file
|
|
# $16 (22) $1106 $1012 2 execution address of a program file
|
|
# $18 (24) $1108 $1014 104 comment
|
|
|
|
# Initialize in memory image.
|
|
@MainMemory = ();
|
|
|
|
|
|
# First up, write out the Monitor ROM to output file.
|
|
#
|
|
if($a_mromExists == 1) { $mrom_size = scalar @A_MROM; foreach my $byte (@A_MROM) { push @MainMemory, $byte; } };
|
|
if($a_80c_mromExists == 1) { $mrom_size = scalar @A_80C_MROM; foreach my $byte (@A_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($b_mromExists == 1) { $mrom_size = scalar @B_MROM; foreach my $byte (@B_MROM) { push @MainMemory, $byte; } };
|
|
if($b_80c_mromExists == 1) { $mrom_size = scalar @B_80C_MROM; foreach my $byte (@B_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($c_mromExists == 1) { $mrom_size = scalar @C_MROM; foreach my $byte (@C_MROM) { push @MainMemory, $byte; } };
|
|
if($c_80c_mromExists == 1) { $mrom_size = scalar @C_80C_MROM; foreach my $byte (@C_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($k_mromExists == 1) { $mrom_size = scalar @K_MROM; foreach my $byte (@K_MROM) { push @MainMemory, $byte; } };
|
|
if($k_80c_mromExists == 1) { $mrom_size = scalar @K_80C_MROM; foreach my $byte (@K_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($m7_mromExists == 1) { $mrom_size = scalar @M7_MROM; foreach my $byte (@M7_MROM) { push @MainMemory, $byte; } };
|
|
if($m7_80c_mromExists == 1) { $mrom_size = scalar @M7_80C_MROM; foreach my $byte (@M7_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($m8_mromExists == 1) { $mrom_size = scalar @M8_MROM; foreach my $byte (@M8_MROM) { push @MainMemory, $byte; } };
|
|
if($m8_80c_mromExists == 1) { $mrom_size = scalar @M8_80C_MROM; foreach my $byte (@M8_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($m12_mromExists == 1) { $mrom_size = scalar @M12_MROM; foreach my $byte (@M12_MROM) { push @MainMemory, $byte; } };
|
|
if($m12_80c_mromExists == 1) { $mrom_size = scalar @M12_80C_MROM; foreach my $byte (@M12_80C_MROM) { push @MainMemory, $byte; } };
|
|
if($m20_mromExists == 1) { $mrom_size = scalar @M20_MROM; foreach my $byte (@M20_MROM) { push @MainMemory, $byte; } };
|
|
if($m20_80c_mromExists == 1) { $mrom_size = scalar @M20_80C_MROM; foreach my $byte (@M20_80C_MROM) { push @MainMemory, $byte; } };
|
|
|
|
|
|
# If a Tape Program has been provided, process it.
|
|
#
|
|
if($mzfExists == 1)
|
|
{
|
|
# Process the header to get key information.
|
|
#
|
|
$mzf_header = pack('a'x128, @A_MZF);
|
|
($mzf_type, $mzf_filename, $mzf_size, $mzf_loadaddr, $mzf_execaddr, $mzf_comment) = unpack 'c1 a17 v4 v4 v4 a104', $mzf_header;
|
|
$mzf_filename =~ s/\r|\n//g;
|
|
|
|
# Next, 1000 - 10EF as zero's (Monitor scratch area).
|
|
for(my $idx=0; $idx < 240; $idx++) { push @MainMemory, "\x00"; };
|
|
|
|
# Next, write out the Tape Header 10F0 - 116F.
|
|
for(my $idx=0; $idx < 128; $idx++) { push @MainMemory, $A_MZF[$idx]; };
|
|
|
|
# Next, write out zero's up until the load address.
|
|
for(my $idx=0x1170; $idx < $mzf_loadaddr; $idx++) { push @MainMemory, "\x00"; };
|
|
for(my $idx=128; $idx < $A_MZF_SIZE; $idx++) { push @MainMemory, $A_MZF[$idx]; };
|
|
|
|
# Next, 1000 - 10EF as zero's (Monitor scratch area).
|
|
# Positions for easy reference.
|
|
$romStartPosition = 0;
|
|
$romEndPosition = $mrom_size;
|
|
$romScratchStartPosition = $mrom_size;
|
|
$romScratchEndPosition = 0x10EF;
|
|
$tapeHeaderStartPosition = 0x10F0;
|
|
$tapeHeaderEndPosition = 0x116F;
|
|
$romStackStartPosition = 0x1170;
|
|
$romStackEndPosition = $mzf_loadaddr;
|
|
$programStartPosition = $mzf_loadaddr;
|
|
$programEndPosition = $mzf_loadaddr + $mzf_size;
|
|
$lowerUsedMemoryPosition = scalar @MainMemory;
|
|
$ramcheckMemoryPosition = 0xCE00;
|
|
$userrom_size = 0x0000;
|
|
$fdcrom_size = 0x0000;
|
|
$userRomMemoryPosition = 0xE800;
|
|
$fdcRomMemoryPosition = 0xF000;
|
|
$upperMemoryPosition = 65536;
|
|
|
|
# Next, write out zero's from scratch area to end of ramchecker or userrom.
|
|
if($ramcheckExists == 1)
|
|
{
|
|
for(my $idx=$lowerUsedMemoryPosition; $idx < $ramcheckMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
for(my $idx=0; $idx < $RAMCHECK_SIZE; $idx++) { push @MainMemory, $RAMCHECK[$idx]; };
|
|
for(my $idx=$ramcheckMemoryPosition + $RAMCHECK_SIZE; $idx < $userRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
} else
|
|
{
|
|
for(my $idx=$lowerUsedMemoryPosition; $idx < $userRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
}
|
|
|
|
# User Rom
|
|
if($a_userromExists == 1) { $userrom_size = scalar @A_USERROM; foreach my $byte (@A_USERROM) { push @MainMemory, $byte; } };
|
|
if($b_userromExists == 1) { $userrom_size = scalar @B_USERROM; foreach my $byte (@B_USERROM) { push @MainMemory, $byte; } };
|
|
if($c_userromExists == 1) { $userrom_size = scalar @C_USERROM; foreach my $byte (@C_USERROM) { push @MainMemory, $byte; } };
|
|
if($k_userromExists == 1) { $userrom_size = scalar @K_USERROM; foreach my $byte (@K_USERROM) { push @MainMemory, $byte; } };
|
|
if($m7_userromExists == 1) { $userrom_size = scalar @M7_USERROM; foreach my $byte (@M7_USERROM) { push @MainMemory, $byte; } };
|
|
if($m8_userromExists == 1) { $userrom_size = scalar @M8_USERROM; foreach my $byte (@M8_USERROM) { push @MainMemory, $byte; } };
|
|
if($m12_userromExists == 1) { $userrom_size = scalar @M12_USERROM; foreach my $byte (@M12_USERROM) { push @MainMemory, $byte; } };
|
|
if($m20_userromExists == 1) { $userrom_size = scalar @M20_USERROM; foreach my $byte (@M20_USERROM) { push @MainMemory, $byte; } };
|
|
|
|
# Pad with zeros to end of block.
|
|
for(my $idx=$userRomMemoryPosition + $userrom_size; $idx < $userRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
|
|
# FDC Rom
|
|
if($a_fdcromExists == 1) { $fdcrom_size = scalar @A_FDCROM; foreach my $byte (@A_FDCROM) { push @MainMemory, $byte; } };
|
|
if($b_fdcromExists == 1) { $fdcrom_size = scalar @B_FDCROM; foreach my $byte (@B_FDCROM) { push @MainMemory, $byte; } };
|
|
if($c_fdcromExists == 1) { $fdcrom_size = scalar @C_FDCROM; foreach my $byte (@C_FDCROM) { push @MainMemory, $byte; } };
|
|
if($k_fdcromExists == 1) { $fdcrom_size = scalar @K_FDCROM; foreach my $byte (@K_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m7_fdcromExists == 1) { $fdcrom_size = scalar @M7_FDCROM; foreach my $byte (@M7_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m8_fdcromExists == 1) { $fdcrom_size = scalar @M8_FDCROM; foreach my $byte (@M8_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m12_fdcromExists == 1) { $fdcrom_size = scalar @M12_FDCROM; foreach my $byte (@M12_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m20_fdcromExists == 1) { $fdcrom_size = scalar @M20_FDCROM; foreach my $byte (@M20_FDCROM) { push @MainMemory, $byte; } };
|
|
|
|
# Pad with zeros to end of block.
|
|
for(my $idx=$fdcRomMemoryPosition + $fdcrom_size; $idx < $fdcRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
} else
|
|
{
|
|
|
|
# Positions for easy reference.
|
|
$romStartPosition = 0;
|
|
$romEndPosition = $mrom_size;
|
|
$romScratchStartPosition = $mrom_size;
|
|
$romScratchEndPosition = 0x116F;
|
|
$tapeHeaderStartPosition = 0x0000;
|
|
$tapeHeaderEndPosition = 0x0000;
|
|
$romStackStartPosition = 0x1170;
|
|
$romStackEndPosition = 0x11FF;
|
|
$programStartPosition = 0x0000;
|
|
$programEndPosition = 0x0000;
|
|
$lowerUsedMemoryPosition = scalar @MainMemory;
|
|
$ramcheckMemoryPosition = 0xCE00;
|
|
$userrom_size = 0x0000;
|
|
$fdcrom_size = 0x0000;
|
|
$userRomMemoryPosition = 0xE800;
|
|
$fdcRomMemoryPosition = 0xF000;
|
|
$upperMemoryPosition = 65536;
|
|
|
|
# Next, write out zero's from scratch area to end of memory or ramchecker..
|
|
if($ramcheckExists == 1)
|
|
{
|
|
for(my $idx=$lowerUsedMemoryPosition; $idx < $ramcheckMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
for(my $idx=0; $idx < $RAMCHECK_SIZE; $idx++) { push @MainMemory, $RAMCHECK[$idx]; };
|
|
for(my $idx=$ramcheckMemoryPosition + $RAMCHECK_SIZE; $idx < $userRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
} else
|
|
{
|
|
for(my $idx=$lowerUsedMemoryPosition; $idx < $userRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
}
|
|
|
|
# User Rom
|
|
if($a_userromExists == 1) { $userrom_size = scalar @A_USERROM; foreach my $byte (@A_USERROM) { push @MainMemory, $byte; } };
|
|
if($b_userromExists == 1) { $userrom_size = scalar @B_USERROM; foreach my $byte (@B_USERROM) { push @MainMemory, $byte; } };
|
|
if($c_userromExists == 1) { $userrom_size = scalar @C_USERROM; foreach my $byte (@C_USERROM) { push @MainMemory, $byte; } };
|
|
if($k_userromExists == 1) { $userrom_size = scalar @K_USERROM; foreach my $byte (@K_USERROM) { push @MainMemory, $byte; } };
|
|
if($m7_userromExists == 1) { $userrom_size = scalar @M7_USERROM; foreach my $byte (@M7_USERROM) { push @MainMemory, $byte; } };
|
|
if($m8_userromExists == 1) { $userrom_size = scalar @M8_USERROM; foreach my $byte (@M8_USERROM) { push @MainMemory, $byte; } };
|
|
if($m12_userromExists == 1) { $userrom_size = scalar @M12_USERROM; foreach my $byte (@M12_USERROM) { push @MainMemory, $byte; } };
|
|
if($m20_userromExists == 1) { $userrom_size = scalar @M20_USERROM; foreach my $byte (@M20_USERROM) { push @MainMemory, $byte; } };
|
|
|
|
# Pad with zeros to end of block.
|
|
for(my $idx=$userRomMemoryPosition + $userrom_size; $idx < $userRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
|
|
# FDC Rom
|
|
if($a_fdcromExists == 1) { $fdcrom_size = scalar @A_FDCROM; foreach my $byte (@A_FDCROM) { push @MainMemory, $byte; } };
|
|
if($b_fdcromExists == 1) { $fdcrom_size = scalar @B_FDCROM; foreach my $byte (@B_FDCROM) { push @MainMemory, $byte; } };
|
|
if($c_fdcromExists == 1) { $fdcrom_size = scalar @C_FDCROM; foreach my $byte (@C_FDCROM) { push @MainMemory, $byte; } };
|
|
if($k_fdcromExists == 1) { $fdcrom_size = scalar @K_FDCROM; foreach my $byte (@K_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m7_fdcromExists == 1) { $fdcrom_size = scalar @M7_FDCROM; foreach my $byte (@M7_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m8_fdcromExists == 1) { $fdcrom_size = scalar @M8_FDCROM; foreach my $byte (@M8_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m12_fdcromExists == 1) { $fdcrom_size = scalar @M12_FDCROM; foreach my $byte (@M12_FDCROM) { push @MainMemory, $byte; } };
|
|
if($m20_fdcromExists == 1) { $fdcrom_size = scalar @M20_FDCROM; foreach my $byte (@M20_FDCROM) { push @MainMemory, $byte; } };
|
|
|
|
# Pad with zeros to end of block.
|
|
for(my $idx=$fdcRomMemoryPosition + $fdcrom_size; $idx < $fdcRomMemoryPosition; $idx++) { push @MainMemory, "\x00"; };
|
|
}
|
|
|
|
# Finally, print out details for confirmation.
|
|
#
|
|
logWrite("", sprintf "Main Memory Map:\n");
|
|
logWrite("", sprintf " MROM = %04x:%04x %04x bytes", $romStartPosition, $romEndPosition, $romEndPosition - $romStartPosition);
|
|
logWrite("", sprintf " MROM (Scratch) = %04x:%04x %04x bytes", $romScratchStartPosition, $romScratchEndPosition, $romScratchEndPosition - $romScratchStartPosition);
|
|
logWrite("", sprintf " Tape Header = %04x:%04x %04x bytes", $tapeHeaderStartPosition, $tapeHeaderEndPosition, $tapeHeaderEndPosition - $tapeHeaderStartPosition,);
|
|
logWrite("", sprintf " MROM (Stack) = %04x:%04x %04x bytes", $romStackStartPosition, $romStackEndPosition, $romStackEndPosition - $romStackStartPosition);
|
|
logWrite("", sprintf " Program = %04x:%04x %04x bytes", $programStartPosition, $programEndPosition, $programEndPosition - $programStartPosition);
|
|
if($ramcheckExists == 1)
|
|
{
|
|
logWrite("", sprintf " Ram Checker = %04x:%04x %04x bytes", $ramcheckMemoryPosition, $ramcheckMemoryPosition + $RAMCHECK_SIZE, $RAMCHECK_SIZE);
|
|
}
|
|
if($a_userromExists == 1 || $b_userromExists == 1 || $c_userromExists == 1 || $k_userromExists == 1 || $m7_userromExists == 1 || $m8_userromExists == 1 || $m12_userromExists == 1 || $m20_userromExists == 1)
|
|
{
|
|
logWrite("", sprintf " User Rom = %04x:%04x %04x bytes", $userRomMemoryPosition, $userRomMemoryPosition + $userrom_size, $userrom_size);
|
|
}
|
|
if($a_fdcromExists == 1 || $b_fdcromExists == 1 || $c_fdcromExists == 1 || $k_fdcromExists == 1 || $m7_fdcromExists == 1 || $m8_fdcromExists == 1 || $m12_fdcromExists == 1 || $m20_fdcromExists == 1)
|
|
{
|
|
logWrite("", sprintf " FDC Rom = %04x:%04x %04x bytes", $fdcRomMemoryPosition, $fdcRomMemoryPosition + $fdcrom_size, $fdcrom_size);
|
|
}
|
|
logWrite("", sprintf "End of Program Memory = %04x", $programEndPosition);
|
|
}
|
|
elsif($command eq "MONROM")
|
|
{
|
|
# Initialize in memory image.
|
|
@MonitorMemory = ();
|
|
|
|
# Max ROM Sizes.
|
|
$A_MROM_MAX_SIZE = 4096;
|
|
$A_80C_MROM_MAX_SIZE = 4096;
|
|
$A_USERROM_MAX_SIZE = 2048;
|
|
$A_FDCROM_MAX_SIZE = 4096;
|
|
$K_MROM_MAX_SIZE = 4096;
|
|
$K_80C_MROM_MAX_SIZE = 4096;
|
|
$K_USERROM_MAX_SIZE = 2048;
|
|
$K_FDCROM_MAX_SIZE = 4096;
|
|
$C_MROM_MAX_SIZE = 4096;
|
|
$C_80C_MROM_MAX_SIZE = 4096;
|
|
$C_USERROM_MAX_SIZE = 2048;
|
|
$C_FDCROM_MAX_SIZE = 4096;
|
|
$M12_MROM_MAX_SIZE = 4096;
|
|
$M12_80C_MROM_MAX_SIZE = 4096;
|
|
$M12_USERROM_MAX_SIZE = 2048;
|
|
$M12_FDCROM_MAX_SIZE = 4096;
|
|
$M20_MROM_MAX_SIZE = 2048;
|
|
$M20_80C_MROM_MAX_SIZE = 2048;
|
|
$M20_USERROM_MAX_SIZE = 2048;
|
|
$M20_FDCROM_MAX_SIZE = 4096;
|
|
$M7_MROM_MAX_SIZE = 4096;
|
|
$M7_80C_MROM_MAX_SIZE = 4096;
|
|
$M7_USERROM_MAX_SIZE = 2048;
|
|
$M7_FDCROM_MAX_SIZE = 4096;
|
|
$M8_MROM_MAX_SIZE = 4096;
|
|
$M8_80C_MROM_MAX_SIZE = 4096;
|
|
$M8_USERROM_MAX_SIZE = 2048;
|
|
$M8_FDCROM_MAX_SIZE = 4096;
|
|
$B_MROM_MAX_SIZE = 2048;
|
|
$B_80C_MROM_MAX_SIZE = 2048;
|
|
$B_USERROM_MAX_SIZE = 2048;
|
|
$B_FDCROM_MAX_SIZE = 4096;
|
|
$M20_MROM_MAX_SIZE = 2048;
|
|
$M20_80C_MROM_MAX_SIZE = 2048;
|
|
$M20_USERROM_MAX_SIZE = 2048;
|
|
$M20_FDCROM_MAX_SIZE = 4096;
|
|
|
|
# Fill the memory image with equisize images, zero padding as necessary.
|
|
foreach my $byte (@K_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$K_MROM_SIZE; $idx < $K_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@K_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$K_80C_MROM_SIZE; $idx < $K_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@K_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$K_USERROM_SIZE; $idx < $K_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@K_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$K_FDCROM_SIZE; $idx < $K_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$C_MROM_SIZE; $idx < $C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@C_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$C_80C_MROM_SIZE; $idx < $C_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@C_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$C_USERROM_SIZE; $idx < $C_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@C_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$C_FDCROM_SIZE; $idx < $C_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M12_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M12_MROM_SIZE; $idx < $M12_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M12_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M12_80C_MROM_SIZE; $idx < $M12_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M12_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$M12_USERROM_SIZE; $idx < $M12_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M12_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$M12_FDCROM_SIZE; $idx < $M12_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@A_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$A_MROM_SIZE; $idx < $A_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@A_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$A_80C_MROM_SIZE; $idx < $A_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@A_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$A_USERROM_SIZE; $idx < $A_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@A_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$A_FDCROM_SIZE; $idx < $A_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M7_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M7_MROM_SIZE; $idx < $M7_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M7_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M7_80C_MROM_SIZE; $idx < $M7_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M7_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$M7_USERROM_SIZE; $idx < $M7_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M7_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$M7_FDCROM_SIZE; $idx < $M7_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M8_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M8_MROM_SIZE; $idx < $M8_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M8_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M8_80C_MROM_SIZE; $idx < $M8_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M8_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$M8_USERROM_SIZE; $idx < $M8_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M8_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$M8_FDCROM_SIZE; $idx < $M8_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@B_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$B_MROM_SIZE; $idx < $B_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@B_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$B_80C_MROM_SIZE; $idx < $B_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@B_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$B_USERROM_SIZE; $idx < $B_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@B_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$B_FDCROM_SIZE; $idx < $B_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M20_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M20_MROM_SIZE; $idx < $M20_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M20_80C_MROM) { push @MonitorMemory, $byte; }; for(my $idx=$M20_80C_MROM_SIZE; $idx < $M20_80C_MROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M20_USERROM) { push @MonitorMemory, $byte; }; for(my $idx=$M20_USERROM_SIZE; $idx < $M20_USERROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
foreach my $byte (@M20_FDCROM) { push @MonitorMemory, $byte; }; for(my $idx=$M20_FDCROM_SIZE; $idx < $M20_FDCROM_MAX_SIZE; $idx++) { push @MonitorMemory, "\x00"; };
|
|
|
|
# Positions for easy reference.
|
|
$k_romStartPosition = 0;
|
|
$k_romEndPosition = $K_MROM_MAX_SIZE -1;
|
|
$k_romPadding = $K_MROM_MAX_SIZE - $K_MROM_SIZE;
|
|
$k_80c_romStartPosition = $k_romEndPosition + 1;
|
|
$k_80c_romEndPosition = $k_80c_romStartPosition + $K_80C_MROM_MAX_SIZE -1;
|
|
$k_80c_romPadding = $K_80C_MROM_MAX_SIZE - $K_80C_MROM_SIZE;
|
|
$k_userromStartPosition = $k_80c_romEndPosition + 1;
|
|
$k_userromEndPosition = $k_userromStartPosition + $K_USERROM_MAX_SIZE -1;
|
|
$k_userromPadding = $K_USERROM_MAX_SIZE - $K_USERROM_SIZE;
|
|
$k_fdcromStartPosition = $k_userromEndPosition + 1;
|
|
$k_fdcromEndPosition = $k_fdcromStartPosition + $K_FDCROM_MAX_SIZE -1;
|
|
$k_fdcromPadding = $K_FDCROM_MAX_SIZE - $K_FDCROM_SIZE;
|
|
$c_romStartPosition = $k_fdcromEndPosition + 1;
|
|
$c_romEndPosition = $c_romStartPosition + $C_MROM_MAX_SIZE -1;
|
|
$c_romPadding = $C_MROM_MAX_SIZE - $C_MROM_SIZE;
|
|
$c_80c_romStartPosition = $c_romEndPosition + 1;
|
|
$c_80c_romEndPosition = $c_80c_romStartPosition + $C_80C_MROM_MAX_SIZE -1;
|
|
$c_80c_romPadding = $C_80C_MROM_MAX_SIZE - $C_80C_MROM_SIZE;
|
|
$c_userromStartPosition = $c_80c_romEndPosition + 1;
|
|
$c_userromEndPosition = $c_userromStartPosition + $C_USERROM_MAX_SIZE -1;
|
|
$c_userromPadding = $C_USERROM_MAX_SIZE - $C_USERROM_SIZE;
|
|
$c_fdcromStartPosition = $c_userromEndPosition + 1;
|
|
$c_fdcromEndPosition = $c_fdcromStartPosition + $C_FDCROM_MAX_SIZE -1;
|
|
$c_fdcromPadding = $C_FDCROM_MAX_SIZE - $C_FDCROM_SIZE;
|
|
$m12_romStartPosition = $c_fdcromEndPosition + 1;
|
|
$m12_romEndPosition = $m12_romStartPosition + $M12_MROM_MAX_SIZE -1;
|
|
$m12_romPadding = $M12_MROM_MAX_SIZE - $M12_MROM_SIZE;
|
|
$m12_80c_romStartPosition = $m12_romEndPosition + 1;
|
|
$m12_80c_romEndPosition = $m12_80c_romStartPosition + $M12_80C_MROM_MAX_SIZE -1;
|
|
$m12_80c_romPadding = $M12_80C_MROM_MAX_SIZE - $M12_80C_MROM_SIZE;
|
|
$m12_userromStartPosition = $m12_80c_romEndPosition + 1;
|
|
$m12_userromEndPosition = $m12_userromStartPosition + $M12_USERROM_MAX_SIZE -1;
|
|
$m12_userromPadding = $M12_USERROM_MAX_SIZE - $M12_USERROM_SIZE;
|
|
$m12_fdcromStartPosition = $m12_userromEndPosition + 1;
|
|
$m12_fdcromEndPosition = $m12_fdcromStartPosition + $M12_FDCROM_MAX_SIZE -1;
|
|
$m12_fdcromPadding = $M12_FDCROM_MAX_SIZE - $M12_FDCROM_SIZE;
|
|
$a_romStartPosition = $m12_fdcromEndPosition + 1;
|
|
$a_romEndPosition = $a_romStartPosition + $A_MROM_MAX_SIZE -1;
|
|
$a_romPadding = $A_MROM_MAX_SIZE - $A_MROM_SIZE;
|
|
$a_80c_romStartPosition = $a_romEndPosition + 1;
|
|
$a_80c_romEndPosition = $a_80c_romStartPosition + $A_80C_MROM_MAX_SIZE -1;
|
|
$a_80c_romPadding = $A_80C_MROM_MAX_SIZE - $A_80C_MROM_SIZE;
|
|
$a_userromStartPosition = $a_80c_romEndPosition + 1;
|
|
$a_userromEndPosition = $a_userromStartPosition + $A_USERROM_MAX_SIZE -1;
|
|
$a_userromPadding = $A_USERROM_MAX_SIZE - $A_USERROM_SIZE;
|
|
$a_fdcromStartPosition = $a_userromEndPosition + 1;
|
|
$a_fdcromEndPosition = $a_fdcromStartPosition + $A_FDCROM_MAX_SIZE -1;
|
|
$a_fdcromPadding = $A_FDCROM_MAX_SIZE - $A_FDCROM_SIZE;
|
|
$m7_romStartPosition = $a_fdcromEndPosition + 1;
|
|
$m7_romEndPosition = $m7_romStartPosition + $M7_MROM_MAX_SIZE -1;
|
|
$m7_romPadding = $M7_MROM_MAX_SIZE - $M7_MROM_SIZE;
|
|
$m7_80c_romStartPosition = $m7_romEndPosition + 1;
|
|
$m7_80c_romEndPosition = $m7_80c_romStartPosition + $M7_80C_MROM_MAX_SIZE -1;
|
|
$m7_80c_romPadding = $M7_80C_MROM_MAX_SIZE - $M7_80C_MROM_SIZE;
|
|
$m7_userromStartPosition = $m7_80c_romEndPosition + 1;
|
|
$m7_userromEndPosition = $m7_userromStartPosition + $M7_USERROM_MAX_SIZE -1;
|
|
$m7_userromPadding = $M7_USERROM_MAX_SIZE - $M7_USERROM_SIZE;
|
|
$m7_fdcromStartPosition = $m7_userromEndPosition + 1;
|
|
$m7_fdcromEndPosition = $m7_fdcromStartPosition + $M7_FDCROM_MAX_SIZE -1;
|
|
$m7_fdcromPadding = $M7_FDCROM_MAX_SIZE - $M7_FDCROM_SIZE;
|
|
$m8_romStartPosition = $m7_fdcromEndPosition + 1;
|
|
$m8_romEndPosition = $m8_romStartPosition + $M8_MROM_MAX_SIZE -1;
|
|
$m8_romPadding = $M8_MROM_MAX_SIZE - $M8_MROM_SIZE;
|
|
$m8_80c_romStartPosition = $m8_romEndPosition + 1;
|
|
$m8_80c_romEndPosition = $m8_80c_romStartPosition + $M8_80C_MROM_MAX_SIZE -1;
|
|
$m8_80c_romPadding = $M8_80C_MROM_MAX_SIZE - $M8_80C_MROM_SIZE;
|
|
$m8_userromStartPosition = $m8_80c_romEndPosition + 1;
|
|
$m8_userromEndPosition = $m8_userromStartPosition + $M8_USERROM_MAX_SIZE -1;
|
|
$m8_userromPadding = $M8_USERROM_MAX_SIZE - $M8_USERROM_SIZE;
|
|
$m8_fdcromStartPosition = $m8_userromEndPosition + 1;
|
|
$m8_fdcromEndPosition = $m8_fdcromStartPosition + $M8_FDCROM_MAX_SIZE -1;
|
|
$m8_fdcromPadding = $M8_FDCROM_MAX_SIZE - $M8_FDCROM_SIZE;
|
|
$b_romStartPosition = $m8_fdcromEndPosition + 1;
|
|
$b_romEndPosition = $b_romStartPosition + $B_MROM_MAX_SIZE -1;
|
|
$b_romPadding = $B_MROM_MAX_SIZE - $B_MROM_SIZE;
|
|
$b_80c_romStartPosition = $b_romEndPosition + 1;
|
|
$b_80c_romEndPosition = $b_80c_romStartPosition + $B_80C_MROM_MAX_SIZE -1;
|
|
$b_80c_romPadding = $B_80C_MROM_MAX_SIZE - $B_80C_MROM_SIZE;
|
|
$b_userromStartPosition = $b_80c_romEndPosition + 1;
|
|
$b_userromEndPosition = $b_userromStartPosition + $B_USERROM_MAX_SIZE -1;
|
|
$b_userromPadding = $B_USERROM_MAX_SIZE - $B_USERROM_SIZE;
|
|
$b_fdcromStartPosition = $b_userromEndPosition + 1;
|
|
$b_fdcromEndPosition = $b_fdcromStartPosition + $B_FDCROM_MAX_SIZE -1;
|
|
$b_fdcromPadding = $B_FDCROM_MAX_SIZE - $B_FDCROM_SIZE;
|
|
$m20_romStartPosition = $b_fdcromEndPosition + 1;
|
|
$m20_romEndPosition = $m20_romStartPosition + $M20_MROM_MAX_SIZE -1;
|
|
$m20_romPadding = $M20_MROM_MAX_SIZE - $M20_MROM_SIZE;
|
|
$m20_80c_romStartPosition = $m20_romEndPosition + 1;
|
|
$m20_80c_romEndPosition = $m20_80c_romStartPosition + $M20_80C_MROM_MAX_SIZE -1;
|
|
$m20_80c_romPadding = $M20_80C_MROM_MAX_SIZE - $M20_80C_MROM_SIZE;
|
|
$m20_userromStartPosition = $m20_80c_romEndPosition + 1;
|
|
$m20_userromEndPosition = $m20_userromStartPosition + $M20_USERROM_MAX_SIZE -1;
|
|
$m20_userromPadding = $M20_USERROM_MAX_SIZE - $M20_USERROM_SIZE;
|
|
$m20_fdcromStartPosition = $m20_userromEndPosition + 1;
|
|
$m20_fdcromEndPosition = $m20_fdcromStartPosition + $M20_FDCROM_MAX_SIZE -1;
|
|
$m20_fdcromPadding = $M20_FDCROM_MAX_SIZE - $M20_FDCROM_SIZE;
|
|
for(my $idx=$m20_fdcromEndPosition; $idx < 131071; $idx++) { push @MonitorMemory, "\x00"; };
|
|
|
|
# Finally, print out details for confirmation.
|
|
#
|
|
logWrite("", sprintf "Monitor ROM Map:\n");
|
|
logWrite("", sprintf " 80K MROM =%04x:%04x %04x bytes padding", $k_romStartPosition, $k_romEndPosition, $k_romPadding);
|
|
logWrite("", sprintf " 80x25 80K MROM =%04x:%04x %04x bytes padding", $k_80c_romStartPosition, $k_80c_romEndPosition, $k_80c_romPadding);
|
|
logWrite("", sprintf " USER 80K ROM =%04x:%04x %04x bytes padding", $k_userromStartPosition, $k_userromEndPosition, $k_userromPadding);
|
|
logWrite("", sprintf " FDC 80K ROM =%04x:%04x %04x bytes padding", $k_fdcromStartPosition, $k_fdcromEndPosition, $k_fdcromPadding);
|
|
logWrite("", sprintf " 80C MROM =%04x:%04x %04x bytes padding", $c_romStartPosition, $c_romEndPosition, $c_romPadding);
|
|
logWrite("", sprintf " 80x25 80C MROM =%04x:%04x %04x bytes padding", $c_80c_romStartPosition, $c_80c_romEndPosition, $c_80c_romPadding);
|
|
logWrite("", sprintf " USER 80C ROM =%04x:%04x %04x bytes padding", $c_userromStartPosition, $c_userromEndPosition, $c_userromPadding);
|
|
logWrite("", sprintf " FDC 80C ROM =%04x:%04x %04x bytes padding", $c_fdcromStartPosition, $c_fdcromEndPosition, $c_fdcromPadding);
|
|
logWrite("", sprintf " 1200 MROM =%04x:%04x %04x bytes padding", $m12_romStartPosition, $m12_romEndPosition, $m12_romPadding);
|
|
logWrite("", sprintf " 80x25 1200 MROM =%04x:%04x %04x bytes padding", $m12_80c_romStartPosition, $m12_80c_romEndPosition, $m12_80c_romPadding);
|
|
logWrite("", sprintf " USER 1200 ROM =%04x:%04x %04x bytes padding", $m12_userromStartPosition, $m12_userromEndPosition, $m12_userromPadding);
|
|
logWrite("", sprintf " FDC 1200 ROM =%04x:%04x %04x bytes padding", $m12_fdcromStartPosition, $m12_fdcromEndPosition, $m12_fdcromPadding);
|
|
logWrite("", sprintf " 80A MROM =%04x:%04x %04x bytes padding", $a_romStartPosition, $a_romEndPosition, $a_romPadding);
|
|
logWrite("", sprintf " 80x25 80A MROM =%04x:%04x %04x bytes padding", $a_80c_romStartPosition, $a_80c_romEndPosition, $a_80c_romPadding);
|
|
logWrite("", sprintf " USER 80A ROM =%04x:%04x %04x bytes padding", $a_userromStartPosition, $a_userromEndPosition, $a_userromPadding);
|
|
logWrite("", sprintf " FDC 80A ROM =%04x:%04x %04x bytes padding", $a_fdcromStartPosition, $a_fdcromEndPosition, $a_fdcromPadding);
|
|
logWrite("", sprintf " 700 MROM =%04x:%04x %04x bytes padding", $m7_romStartPosition, $m7_romEndPosition, $m7_romPadding);
|
|
logWrite("", sprintf " 80x25 700 MROM =%04x:%04x %04x bytes padding", $m7_80c_romStartPosition, $m7_80c_romEndPosition, $m7_80c_romPadding);
|
|
logWrite("", sprintf " USER 700 ROM =%04x:%04x %04x bytes padding", $m7_userromStartPosition, $m7_userromEndPosition, $m7_userromPadding);
|
|
logWrite("", sprintf " FDC 700 ROM =%04x:%04x %04x bytes padding", $m7_fdcromStartPosition, $m7_fdcromEndPosition, $m7_fdcromPadding);
|
|
logWrite("", sprintf " 800 MROM =%04x:%04x %04x bytes padding", $m8_romStartPosition, $m8_romEndPosition, $m8_romPadding);
|
|
logWrite("", sprintf " 80x25 800 MROM =%04x:%04x %04x bytes padding", $m8_80c_romStartPosition, $m8_80c_romEndPosition, $m8_80c_romPadding);
|
|
logWrite("", sprintf " USER 800 ROM =%04x:%04x %04x bytes padding", $m8_userromStartPosition, $m8_userromEndPosition, $m8_userromPadding);
|
|
logWrite("", sprintf " FDC 800 ROM =%04x:%04x %04x bytes padding", $m8_fdcromStartPosition, $m8_fdcromEndPosition, $m8_fdcromPadding);
|
|
logWrite("", sprintf " 80B MROM =%04x:%04x %04x bytes padding", $b_romStartPosition, $b_romEndPosition, $b_romPadding);
|
|
logWrite("", sprintf " 80x25 80B MROM =%04x:%04x %04x bytes padding", $b_80c_romStartPosition, $b_80c_romEndPosition, $b_romPadding);
|
|
logWrite("", sprintf " USER 80B ROM =%04x:%04x %04x bytes padding", $b_userromStartPosition, $b_userromEndPosition, $b_userromPadding);
|
|
logWrite("", sprintf " FDC 80B ROM =%04x:%04x %04x bytes padding", $b_fdcromStartPosition, $b_fdcromEndPosition, $b_fdcromPadding);
|
|
logWrite("", sprintf " 2000 MROM =%04x:%04x %04x bytes padding", $m20_romStartPosition, $m20_romEndPosition, $m20_romPadding);
|
|
logWrite("", sprintf " 80x25 2000 MROM =%04x:%04x %04x bytes padding", $m20_80c_romStartPosition, $m20_80c_romEndPosition, $m20_romPadding);
|
|
logWrite("", sprintf " USER 2000 ROM =%04x:%04x %04x bytes padding", $m20_userromStartPosition, $m20_userromEndPosition, $m20_userromPadding);
|
|
logWrite("", sprintf " FDC 2000 ROM =%04x:%04x %04x bytes padding", $m20_fdcromStartPosition, $m20_fdcromEndPosition, $m20_fdcromPadding);
|
|
}
|
|
elsif($command eq "CGROM")
|
|
{
|
|
# Initialize in memory image.
|
|
@CGMemory = ();
|
|
|
|
# Fill the memory image with equisize images.=.
|
|
foreach my $byte (@K_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@C_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@M12_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@A_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@M7_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@M8_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@B_CGROM) { push @CGMemory, $byte; };
|
|
foreach my $byte (@M20_CGROM) { push @CGMemory, $byte; };
|
|
|
|
# Positions for easy reference.
|
|
$k_romStartPosition = 0;
|
|
$k_romEndPosition = $K_CGROM_SIZE -1;
|
|
$c_romStartPosition = $k_romEndPosition + 1;
|
|
$c_romEndPosition = $c_romStartPosition + $C_CGROM_SIZE -1;
|
|
$m12_romStartPosition = $c_romEndPosition + 1;
|
|
$m12_romEndPosition = $m12_romStartPosition + $M12_CGROM_SIZE -1;
|
|
$a_romStartPosition = $m12_romEndPosition + 1;
|
|
$a_romEndPosition = $a_romStartPosition + $A_CGROM_SIZE -1;
|
|
$m7_romStartPosition = $a_romEndPosition + 1;
|
|
$m7_romEndPosition = $m7_romStartPosition + $M7_CGROM_SIZE -1;
|
|
$m8_romStartPosition = $m7_romEndPosition + 1;
|
|
$m8_romEndPosition = $m8_romStartPosition + $M8_CGROM_SIZE -1;
|
|
$b_romStartPosition = $m8_romEndPosition + 1;
|
|
$b_romEndPosition = $b_romStartPosition + $B_CGROM_SIZE -1;
|
|
$m20_romStartPosition = $b_romEndPosition + 1;
|
|
$m20_romEndPosition = $m20_romStartPosition + $M20_CGROM_SIZE -1;
|
|
|
|
# Finally, print out details for confirmation.
|
|
#
|
|
logWrite("", sprintf "Character Generator ROM Map:\n");
|
|
logWrite("", sprintf " 80K CGROM =%04x:%04x", $k_romStartPosition, $k_romEndPosition);
|
|
logWrite("", sprintf " 80C CGROM =%04x:%04x", $c_romStartPosition, $c_romEndPosition);
|
|
logWrite("", sprintf " 1200 CGROM =%04x:%04x", $m12_romStartPosition, $m12_romEndPosition);
|
|
logWrite("", sprintf " 80A CGROM =%04x:%04x", $a_romStartPosition, $a_romEndPosition);
|
|
logWrite("", sprintf " 700 CGROM =%04x:%04x", $m7_romStartPosition, $m7_romEndPosition);
|
|
logWrite("", sprintf " 800 CGROM =%04x:%04x", $m8_romStartPosition, $m8_romEndPosition);
|
|
logWrite("", sprintf " 80B CGROM =%04x:%04x", $b_romStartPosition, $b_romEndPosition);
|
|
logWrite("", sprintf " 2000 CGROM =%04x:%04x", $m20_romStartPosition, $m20_romEndPosition);
|
|
}
|
|
elsif($command eq "KEYMAP")
|
|
{
|
|
# Initialize in memory image.
|
|
@KeyMemory = ();
|
|
|
|
$maxSize = $A_KEYMAP_SIZE;
|
|
if($K_KEYMAP_SIZE > $maxSize) { $maxSize = $K_KEYMAP_SIZE; }
|
|
if($C_KEYMAP_SIZE > $maxSize) { $maxSize = $C_KEYMAP_SIZE; }
|
|
if($M12_KEYMAP_SIZE > $maxSize) { $maxSize = $M12_KEYMAP_SIZE; }
|
|
if($M7_KEYMAP_SIZE > $maxSize) { $maxSize = $M7_KEYMAP_SIZE; }
|
|
if($M8_KEYMAP_SIZE > $maxSize) { $maxSize = $M8_KEYMAP_SIZE; }
|
|
if($B_KEYMAP_SIZE > $maxSize) { $maxSize = $B_KEYMAP_SIZE; }
|
|
if($M20_KEYMAP_SIZE > $maxSize) { $maxSize = $M20_KEYMAP_SIZE; }
|
|
|
|
# Fill the memory image with equisize images, zero padding as necessary.
|
|
foreach my $byte (@K_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$K_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@C_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$C_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@M12_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$M12_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@A_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$A_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@M7_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$M7_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@M8_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$M8_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@B_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$B_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
foreach my $byte (@M20_KEYMAP) { push @KeyMemory, $byte; }; for(my $idx=$M20_KEYMAP_SIZE; $idx < $maxSize; $idx++) { push @KeyMemory, "\x00"; };
|
|
|
|
# Positions for easy reference.
|
|
$k_romStartPosition = 0;
|
|
$k_romEndPosition = $K_KEYMAP_SIZE + ($maxSize - $K_KEYMAP_SIZE) -1;
|
|
$k_romPadding = $maxSize - $K_KEYMAP_SIZE;
|
|
$c_romStartPosition = $k_romEndPosition + 1;
|
|
$c_romEndPosition = $c_romStartPosition + $C_KEYMAP_SIZE + ($maxSize - $C_KEYMAP_SIZE) -1;
|
|
$c_romPadding = $maxSize - $C_KEYMAP_SIZE;
|
|
$m12_romStartPosition = $c_romEndPosition + 1;
|
|
$m12_romEndPosition = $m12_romStartPosition + $M12_KEYMAP_SIZE + ($maxSize - $M12_KEYMAP_SIZE) -1;
|
|
$m12_romPadding = $maxSize - $M12_KEYMAP_SIZE;
|
|
$a_romStartPosition = $m12_romEndPosition + 1;
|
|
$a_romEndPosition = $a_romStartPosition + $A_KEYMAP_SIZE + ($maxSize - $A_KEYMAP_SIZE) -1;
|
|
$a_romPadding = $maxSize - $A_KEYMAP_SIZE;
|
|
$m7_romStartPosition = $a_romEndPosition + 1;
|
|
$m7_romEndPosition = $m7_romStartPosition + $M7_KEYMAP_SIZE + ($maxSize - $M7_KEYMAP_SIZE) -1;
|
|
$m7_romPadding = $maxSize - $M7_KEYMAP_SIZE;
|
|
$m8_romStartPosition = $m7_romEndPosition + 1;
|
|
$m8_romEndPosition = $m8_romStartPosition + $M8_KEYMAP_SIZE + ($maxSize - $M8_KEYMAP_SIZE) -1;
|
|
$m8_romPadding = $maxSize - $M8_KEYMAP_SIZE;
|
|
$b_romStartPosition = $m7_romEndPosition + 1;
|
|
$b_romEndPosition = $b_romStartPosition + $B_KEYMAP_SIZE + ($maxSize - $B_KEYMAP_SIZE) -1;
|
|
$b_romPadding = $maxSize - $B_KEYMAP_SIZE;
|
|
$m20_romStartPosition = $b_romEndPosition + 1;
|
|
$m20_romEndPosition = $m20_romStartPosition + $M20_KEYMAP_SIZE + ($maxSize - $M20_KEYMAP_SIZE) -1;
|
|
$m20_romPadding = $maxSize - $M20_KEYMAP_SIZE;
|
|
|
|
# Finally, print out details for confirmation.
|
|
#
|
|
logWrite("", sprintf "Key Mapping ROM Map:\n");
|
|
logWrite("", sprintf " 80K KEYMAP =%04x:%04x %04x bytes padding", $k_romStartPosition, $k_romEndPosition, $k_romPadding);
|
|
logWrite("", sprintf " 80C KEYMAP =%04x:%04x %04x bytes padding", $c_romStartPosition, $c_romEndPosition, $c_romPadding);
|
|
logWrite("", sprintf " 1200 KEYMAP =%04x:%04x %04x bytes padding", $m12_romStartPosition, $m12_romEndPosition, $m12_romPadding);
|
|
logWrite("", sprintf " 80A KEYMAP =%04x:%04x %04x bytes padding", $a_romStartPosition, $a_romEndPosition, $a_romPadding);
|
|
logWrite("", sprintf " 700 KEYMAP =%04x:%04x %04x bytes padding", $m7_romStartPosition, $m7_romEndPosition, $m7_romPadding);
|
|
logWrite("", sprintf " 800 KEYMAP =%04x:%04x %04x bytes padding", $m8_romStartPosition, $m8_romEndPosition, $m8_romPadding);
|
|
logWrite("", sprintf " 80B KEYMAP =%04x:%04x %04x bytes padding", $b_romStartPosition, $b_romEndPosition, $b_romPadding);
|
|
logWrite("", sprintf " 2000 KEYMAP =%04x:%04x %04x bytes padding", $m20_romStartPosition, $m20_romEndPosition, $m20_romPadding);
|
|
}
|
|
else
|
|
{
|
|
argOptions(1, "Illegal command given on command line:$command.\n",$ERR_BADARGUMENTS);
|
|
}
|
|
|
|
# Output the memory image to the output file.
|
|
#
|
|
if (scalar @MainMemory > 0)
|
|
{
|
|
foreach my $byte (@MainMemory) { print OUTFILE $byte; }
|
|
}
|
|
elsif(scalar @MonitorMemory > 0)
|
|
{
|
|
foreach my $byte (@MonitorMemory) { print OUTFILE $byte; }
|
|
}
|
|
elsif(scalar @CGMemory > 0)
|
|
{
|
|
foreach my $byte (@CGMemory) { print OUTFILE $byte; }
|
|
}
|
|
elsif(scalar @KeyMemory > 0)
|
|
{
|
|
foreach my $byte (@KeyMemory) { print OUTFILE $byte; }
|
|
}
|
|
|
|
# If a MIF file is required, create it.
|
|
#
|
|
if($createMIF == 1)
|
|
{
|
|
if (scalar @MainMemory > 0)
|
|
{
|
|
createMIF(\@MainMemory, MIFOUTFILE);
|
|
}
|
|
elsif(scalar @MonitorMemory > 0)
|
|
{
|
|
createMIF(\@MonitorMemory, MIFOUTFILE);
|
|
}
|
|
elsif(scalar @CGMemory > 0)
|
|
{
|
|
createMIF(\@CGMemory, MIFOUTFILE);
|
|
}
|
|
elsif(scalar @KeyMemory > 0)
|
|
{
|
|
createMIF(\@KeyMemory, MIFOUTFILE);
|
|
}
|
|
}
|
|
|
|
exit 0;
|