codesegment.java

pl0编译器的java版本

import java.util.*;
import java.io.*;

// Code Structure of this Virtual Machine
class Instr {
    int fct;
    int level;
    int adr;

    Instr(int f, int l, int a) {
        fct = f;
        level = l;
        adr = a;
    }
}

public class CodeSegment {
    // Instruction types
    public static final int lit = 0;
    public static final int opr = 1;
    public static final int lod = 2;
    public static final int sto = 3;
    public static final int cal = 4;
    public static final int inct = 5;
    public static final int jmp = 6;
    public static final int jpc = 7;

    // opcodes for opr
    public static final int opReturn = 0;
    public static final int opUnaryMinus = 1;
    public static final int opPlus = 2;
    public static final int opMinus = 3;
    public static final int opTimes = 4;
    public static final int opDiv = 5;
    public static final int opOdd = 6;
    public static final int opEqual = 8;
    public static final int opNotEqual = 9;
    public static final int opLess = 10;
    public static final int opGreaterEqual = 11;
    public static final int opGreater = 12;
    public static final int opLessEqual = 13;
    public static final int opWrite = 14;
    public static final int opNewLine = 15;
    public static final int opRead = 16;
        
    // Size of a standard stack frame
    public static final int frameSize = 3;

    ArrayList code;
    String mnemonic[];

    CodeSegment() {
	    code = new ArrayList();
	    mnemonic = new String[jpc + 1];
	    mnemonic[lit] = "lit";
	    mnemonic[opr] = "opr";
	    mnemonic[lod] = "lod";
	    mnemonic[sto] = "sto";
	    mnemonic[cal] = "cal";
	    mnemonic[inct] = "int";
	    mnemonic[jmp] = "jmp";
	    mnemonic[jpc] = "jpc";
    }

    public void gen (int fct, int level, int addr) {
	    code.add(new Instr(fct, level, addr));
    }
    
    public void setAddrField(int instradr, int adrVal) {
	    try {
	        Instr i = (Instr) code.get(instradr);
	        i.adr = adrVal;
	    } catch (IndexOutOfBoundsException e) {
	    }
    }

    public int nextInstrAdr() {
	    return code.size();  // Current code position
    }


    public void list(PrintWriter out, int firstadr, int lastadr) {
        try {
    	    for (int i=firstadr; i <= lastadr; i++) {
    		    Instr inst = (Instr) code.get(i);
    		    out.println(StringJustify.right(String.valueOf(i), 11) + 
    			    "  " + StringJustify.left(mnemonic[inst.fct], 5) + 
    			    StringJustify.right(String.valueOf(inst.level), 3)+
    			    StringJustify.right(String.valueOf(inst.adr), 5));
    	    }
    	} catch (IndexOutOfBoundsException e) {
    	}
    }

    public void interpret(PrintWriter out) throws IOException {
	    final int stacksize = 500;
	    int s[] = new int[stacksize];

    	int pc;    // p in pl0.p
    	int fp;    // b in pl0.p
    	int sp;    // t in pl0.p
    	Instr i;
    
    	out.println(" START PL/0");

    	sp = -1;
    	fp = 0;
    	pc = 0;
    	s[0] = s[1] = s[2] = 0;

    	do {
    	    i = (Instr) code.get(pc);
    	    pc++;
    	    switch (i.fct) {
    	        
        	    case lit:
            		sp++;
            		s[sp] = i.adr;
        		break;
    
        	    case opr:
        		switch(i.adr) {
            		case opReturn:    // return
            		    sp = fp - 1;
            		    pc = s[sp + 3];
            		    fp = s[sp + 2];
            		    break;
            
            		case opUnaryMinus:
            		    s[sp] = -s[sp];
            		    break;
            
            		case opPlus:
            		    sp--;
            		    s[sp] += s[sp+1];
            		    break;
            
            		case opMinus:
            		    sp--;
            		    s[sp] -= s[sp+1];
            		    break;
            
            		case opTimes:
            		    sp--;
            		    s[sp] *= s[sp+1];
            		    break;
            
            		case opDiv:
            		    sp--;
            		    s[sp] = s[sp] / s[sp+1];
            		    break;
            
            		case opOdd:
            		    s[sp] = s[sp] % 2 == 0 ? 0 : 1;
            		    break;
            
            		case opEqual:
            		    sp--;
            		    s[sp] = bool2int(s[sp] == s[sp+1]);
            		    break;
            		    
            		case opNotEqual:
            		    sp--;
            		    s[sp] = bool2int(s[sp] != s[sp+1]);
            		    break;
            		    
            		case opLess:
            		    sp--;
            		    s[sp] = bool2int(s[sp] < s[sp+1]);
            		    break;
            		    
            		case opGreaterEqual:
            		    sp--;
            		    s[sp] = bool2int(s[sp] >= s[sp+1]);
            		    break;
            		    
            		case opGreater:
            		    sp--;
            		    s[sp] = bool2int(s[sp] > s[sp+1]);
            		    break;
            		    
            		case opLessEqual:
            		    sp--;
            		    s[sp] = bool2int(s[sp] <= s[sp+1]);
            		    break;
                        
                    case opWrite:
                        out.println(StringJustify.right(String.valueOf(s[sp]), 11));
                        sp--;
                        break;
                        
                    case opNewLine:
                        out.println("\n");
                        break;
                        
                    case opRead:
                        System.out.print(">");
                        BufferedReader in
                               = new BufferedReader(new InputStreamReader(System.in));
                        String src_num = in.readLine();
                        s[sp+1] = Integer.valueOf(src_num).intValue();
                        sp++;
                        break;    
        		    }
        		    break;
    
        	    case lod:
            		sp++;
            		s[sp] = s[base(s, fp, i.level) + i.adr];
        		    break;
        
        	    case sto:
            		s[base(s, fp, i.level) + i.adr] = s[sp];
            		//out.println(StringJustify.right(String.valueOf(s[sp]), 11));
            		sp--;
        		    break;
        
        	    case cal:  // generate new block mark
            		s[sp+1] = base(s, fp, i.level);
            		s[sp+2] = fp;
            		s[sp+3] = pc;
            		fp = sp + 1;
            		pc = i.adr;
        		    break;
        
        	    case inct:
            		sp = sp + i.adr;
        		    break;
        
        	    case jmp:
            		pc = i.adr;
        		    break;
        
        	    case jpc:
            		if (s[sp] == 0) {
            		    pc = i.adr;
            		}
            		sp--;
           		    break;
           		
    	    }
    	} while (pc != 0);

    	out.println(" END PL/0");
    }

    int base(int s[], int fp, int level) {
	    while (level > 0) {
	        fp = s[fp];
	        level--;
	    }
	    return fp;
    }

    int bool2int(boolean b) {
        return b ? 1 : 0;
    }
}