问JAVA:子类，自学测试，课程作业，家庭作业。

EN

f0  lin 20 6
f1  lin 21 1
f2  lin 22 1
f3  mul 21 21 20
f4  sub 20 20 22
f5  bnz 20 f3
f6  out 21

import java.util.*;

// The machine language interpreter
public class Machine {
    // The labels in the MML program, in the order in which
    // they appear (are defined) in the program
    private Labels labels= new Labels(); 

    // The MML program, consisting of prog.size() instructions, each
    // of class Instruction (or one of its subclasses)
    private Vector prog= new Vector();   

    // The registers of the MML machine
    private Registers registers;

    // The program counter; it contains the index (in prog) of
    // the next instruction to be executed.
    private int PC= 0;

    public static void main (String[] pars) {

        Machine m= new Machine();
        Translator.readAndTranslate(m.labels, m.prog);

        System.out.println("Here is the program; it has " +
      m.prog.size() + " instructions.");
        m.print();
        System.out.println();

        System.out.println("Beginning program execution.");
        m.execute();
 System.out.println("Ending program execution.");

        System.out.println("Values of registers at program termination:");
        System.out.println(m.registers + ".");
 System.exit(0);
    }

    // Print the program
    public void print() {
        for (int i= 0; i != prog.size(); i++) {
            System.out.println((Instruction) prog.elementAt(i));
        }
    }

    // Execute the program in prog, beginning at instruction 0.
    // Precondition: the program and its labels have been store properly.
    public void execute() {
 PC= 0;
 registers= new Registers();
 while (PC < prog.size()) {
     Instruction ins= (Instruction)prog.elementAt(PC);
     PC= PC+1;
     ins.execute(this);
 }
    }

    // = the registers of this machine
    public Registers getRegisters() {
 return registers;
    }

    // = the labels of this machine
    public Labels getLabels() {
 return labels;
    }

    // Set the program counter to pc
    public void setPC(int pc) {
 PC= pc;
    }
}

import  java.io.*;
import  java.util.*;
import  javax.swing.*;

// The translator of a small program. All the fields and methods are static.
public class Translator {
    private static BufferedReader br; // Reader attached to the file chosen by the user

    // word + line is the part of the current line that's not yet processed
    // word has no whitespace
    // If word and line are not empty, line begins with whitespace
    private static String line="";    
    private static String word=""; 

    private static Labels labels; // The labels of the program being translated 
    private static Vector program;   // The program to be created  

    // Obtain a file name from the user and translate the 
    // small program in that file into lab (the labels) and
    // prog (the program)
    // return "no errors were detected"
    public static boolean readAndTranslate(Labels lab, Vector prog) {
        try {
            getReader();
        } catch(IOException ioE) {
            System.out.println("Sai: IO error to start " );
            return false;
        }
        labels= lab;
        labels.reset();
        program= prog;
        program.removeAllElements();

        try { line = br.readLine();
        }
        catch (IOException ioE) {
            return false;
        }

        // Each iteration processes line and reads the next line into line
        while (line != null) {
            // Store the label in label
     String label= scan(); 

            if (label.length() > 0) {

                Instruction ins= getInstruction(label);
                if ( ins != null ) {
                    labels.addLabel(label); 
                    program.addElement(ins);  
                }
            }

            try { line = br.readLine();
            }
            catch (IOException ioE) {
                return false;
            }

        }
        return true;
    }

    // line should consist of an MML instruction, with its label already
    // removed. Translate line into an instruction with label label
    // and return the instruction
    public static Instruction getInstruction(String label) {
        int s1;   // Possible operands of the instruction
        int s2;
        int r;
        int x;
        String L2;

        String ins= scan();
        if (line.equals("")) return null;

        if (ins.equals("add")) {
            r= scanInt();
            s1= scanInt();
            s2= scanInt();
            return new AddInstruction(label, r, s1, s2);
        }

        // You will have to write code here for the other instructions.

        return null;
     }


