adolphenom
208 lines
9.6 KiB
Java
208 lines
9.6 KiB
Java
package mars.simulator;
|
|
import mars.*;
|
|
import mars.venus.*;
|
|
import mars.util.*;
|
|
import mars.mips.hardware.*;
|
|
import mars.mips.instructions.*;
|
|
import java.util.*;
|
|
import javax.swing.*;
|
|
import java.awt.event.*;
|
|
|
|
/*
|
|
Copyright (c) 2003-2008, Pete Sanderson and Kenneth Vollmar
|
|
|
|
Developed by Pete Sanderson (psanderson@otterbein.edu)
|
|
and Kenneth Vollmar (kenvollmar@missouristate.edu)
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining
|
|
a copy of this software and associated documentation files (the
|
|
"Software"), to deal in the Software without restriction, including
|
|
without limitation the rights to use, copy, modify, merge, publish,
|
|
distribute, sublicense, and/or sell copies of the Software, and to
|
|
permit persons to whom the Software is furnished to do so, subject
|
|
to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be
|
|
included in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
|
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
|
|
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
(MIT license, http://www.opensource.org/licenses/mit-license.html)
|
|
*/
|
|
|
|
/**
|
|
* Models Program Arguments, one or more strings provided to the MIPS
|
|
* program at runtime. Equivalent to C's main(int argc, char **argv) or
|
|
* Java's main(String[] args).
|
|
* @author Pete Sanderson
|
|
* @version July 2008
|
|
**/
|
|
|
|
public class ProgramArgumentList {
|
|
|
|
ArrayList programArgumentList;
|
|
|
|
/**
|
|
* Constructor that parses string to produce list. Delimiters
|
|
* are the default Java StringTokenizer delimiters (space, tab,
|
|
* newline, return, formfeed)
|
|
*
|
|
* @param args String containing delimiter-separated arguments
|
|
*/
|
|
public ProgramArgumentList(String args) {
|
|
StringTokenizer st = new StringTokenizer(args);
|
|
programArgumentList = new ArrayList(st.countTokens());
|
|
while (st.hasMoreTokens()) {
|
|
programArgumentList.add(st.nextToken());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constructor that gets list from String array, one argument per element.
|
|
*
|
|
* @param list Array of String, each element containing one argument
|
|
*/
|
|
public ProgramArgumentList(String[] list) {
|
|
this(list, 0);
|
|
}
|
|
|
|
/**
|
|
* Constructor that gets list from section of String array, one
|
|
* argument per element.
|
|
*
|
|
* @param args Array of String, each element containing one argument
|
|
* @param startPosition Index of array element containing the first argument; all remaining
|
|
* elements are assumed to contain an argument.
|
|
*/
|
|
public ProgramArgumentList(String[] list, int startPosition) {
|
|
programArgumentList = new ArrayList(list.length-startPosition);
|
|
for (int i=startPosition; i<list.length; i++) {
|
|
programArgumentList.add(list[i]);
|
|
}
|
|
}
|
|
/**
|
|
* Constructor that gets list from ArrayList of String, one argument per element.
|
|
*
|
|
* @param list ArrayList of String, each element containing one argument
|
|
*/
|
|
public ProgramArgumentList(ArrayList list) {
|
|
this(list, 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Constructor that gets list from section of String ArrayList, one
|
|
* argument per element.
|
|
*
|
|
* @param args ArrayList of String, each element containing one argument
|
|
* @param startPosition Index of array element containing the first argument; all remaining
|
|
* elements are assumed to contain an argument.
|
|
*/
|
|
public ProgramArgumentList(ArrayList list, int startPosition) {
|
|
if (list == null || list.size() < startPosition) {
|
|
programArgumentList = new ArrayList(0);
|
|
}
|
|
else {
|
|
programArgumentList = new ArrayList(list.size()-startPosition);
|
|
for (int i=startPosition; i<list.size(); i++) {
|
|
programArgumentList.add(list.get(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Place any program arguments into MIPS memory and registers
|
|
// Arguments are stored starting at highest word of non-kernel
|
|
// memory and working back toward runtime stack (there is a 4096
|
|
// byte gap in between). The argument count (argc) and pointers
|
|
// to the arguments are stored on the runtime stack. The stack
|
|
// pointer register $sp is adjusted accordingly and $a0 is set
|
|
// to the argument count (argc), and $a1 is set to the stack
|
|
// address holding the first argument pointer (argv).
|
|
public void storeProgramArguments() {
|
|
if (programArgumentList == null || programArgumentList.size() == 0) {
|
|
return;
|
|
}
|
|
// Runtime stack initialization from stack top-down (each is 4 bytes) :
|
|
// programArgumentList.size()
|
|
// address of first character of first program argument
|
|
// address of first character of second program argument
|
|
// ....repeat for all program arguments
|
|
// 0x00000000 (null terminator for list of string pointers)
|
|
// $sp will be set to the address holding the arg list size
|
|
// $a0 will be set to the arg list size (argc)
|
|
// $a1 will be set to stack address just "below" arg list size (argv)
|
|
//
|
|
// Each of the arguments themselves will be stored starting at
|
|
// Memory.stackBaseAddress (0x7ffffffc) and working down from there:
|
|
// 0x7ffffffc will contain null terminator for first arg
|
|
// 0x7ffffffb will contain last character of first arg
|
|
// 0x7ffffffa will contain next-to-last character of first arg
|
|
// Etc down to first character of first arg.
|
|
// Previous address will contain null terminator for second arg
|
|
// Previous-to-that contains last character of second arg
|
|
// Etc down to first character of second arg.
|
|
// Follow this pattern for all remaining arguments.
|
|
|
|
|
|
int highAddress = Memory.stackBaseAddress; // highest non-kernel address, sits "under" stack
|
|
String programArgument;
|
|
int[] argStartAddress = new int[programArgumentList.size()];
|
|
try { // needed for all memory writes
|
|
for (int i=0; i<programArgumentList.size(); i++) {
|
|
programArgument = (String) programArgumentList.get(i);
|
|
Globals.memory.set(highAddress, 0, 1); // trailing null byte for each argument
|
|
highAddress--;
|
|
for (int j = programArgument.length()-1; j >= 0; j--) {
|
|
Globals.memory.set(highAddress, programArgument.charAt(j), 1);
|
|
highAddress--;
|
|
}
|
|
argStartAddress[i] = highAddress+1;
|
|
}
|
|
// now place a null word, the arg starting addresses, and arg count onto stack.
|
|
int stackAddress = Memory.stackPointer; // base address for runtime stack.
|
|
if (highAddress < Memory.stackPointer) {
|
|
// Based on current values for stackBaseAddress and stackPointer, this will
|
|
// only happen if the combined lengths of program arguments is greater than
|
|
// 0x7ffffffc - 0x7fffeffc = 0x00001000 = 4096 bytes. In this case, set
|
|
// stackAddress to next lower word boundary minus 4 for clearance (since every
|
|
// byte from highAddress+1 is filled).
|
|
stackAddress = highAddress - (highAddress % Memory.WORD_LENGTH_BYTES) - Memory.WORD_LENGTH_BYTES;
|
|
}
|
|
Globals.memory.set(stackAddress, 0, Memory.WORD_LENGTH_BYTES); // null word for end of argv array
|
|
stackAddress -= Memory.WORD_LENGTH_BYTES;
|
|
for (int i=argStartAddress.length-1; i >= 0; i--) {
|
|
Globals.memory.set(stackAddress, argStartAddress[i], Memory.WORD_LENGTH_BYTES);
|
|
stackAddress -= Memory.WORD_LENGTH_BYTES;
|
|
}
|
|
Globals.memory.set(stackAddress, argStartAddress.length, Memory.WORD_LENGTH_BYTES); // argc
|
|
stackAddress -= Memory.WORD_LENGTH_BYTES;
|
|
|
|
// Need to set $sp register to stack address, $a0 to argc, $a1 to argv
|
|
// Need to by-pass the backstepping mechanism so go directly to Register instead of RegisterFile
|
|
Register[] registers = RegisterFile.getRegisters();
|
|
RegisterFile.getUserRegister("$sp").setValue(stackAddress+Memory.WORD_LENGTH_BYTES);
|
|
RegisterFile.getUserRegister("$a0").setValue(argStartAddress.length); // argc
|
|
RegisterFile.getUserRegister("$a1").setValue(stackAddress+Memory.WORD_LENGTH_BYTES+Memory.WORD_LENGTH_BYTES); // argv
|
|
//RegisterFile.updateRegister("$sp",stackAddress+Memory.WORD_LENGTH_BYTES);
|
|
//RegisterFile.updateRegister("$a0",argStartAddress.length); // argc
|
|
//RegisterFile.updateRegister("$a1",stackAddress+Memory.WORD_LENGTH_BYTES+Memory.WORD_LENGTH_BYTES); // argv
|
|
}
|
|
catch (AddressErrorException aee) {
|
|
System.out.println("Internal Error: Memory write error occurred while storing program arguments! "+aee);
|
|
System.exit(0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
}
|