parse.java

pl0编译器的java版本

                    hs = new HashSet(followSet);
                    hs.add(new Integer(Symbol.comma));
                    hs.add(new Integer(Symbol.rparen));
                    expression(hs);
                    code.gen(CodeSegment.opr, 0, CodeSegment.opWrite);
                } while(sym.symtype == Symbol.comma);
                if (sym.symtype != Symbol.rparen) {
                    error(33);
                } else {
                    getSym();
                }
            }
            code.gen(CodeSegment.opr, 0, CodeSegment.opNewLine);
       	} else if (sym.symtype == Symbol.callsym) {
    	    getSym();
    	    if (sym.symtype != Symbol.ident) {
    	    	error(14);
    	    } else {
    		    plo = findSym(sym.id);
    		    if (plo == null) {
    		        error(11);
    		    } else {
    		        if (plo.kind == PLobject.PLprocedure) {
    			        code.gen(CodeSegment.cal, level - plo.level, plo.adr);
    		        } else {
    			        error(15);
    		        }
    		    }
    		    getSym();
    	    }
     	} else if (sym.symtype == Symbol.ifsym) {
    	    getSym();
    	    hs = new HashSet(followSet);
    	    hs.add(new Integer(Symbol.thensym));
    	    hs.add(new Integer(Symbol.dosym));
    	    condition(hs);
    	    if (sym.symtype == Symbol.thensym) {
    	    	getSym();
    	    } else {
    		    error(16);
    	    }
    
    	    int codePosn = code.nextInstrAdr();
    	    code.gen(CodeSegment.jpc, 0, 0);
    	    statement(followSet);
    	    code.setAddrField(codePosn, code.nextInstrAdr());
    
    	} else if (sym.symtype == Symbol.beginsym) {
    	    getSym();
    	    hs = new HashSet(followSet);
    	    hs.add(new Integer(Symbol.thensym));
    	    hs.add(new Integer(Symbol.dosym));
    	    statement(hs);
    
    	    while (statementBegin.contains(new Integer(sym.symtype)) || sym.symtype == Symbol.semicolon) {
    		    if (sym.symtype == Symbol.semicolon) {
    		        getSym();
    		    } else {
    		        error(10);
    		    }
    		    hs = new HashSet(followSet);
    		    hs.add(new Integer(Symbol.endsym));
    		    hs.add(new Integer(Symbol.semicolon));
    		    statement(hs);
    	    }
    
    	    if (sym.symtype == Symbol.endsym) {
    		    getSym();
    	    } else {
    		    error(17);
    	    }
    
    	} else if (sym.symtype == Symbol.whilesym) {
    	    getSym();
    	    int loopTop = code.nextInstrAdr();
    	    hs = new HashSet(followSet);
    	    hs.add(new Integer(Symbol.dosym));
    	    condition(hs);
    
    	    int jmpPos = code.nextInstrAdr();
    	    code.gen(CodeSegment.jpc, 0, 0);
    	    if (sym.symtype == Symbol.dosym) {
    	    	getSym();
    	    } else {
    		    error(18);
    	    }
    
    	    statement(followSet);
    	    code.gen(CodeSegment.jmp, 0, loopTop);
    	    code.setAddrField(jmpPos, code.nextInstrAdr());
    	}
    
    	test(followSet, new HashSet(), 19);
    }

    void expression(HashSet followSet) throws IOException {
    	Symbol addop;
    
    	HashSet hs = new HashSet(followSet);
    	hs.add(new Integer(Symbol.plus));
    	hs.add(new Integer(Symbol.minus));
    
    	if (sym.symtype == Symbol.plus || sym.symtype == Symbol.minus) {
    	    addop = sym;
    	    getSym();
    	    term(hs);
   
    	    if (addop.symtype == Symbol.minus) {
        		code.gen(CodeSegment.opr, 0, CodeSegment.opUnaryMinus);
    	    }
    	} else {
    	    term(hs);
    	}
    
    	while (sym.symtype == Symbol.plus || sym.symtype == Symbol.minus) {
    	    addop = sym;
    	    getSym();
    	    term(hs);
    	    if (addop.symtype == Symbol.plus) {
        		code.gen(CodeSegment.opr, 0, CodeSegment.opPlus);
    	    } else {
    	    	code.gen(CodeSegment.opr, 0, CodeSegment.opMinus);
    	    }
    	}
    }

    void term(HashSet followSet) throws IOException {
	    Symbol mulop;

	    HashSet hs = new HashSet(followSet);
	    hs.add(new Integer(Symbol.times));
	    hs.add(new Integer(Symbol.slash));

	    factor(hs);
	    while (sym.symtype == Symbol.times || sym.symtype == Symbol.slash) {
	        mulop = sym;
	        getSym();
	        factor(hs);
	        if (mulop.symtype == Symbol.times) {
		        code.gen(CodeSegment.opr, 0, CodeSegment.opTimes);
	        } else {
		        code.gen(CodeSegment.opr, 0, CodeSegment.opDiv);
	        }
	    }
    }

    void factor(HashSet followSet) throws IOException {
	    HashSet hs;

	    test(factorBegin, followSet, 24);
	    
	    // the original while() is problematic, thanks to macross
	    // while (factorBegin.contains(new Integer(sym.symtype))) {
	    if (factorBegin.contains(new Integer(sym.symtype))) {
	        if (sym.symtype == Symbol.ident) {
		        PLobject plo = findSym(sym.id);
		        if (plo == null) {
		            error(11);
		        } else {
		            switch(plo.kind) {
            		    //case plo.constant:
            			case 0:
            			    code.gen(CodeSegment.lit, 0, plo.val);
            			    break;
            		    //case plo.variable:
            		    case 1:
            			    code.gen(CodeSegment.lod, level - plo.level, plo.adr);
            			    break;
            		    //case plo.PLprocedure:
            		    case 2:
            			    error(21);
            			    break;
        		    }
	        	}
		        getSym();
	        } else if (sym.symtype == Symbol.number) {
		        if (sym.num > amax) {
		            error(31);
		            sym.num = 0;
		        }
		        code.gen(CodeSegment.lit, 0, sym.num);
		        getSym();
	        } else if (sym.symtype == Symbol.lparen) {
		        hs = new HashSet(followSet);
		        hs.add(new Integer(Symbol.rparen));
		        expression(hs);
		        if (sym.symtype == Symbol.rparen) {
		            getSym();
		        } else {
		            error(22);
		        }
	        }
	        
	        hs =  new HashSet();
	        hs.add(new Integer(Symbol.lparen));
	        test(followSet, hs, 23);
	    }
    }


    void condition(HashSet followSet) throws IOException {
	    Symbol op;

	    if (sym.symtype == Symbol.oddsym) {
	        getSym();
	        expression(followSet);
	        code.gen(CodeSegment.opr, 0, CodeSegment.opOdd);
	    } else {
	        HashSet hs = new HashSet(followSet);
	        hs.addAll(relops);
	        expression(hs);
	        op = sym;
	        if (!relops.contains(new Integer(op.symtype))) {
		        error(20);
	        } else {
		        getSym();
		        expression(followSet);
		        int opcode = -1;
		        switch(op.symtype) {
            		case Symbol.eql: opcode = CodeSegment.opEqual; break;
            		case Symbol.neq: opcode = CodeSegment.opNotEqual; break;
            		case Symbol.lss: opcode = CodeSegment.opLess; break;
            		case Symbol.leq: opcode = CodeSegment.opLessEqual; break;
            		case Symbol.gtr: opcode = CodeSegment.opGreater; break;
            		case Symbol.geq: opcode = CodeSegment.opGreaterEqual; break;
        		}
    	    	code.gen(CodeSegment.opr, 0, opcode);
	        }
	    }
    }


    PLobject findSym(String name)
    {
	    PLobject plo;

	    for (int i=symTable.size()-1; i>=0; i--) {
    	    plo = (PLobject) symTable.get(i);
	        if (name.compareTo(plo.name) == 0) {
		        return plo;
	        }
	    }
	    return null;
    }

    void test(HashSet set1, HashSet set2, int errno) throws IOException
    {
	    Integer symbol = new Integer(sym.symtype);

	    if (!set1.contains(symbol)) {
	        error(errno);
	        while(!set1.contains(symbol) && !set2.contains(symbol)) {
		        getSym();
		        symbol = new Integer(sym.symtype);
	        }
	    }
    }

    void error(int errnum) {
    	outFile.print(" **** ");
    	for (int i=0; i<scanner.linePosn(); i++) {
    	    outFile.print(" ");
    	}
    	outFile.println("^" + errnum);
    	errcnt++;
    }

    void getSym() throws IOException {
	    sym = scanner.getSym();
    }

    public void lineRead(String line) {
	    String codeSize = String.valueOf(code.nextInstrAdr());
	    outFile.println(StringJustify.right(codeSize, 5) + " " + line);
	}

    /*
    public static void main(String args[]) {
	    Parse p = new Parse();
	    BufferedReader inp = 
	        new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter outp = new PrintWriter(System.out, true);

	    CodeSegment cs = p.doScan(inp, outp);
    }
    */
}