     // Display a JFileChooser and set br to a reader for the file chosen
     private static void getReader() throws IOException {
       JFileChooser chooser = new JFileChooser("C:\\Windows\\Desktop\\compiler\\test0.txt");
       chooser.setDialogTitle("Choose the File that contains the MML program to be executed");
       chooser.showOpenDialog(null);
       br =  new BufferedReader(new FileReader(chooser.getSelectedFile()));
     }

    // Return the first word of line and remove it from line.
    // If there is no word, return ""
    public static String scan() {
        line= line.trim();
        if (line.length() == 0) 
            {   return "";   }
        int i= 0;
        while (i < line.length() &&
               line.charAt(i) != ' ' &&
               line.charAt(i) != '\t') {
            i= i+1;
        }
        word= line.substring(0,i);
        line= line.substring(i);
        return word;
    }

    // Return the first word of line as an integer. If there is
    // any error, return the maximum int
    public static int scanInt() {
        String word= scan();
        if (word.length() == 0)
            { return Integer.MAX_VALUE; }

        try {
            return Integer.parseInt(word);
        } catch (NumberFormatException e) {
            return Integer.MAX_VALUE;
        }
    }
}

import java.util.*;

// An instance contains a list of Strings, called "labels",
// in the order in which they were added to the list. 
public class Labels {
    private Vector labels= new Vector();

    // Constructor: an empty list of labels
    public Labels() {
    }

    // Add label lab to this list and return its number in the list
    // (the first one added is number 0)
    // Precondition: the list has at most 49 entries
    public int addLabel(String lab) {
        labels.addElement(lab);
        return labels.size()-1;
    }

    // = the number of label lab in the list
    //   (= -1 if lab is not in the list)
    public int indexOf(String lab) {

        // invariant: lab is not in labels[0..i-1]
        for (int i= 0; i != labels.size(); i++) {
            if (lab.equals((String)(labels.elementAt(i)))) {
                return i;
            }
        }   
        return -1;
    }

    // representation of this instance, "(label 0, label 1, ..., label (n-1))"
    public String toString() {
        String r= "(";
        // invariant: r contains the representation for labels[0..i-1]
        // (with the opening "(" but no closing ")")
        for (int i= 0; i != labels.size(); i++) {
            if (i == 0) {
                r= r + (String)(labels.elementAt(i));
            } else {
                r= r + ", " + (String)(labels.elementAt(i));
            }
        }
        r= r + ")";
        return r;
    }

    // Set the number of elements in the list to 0
    public void reset() {
        labels.removeAllElements();
    }
}

// An instance contains 31 registers and methods to access
// and change them
public class Registers {
    private int registers[]= new int[31];

    // Constructor: an instance whose registers are set to 0
    public Registers() {
        for (int i= 0; i != registers.length; i++) {
            registers[i]= 0;
        }
    }

    // = the value in register i.
    // Precondition: 0 <= i < 32
    public int getRegister(int i) {
        return registers[i];
    }

    // Set register i to v.
    // Precondition: 0 <= i < 32
    public void setRegister(int i, int v) {
        registers[i]= v;
    }

    // =  a representation of the registers,
    //    "(reg 0, reg 1, ..., reg 31)"
    public String toString() {
        String r= "(" + registers[0];
        // invariant: r contains the representation for registers[0..i-1]
        // (with the opening "(" but no closing ")")
        for (int i= 1; i != registers.length; i++) {
            r= r + ", " + registers[i];
        }
        r= r + ")";
        return r;
    }
}

// This class is the superclass of the classes for machine instructions
public abstract class Instruction {

    // Constructor: an instruction with label l and opcode op
    // (op must be an operation of the language)
    public Instruction(String l, String op) {
    }

    // = the representation "label: opcode" of this Instruction
    public String toString() {
        return "";
    }

    // Execute this instruction on machine m. 
    public abstract void execute(Machine m);
}