/* --- Copyright Jonathan Meyer 1997. All rights reserved. -----------------
> File: jasmin/src/jasmin/ClassFile.java
> Purpose: Uses a parser and the JAS package to create Java class files
> Author: Jonathan Meyer, 10 July 1996
*/
package jasmin;
/*
* This class is a bit monolithic, and should probably be converted into
* several smaller classes. However, for this specific application,
* its acceptable.
*
*/
import jas.*;
import java.io.*;
import java.util.*;
/**
* A ClassFile object is used to represent the binary data that makes up a
* Java class file - it also serves as the public
* API to the Jasmin assembler, though users should beware: the API
* is likely to change in future versions (though its such a small API
* at the moment that changes are likely to have only a small impact).<p>
*
* To assemble a file, you first construct a jasmin.ClassFile object, then
* call readJasmin() to read in the contents of a Jasmin assembly file, then
* call write() to write out the binary representation of the class file.<p>
*
* There are a few other utility methods as well. See Main.java for an example
* which uses all of the public methods provided in ClassFile.
*
* @author Jonathan Meyer
* @version 1.05, 8 Feb 1997
*/
public class ClassFile {
private static final boolean PARSER_DEBUG = false;
// state info for the class being built
String filename;
ClassEnv class_env;
String class_name;
String source_name;
Scanner scanner;
// state info for the current method being defined
ExceptAttr except_attr;
Catchtable catch_table;
LocalVarTableAttr var_table;
LocalVarTypeTableAttr vtype_table;
LineTableAttr line_table;
CodeAttr code;
Method cur_method;
Var cur_field;
Hashtable labels;
StackMap stackmap;
VerifyFrame verifyframe;
Annotation cur_annotation;
int line_label_count, line_num, stack_map_label_count;
boolean auto_number, class_header;
Insn buffered_insn;
// state info for lookupswitch and tableswitch instructions
Vector switch_vec;
int low_value;
int high_value;
static final String BGN_METHOD = "jasmin_reserved_bgnmethod:";
static final String END_METHOD = "jasmin_reserved_endmethod:";
// number of errors reported in a file.
int errors;
//
// Error reporting method
//
void report_error(String msg) { report_error(msg, false); }
void report_error(String msg, boolean BadIntVal) {
if(Main.DEBUG)
throw new RuntimeException();
errors++;
// Print out filename/linenumber/message
System.err.print(filename + ":");
if (scanner == null)
System.err.println(" " + msg + ".");
else {
String dia_line;
int dia_linnum, dia_charpos;
if (BadIntVal && scanner.char_num >= 0) {
dia_line = scanner.int_line;
dia_linnum = scanner.int_line_num;
dia_charpos = scanner.int_char_num;
} else {
dia_line = scanner.line.toString();
dia_linnum = scanner.line_num;
dia_charpos = scanner.char_num;
}
System.err.println(dia_linnum + ": " + msg + ".");
if (scanner.char_num >= 0) {
System.err.println(dia_line);
// Print out where on the line the scanner got to
int i;
for (i = 0; i < dia_charpos; i++) {
if (dia_line.charAt(i) == '\t') {
System.err.print("\t");
} else {
System.err.print(" ");
}
}
System.err.println("^");
}
}
}
//
// called by the .source directive
//
void setSource(String name) {
source_name = name;
}
//
// called by the .bytecode directive
//
void setVersion(Number version) {
String str = version.toString();
int idx = str.indexOf(".");
if(!(version instanceof Float) || (idx == -1))
report_error("invalid bytecode version number : " + str);
class_env.setVersion(Short.parseShort(str.substring(0,idx)),
Short.parseShort(str.substring(idx+1,str.length())));
}
//
// called by the .class directive
//
void setClass(String name, short acc) {
class_name = name;
class_env.setClass(new ClassCP(name));
class_env.setClassAccess(acc);
class_header = true;
}
//
// called by the .super directive
//
void setSuperClass(String name) {
class_env.setSuperClass(new ClassCP(name));
}
//
// called by the .implements directive
//
void addInterface(String name) {
class_env.addInterface(new ClassCP(name));
}
//
// called by the .debug directive
//
void setSourceDebugExtension(String str) {
class_env.setSourceDebugExtension(str);
}
//
// called by the .enclosing directive
//
void setEnclosingMethod(String str) {
try {
if(str.indexOf("(") != -1) { // full method description
String[] split = ScannerUtils.splitClassMethodSignature(str);
class_env.setEnclosingMethod(split[0], split[1], split[2]);
}
else // just a class name
class_env.setEnclosingMethod(str, null, null);
} catch(IllegalArgumentException e) {
report_error(e.toString());
}
}
// parser diagnostics
private static void opened_annotation(String fld) throws jasError
{ throw new jasError("Skipped .end annotation in " + fld); }
private static void outside(String dir) throws jasError
{ throw new jasError("illegal use of " +dir+
" outside of method/field definition or class header"); }
//
// called at end of jasmin-header (resolve class variables)
//
public void endHeader() throws jasError
{
if(cur_annotation != null)
opened_annotation("class header");
class_env.endHeader(); // resolve annotations
class_header = false;
}
//
// called by the .signature directive
//
void setSignature(String str) throws jasError
{
SignatureAttr sig = new SignatureAttr(str);
if (cur_method != null) {
cur_method.setSignature(sig);
} else if(cur_field != null) {
cur_field.setSignature(sig);
} else if(class_header) {
class_env.setSignature(str);
} else {
outside(".signature");
}
}
//
// called by the .deprecated directive
//
//
void setDeprecated() throws jasError
{
DeprecatedAttr depr = new DeprecatedAttr();
if ( cur_method != null ) {
cur_method.setDeprecated(depr);
} else if(cur_field != null) {
cur_field.setDeprecated(depr);
} else if(class_header) {
class_env.setDeprecated(depr);
} else {
outside(".deprecated");
}
}
//
// called by the .attribute directive
//
void addGenericAttr(String name, String file)
throws IOException, jasError
{
GenericAttr gattr = new GenericAttr(name, file);
if (cur_method != null) {
flushInsnBuffer();
if(code != null) code.addGenericAttr(gattr);
else cur_method.addGenericAttr(gattr);
} else if(cur_field != null) {
cur_field.addGenericAttr(gattr);
} else if (class_header) {
class_env.addGenericAttr(gattr);
} else {
outside(".attribute");
}
}
//
// called by the .inner directive
//
//
public void addInner(short iacc, String name, String inner, String outer)
{ class_env.addInnerClass(iacc, name, inner, outer); }
//
// procedure group for annotation description
//
private static void annotation_internal() throws jasError
{ throw new jasError("logic error in .annotation parsing"); }
void addAnnotation() throws jasError
{
if(cur_method == null) Annotation.ParserError();
cur_annotation = cur_method.addAnnotation();
}
void addAnnotation(boolean visible, String clname, int paramnum)
throws jasError
{
if(cur_method == null) Annotation.ParserError();
cur_annotation = cur_method.addAnnotation(visible, clname, paramnum);
}
void addAnnotation(boolean visible, String clname) throws jasError
{
if (cur_method != null) {
cur_annotation = cur_method.addAnnotation(visible, clname);
} else if(cur_field != null) {
cur_annotation = cur_field.addAnnotation(visible, clname);
} else if (class_header) {
cur_annotation = class_env.addAnnotation(visible, clname);
} else {
outside(".annotation");
}
}
void addAnnotationField(String name, String type, String add)
throws jasError
{
if(cur_annotation == null) annotation_internal();
cur_annotation.addField(name, type, add);
}
void addAnnotationValue(Object value) throws jasError
{
if(cur_annotation == null) annotation_internal();
cur_annotation.addValue(value);
}
void nestAnnotation() throws jasError
{
if(cur_annotation == null) annotation_internal();
cur_annotation = cur_annotation.nestAnnotation();
}
void endAnnotation() throws jasError
{
if(cur_annotation == null)
throw new jasError(".end annotation without .annotation");
cur_annotation = cur_annotation.endAnnotation();
}
// called by the .field directive to begin 'prompted' field
//
void beginField(short access, String name, String desc, Object value)
throws jasError
{
ConstAttr ca = null;
if (value != null) {
CP cp;
// create a constant pool entry for the initial value
if (value instanceof Integer) {
cp = new IntegerCP(((Integer)value).intValue());
} else if (value instanceof Float) {
cp = new FloatCP(((Float)value).floatValue());
} else if (value instanceof Double) {
cp = new DoubleCP(((Double)value).doubleValue());
} else if (value instanceof Long) {
cp = new LongCP(((Long)value).longValue());
} else if (value instanceof String) {
cp = new StringCP((String)value);
} else {
throw new jasError("usupported value type");
}
ca = new ConstAttr(cp);
}
cur_field = new Var(access, new AsciiCP(name), new AsciiCP(desc), ca);
}
//
// called by the .end field directive to end 'prompted' field
//
void endField() throws jasError {
if (cur_field == null)
throw new jasError(".end field without .field");
if (cur_annotation != null)
opened_annotation("field");
class_env.addField(cur_field);
cur_field = null;
}
//
// called by the .field directive
//
void addField(short access, String name, String desc,
String sig, Object value) throws jasError {
beginField(access, name, desc, value);
if (sig != null) cur_field.setSignature(new SignatureAttr(sig));
endField();
}
//
// called by the .method directive to start the definition for a method
//
void newMethod(String name, String descriptor, int access) {
// set method state variables
labels = new Hashtable();
code = null;
except_attr = null;
catch_table = null;
var_table = null;
vtype_table = null;
line_table = null;
line_label_count = 0;
stack_map_label_count = 0;
stackmap = null;
verifyframe = null;
cur_method = new Method((short)access, new AsciiCP(name),
new AsciiCP(descriptor));
}
//
// called by the .end method directive to end the definition for a method
//
void endMethod() throws jasError {
if (cur_method == null)
throw new jasError(".end method without .method");
if (cur_annotation != null)
opened_annotation("method");
if (code != null) {
plantLabel(END_METHOD);
flushInsnBuffer();
if (catch_table != null) {
code.setCatchtable(catch_table);
}
if (var_table != null) {
code.setLocalVarTable(var_table);
}
if (vtype_table != null) {
code.setLocalVarTypeTable(vtype_table);
}
if (line_table != null) {
code.setLineTable(line_table);
}
if (stackmap != null) {
code.setStackMap(stackmap);
}
}
cur_method.setCode(code, except_attr);
class_env.addMethod(cur_method);
// clear method state variables
cur_method = null;
code = null;
labels = null;
catch_table = null;
line_table = null;
var_table = null;
vtype_table = null;
stackmap = null;
verifyframe = null;
}
// get last stackmap locals vector
private Vector prevStack(int count) throws jasError {
Vector prev = null;
if(stackmap != null)
prev = stackmap.getLastFrame(count);
return prev;
}
// define a new stack map frame (possible with copy previous)
void beginStack(boolean copy) throws jasError {
Vector prev = null;
if(copy)
prev = prevStack(0);
verifyframe = new VerifyFrame(prev);
}
// define a new stack map frame and copy 'n' previous
// (type-independet) elements
void beginStack(int n) throws jasError {
if(n <= 0)
throw new jasError("Invalid counter", true);
verifyframe = new VerifyFrame(prevStack(n));
}
// define the offset of the current stack map frame
void plantStackOffset(int n) {
try {
verifyframe.setOffset(n);
} catch(jasError e) {
report_error(e.toString());
}
}
void plantStackOffset(String label) throws jasError {
Label l = getLabel(label);
try {
verifyframe.setOffset(l);
} catch(jasError e) {
report_error(e.toString());
}
}
// add a local variable item to the current stack map frame
void plantStackLocals(String item, String val) {
try {
verifyframe.addLocalsItem(item, val);
} catch(jasError e) {
report_error(e.toString());
}
}
// add a stack item element to the current stack map frame
void plantStackStack(String item, String val) {
try {
verifyframe.addStackItem(item, val);
} catch(jasError e) {
report_error(e.toString());
}
}
// add the current stack map frame to the current stack map attribute
void endStack() {
if(!verifyframe.haveOffset()) {
String l = "jasmin_reserved_SM:" + (stack_map_label_count++);
try {
plantLabel(l);
verifyframe.setOffset(getLabel(l));
} catch(jasError e) {
report_error(e.toString());
}
}
if(stackmap==null)
stackmap = new StackMap(class_env);
stackmap.addFrame(verifyframe);
verifyframe = null; // PARANOYA
}
//
// plant routines - these use addInsn to add instructions to the
// code for the current method.
//
//
// used for instructions that take no arguments
//
void plant(String name) throws jasError {
InsnInfo insn = InsnInfo.get(name);
autoNumber();
flushInsnBuffer();
if (insn.args.equals("")) {
bufferInsn(new Insn(insn.opcode));
} else {
throw new jasError("Missing arguments for instruction " + name);
}
}
//
// used for relative branch targets (ie $+5, $-12, ...)
//
void plantRelativeGoto(String name, int val) throws jasError {
InsnInfo insn = InsnInfo.get(name);
if (insn.args.equals("label")) {
bufferInsn(new Insn(insn.opcode, val, true));
} else { // forward the request for "normal" instructions
plant(name, val);
}
}
//
// used for iinc
//
void plant(String name, int v1, int v2)
throws jasError
{
InsnInfo insn = InsnInfo.get(name);
autoNumber();
flushInsnBuffer();
if (insn.args.equalsIgnoreCase("ii")) {
bufferInsn(new IincInsn(v1, v2, insn.args.charAt(0) == 'I'));
} else {
throw new jasError("Bad arguments for instruction " + name);
}
}
//
// used for instructions that take an integer parameter
// (branches are part of this, the int is converted to a label)
//
void plant(String name, int val) throws jasError {
InsnInfo insn = InsnInfo.get(name);
CodeAttr code = _getCode();
autoNumber();
flushInsnBuffer();
if (insn.args.equalsIgnoreCase("i")) {
bufferInsn(new Insn(insn.opcode, val, insn.args.charAt(0) == 'I'));
} else if (insn.args.equals("constant")) {
bufferInsn(new Insn(insn.opcode, new IntegerCP(val)));
} else if (insn.args.equals("bigconstant")) {
bufferInsn(new Insn(insn.opcode, new LongCP(val)));
} else if (insn.args.equals("label")) {
plant(name, String.valueOf(val)); // the target is not signed
// assume it is a label
} else {
throw new jasError("Bad arguments for instruction " + name);
}
}
//
// used for ldc and other instructions that take a numeric argument
//
void plant(String name, Number val) throws jasError {
InsnInfo insn = InsnInfo.get(name);
CodeAttr code = _getCode();
autoNumber();
flushInsnBuffer();
if (insn.args.equalsIgnoreCase("i") && (val instanceof Integer)) {
bufferInsn(new Insn(insn.opcode, val.intValue(), insn.args.charAt(0) == 'I'));
} else if (insn.args.equals("constant")) {
if (val instanceof Integer || val instanceof Long) {
bufferInsn(new Insn(insn.opcode,
new IntegerCP(val.intValue())));
} else if (val instanceof Float || val instanceof Double) {
bufferInsn(new Insn(insn.opcode,
new FloatCP(val.floatValue())));
}
} else if (insn.args.equals("bigconstant")) {
if (val instanceof Integer || val instanceof Long) {
bufferInsn(new Insn(insn.opcode,
new LongCP(val.longValue())));
} else if (val instanceof Float || val instanceof Double) {
bufferInsn(new Insn(insn.opcode,
new DoubleCP(val.doubleValue())));
}
} else {
throw new jasError("Bad arguments for instruction " + name);
}
}
//
// used for ldc <quoted-string>
//
void plantString(String name, String val) throws jasError {
InsnInfo insn = InsnInfo.get(name);
autoNumber();
flushInsnBuffer();
if (insn.args.equals("constant")) {
bufferInsn(new Insn(insn.opcode, new StringCP(val)));
} else {
throw new jasError("Bad arguments for instruction " + name);
}
}
//
// used for invokeinterface and multianewarray
//
void plant(String name, String val, int nargs)
throws jasError
{
InsnInfo insn = InsnInfo.get(name);
CodeAttr code = _getCode();
autoNumber();
flushInsnBuffer();
if (insn.args.equals("interface")) {
String split[] = ScannerUtils.splitClassMethodSignature(val);
bufferInsn(new InvokeinterfaceInsn(
new InterfaceCP(split[0], split[1],
split[2]), nargs));
} else if (insn.args.equals("marray")) {
bufferInsn(new MultiarrayInsn(new ClassCP(val), nargs));
} else {
throw new jasError("Bad arguments for instruction " + name);
}
}
//
// used for instructions that take a word as a parameter
// (e.g. branches, newarray, invokemethod)
//
void plant(String name, String val) throws jasError {
InsnInfo insn = InsnInfo.get(name);
CodeAttr code = _getCode();
autoNumber();
flushInsnBuffer();
if (insn.args.equals("method")) {
String split[] = ScannerUtils.splitClassMethodSignature(val);
bufferInsn(new Insn(insn.opcode,
new MethodCP(split[0], split[1], split[2])));
} else if (insn.args.equals("constant")) {
bufferInsn(new Insn(insn.opcode, new ClassCP(val)));
} else if (insn.args.equals("atype")) {
int atype = 0;
if (val.equals("boolean")) {
atype = 4;
} else if (val.equals("char")) {
atype = 5;
} else if (val.equals("float")) {
atype = 6;
} else if (val.equals("double")) {
atype = 7;
} else if (val.equals("byte")) {
atype = 8;
} else if (val.equals("short")) {
atype = 9;
} else if (val.equals("int")) {
atype = 10;
} else if (val.equals("long")) {
atype = 11;
} else {
throw new jasError("Bad array type: " + name);
}
bufferInsn(new Insn(insn.opcode, atype, false));
} else if (insn.args.indexOf("label")>=0) {
bufferInsn(new Insn(insn.opcode, getLabel(val), scanner.line_num));
} else if (insn.args.equals("class")) {
bufferInsn(new Insn(insn.opcode, new ClassCP(val)));
} else {
throw new jasError("(gloups)Bad arguments for instruction " + name);
}
}
//
// used for instructions that take a field and a signature as parameters
// (e.g. getstatic, putstatic)
//
void plant(String name, String v1, String v2)
throws jasError
{
InsnInfo info = InsnInfo.get(name);
CodeAttr code = _getCode();
autoNumber();
flushInsnBuffer();
if (info.args.equals("field")) {
String split[] = ScannerUtils.splitClassField(v1);
if(split[1] == null)
throw new jasError("can't extract field from "+v1);
bufferInsn(new Insn(info.opcode,
new FieldCP(split[0], split[1], v2)));
} else {
throw new jasError("Bad arguments for instruction " + name);
}
}
//
// Lookupswitch instruction
//
void newLookupswitch() throws jasError {
switch_vec = new Vector();
autoNumber();
};
void addLookupswitch(int val, String label)
throws jasError {
switch_vec.addElement(new Integer(val));
switch_vec.addElement(new LabelOrOffset(getLabel(label)));
};
void addLookupswitch(int val, int offset)
throws jasError {
switch_vec.addElement(new Integer(val));
switch_vec.addElement(new LabelOrOffset(offset));
};
void endLookupswitch(String deflabel) throws jasError {
flushInsnBuffer();
Object[] offlabs = checkLookupswitch();
int[] offsets = (int[])offlabs[0];
LabelOrOffset[] labels = (LabelOrOffset[])offlabs[1];
LabelOrOffset defl = new LabelOrOffset(getLabel(deflabel));
bufferInsn(new LookupswitchInsn(defl, offsets, labels));
}
void endLookupswitch(int defoffset) throws jasError {
flushInsnBuffer();
Object[] offlabs = checkLookupswitch();
int[] offsets = (int[])offlabs[0];
LabelOrOffset[] labels = (LabelOrOffset[])offlabs[1];
bufferInsn(new LookupswitchInsn(new LabelOrOffset(defoffset),
offsets, labels));
}
//
// called by both endLookupswitch() methods
//
private Object[] checkLookupswitch() {
int n = switch_vec.size() >> 1;
int offsets[] = new int[n];
LabelOrOffset labels[] = new LabelOrOffset[n];
Enumeration e = switch_vec.elements();
int i = 0;
while (e.hasMoreElements()) {
offsets[i] = ((Integer)e.nextElement()).intValue();
labels[i] = (LabelOrOffset)e.nextElement();
i++;
}
Object result[] = { offsets, labels };
return result;
}
//
// Tableswitch instruction
//
void newTableswitch(int lowval) throws jasError {
newTableswitch(lowval, -1);
};
void newTableswitch(int lowval, int hival) throws jasError {
switch_vec = new Vector();
low_value = lowval;
high_value = hival;
autoNumber();
};
void addTableswitch(String label) throws jasError {
switch_vec.addElement(new LabelOrOffset(getLabel(label)));
};
void addTableswitch(int offset) throws jasError {
switch_vec.addElement(new LabelOrOffset(offset));
};
void endTableswitch(String deflabel) throws jasError {
flushInsnBuffer();
LabelOrOffset labels[] = checkTableswitch();
bufferInsn(new TableswitchInsn(low_value,
low_value+labels.length-1,
new LabelOrOffset(getLabel(deflabel)),
labels));
}
void endTableswitch(int defoffset) throws jasError {
flushInsnBuffer();
LabelOrOffset labels[] = checkTableswitch();
bufferInsn(new TableswitchInsn(low_value,
low_value+labels.length-1, new LabelOrOffset(defoffset), labels));
}
//
// called by both endTableswitch() methods
//
private LabelOrOffset[] checkTableswitch() {
int n = switch_vec.size();
LabelOrOffset labels[] = new LabelOrOffset[n];
Enumeration e = switch_vec.elements();
int i = 0;
while (e.hasMoreElements()) {
labels[i] = (LabelOrOffset)e.nextElement();
i++;
}
if (high_value != -1 && (high_value != low_value + n - 1)) {
report_error("tableswitch - given incorrect value for <high>");
}
return labels;
}
// Used by the parser to tell ClassFile what the line number
// for the next statement is. ClassFile's autoNumber mechanism
// uses this info.
void setLine(int l) { line_num = l; }
//
// If auto_number is true, output debugging line number table
// for Jasmin assembly instructions.
//
void autoNumber() throws jasError {
if (auto_number) {
// use the line number of the last token
addLineInfo(line_num);
}
}
//
// Label management
//
//
// gets the Label object for a label, creating it if it doesn't exist
//
Label getLabel(String name) throws jasError {
// check that we are inside of a method definition
if (cur_method == null) {
throw new jasError( "illegal use of label outside of method definition");
}
Label lab = (Label)labels.get(name);
if (lab == null) {
lab = new Label(name);
labels.put(name, lab);
}
return lab;
}
//
// defines a label
//
void plantLabel(String name) throws jasError {
// System.out.println("planting label "+name);
try {
Integer.parseInt(name);
// the label is a number, we must add it *before* the buffered insn
// this is the reason to use a buffer instructions
_getCode().addInsn(getLabel(name));
flushInsnBuffer();
} catch(NumberFormatException e) {
// traditional label (word), add it *after* the buffered insn
flushInsnBuffer();
bufferInsn(getLabel(name));
}
}
// if there is an instruction in the buffer, add it to the code
// and put the new instruction in the buffer
void bufferInsn(Insn i) throws jasError{
if(i == null)
throw new jasError("trying to buffer a null instruction");
if(buffered_insn != null)
flushInsnBuffer();
buffered_insn = i;
}
// if the buffer is not empty, add the instruction to the code array
void flushInsnBuffer() throws jasError {
if(buffered_insn != null) {
_getCode().addInsn(buffered_insn);
buffered_insn = null;
}
}
//
// used by the .var directive
//
void addVar(String startLab, String endLab,
String name, String desc, String sign, int var_num)
throws jasError {
if (startLab == null) {
startLab = BGN_METHOD;
}
if (endLab == null) {
endLab = END_METHOD;
}
Label slab, elab;
slab = getLabel(startLab);
elab = getLabel(endLab);
if (var_table == null) {
var_table = new LocalVarTableAttr();
}
var_table.addEntry(new LocalVarEntry(slab, elab, name, desc, var_num));
if (sign != null) {
if (vtype_table == null) {
vtype_table = new LocalVarTypeTableAttr();
}
vtype_table.addEntry(new LocalVarEntry(slab, elab, name, sign, var_num));
}
}
void addVar(int startOffset, int endOffset, String name,
String desc, String sign, int var_num) throws jasError {
if (var_table == null) {
var_table = new LocalVarTableAttr();
}
var_table.addEntry(new LocalVarEntry(startOffset, endOffset,
name, desc, var_num));
if (sign != null) {
if (vtype_table == null) {
vtype_table = new LocalVarTypeTableAttr();
}
vtype_table.addEntry(new LocalVarEntry(startOffset, endOffset,
name, sign, var_num));
}
}
//
// used by .line directive
//
void addLineInfo(int line_num) throws jasError {
String l = "jasmin_reserved_L:" + (line_label_count++);
if (line_table == null) {
line_table = new LineTableAttr();
}
plantLabel(l);
line_table.addEntry(getLabel(l), line_num);
}
void addLine(int line_num) throws jasError {
if (!auto_number) {
addLineInfo(line_num);
}
}
//
// used by the .throws directive
//
void addThrow(String name) throws jasError {
// check that we are inside of a method definition
if (cur_method == null) {
throw new jasError( "illegal use of .throw outside of method definition");
}
if (except_attr == null) {
except_attr = new ExceptAttr();
}
except_attr.addException(new ClassCP(name));
}
//
// used by the .catch directive
//
void addCatch(String name, String start_lab, String end_lab,
String branch_lab) throws jasError {
ClassCP class_cp = checkCatch(name);
catch_table.addEntry(getLabel(start_lab), getLabel(end_lab),
getLabel(branch_lab), class_cp);
}
void addCatch(String name, int start_off, int end_off,
int branch_off) throws jasError {
ClassCP class_cp = checkCatch(name);
catch_table.addEntry(start_off, end_off, branch_off, class_cp);
}
short checkLimit(int v) throws jasError {
if(v < 0 || v > 65535)
throw new jasError("Illegal limit value", true);
return (short)v;
}
//
// used by the .limit stack directive
//
void setStackSize(int v) throws jasError {
_getCode().setStackSize(checkLimit(v));
}
//
// used by the .limit vars directive
//
void setVarSize(int v) throws jasError {
_getCode().setVarSize(checkLimit(v));
}
// --- Private stuff ---
//
// verifications made by both addCatch() methods
//
private ClassCP checkCatch(String name) throws jasError {
ClassCP class_cp;
// check that we are inside of a method definition
if (cur_method == null) {
throw new jasError( "illegal use of .catch outside of method definition");
}
if (catch_table == null) {
catch_table = new Catchtable();
}
if (name.equals("all")) {
class_cp = null;
} else {
class_cp = new ClassCP(name);
}
return class_cp;
}
//
// returns the code block, creating it if it doesn't exist
//
CodeAttr _getCode() throws jasError {
// check that we are inside of a method definition
if (cur_method == null) {
throw new jasError("illegal use of instruction outside of method definition");
}
if (code == null) {
code = new CodeAttr();
plantLabel(BGN_METHOD);
}
return (code);
}
// PUBLIC API TO JASMIN:
/** Makes a new ClassFile object, used to represent a Java class file.
* You can then use readJasmin to read in a class file stored in
* Jasmin assembly format.
*/
public ClassFile() {}
/**
* Parses a Jasmin file, converting it internally into a binary
* representation.
* If something goes wrong, this throws one of
* an IOException, or a jasError, or one of a few other exceptions.
* I'll tie this down more formally in the next version.
*
* @param input is the stream containing the Jasmin assembly code for the
* class.
*
* @param name is the name of the stream. This name will be
* concatenated to error messages printed to System.err.
*
* @param numberLines true if you want Jasmin to generate line
* numbers automatically, based on the assembly source, or
* false if you are using the ".line" directive and don't
* want Jasmin to help out.
*/
public void readJasmin(Reader input, String name,
boolean numberLines)
throws IOException, Exception {
// initialize variables for error reporting
errors = 0;
filename = name;
source_name = name;
//initialize local-frame variables
cur_method = null;
cur_field = null;
cur_annotation = null;
class_header = false;
// if numberLines is true, we output LineTableAttr's that indicate what line
// numbers the Jasmin code falls on.
auto_number = numberLines;
// Parse the input file
class_env = new ClassEnv();
scanner = new Scanner(input);
parser parse_obj = new parser(this, scanner);
if (PARSER_DEBUG) {
// for debugging
parse_obj.debug_parse();
} else {
parse_obj.parse();
}
}
/**
* Returns the number of warnings/errors encountered while parsing a file.
* 0 if everything went OK.
*/
public int errorCount() {
return errors;
}
/**
* Returns the name of the class in the file (i.e. the string given to
* the .class parameter in Jasmin)
*
*/
public String getClassName() {
return class_name;
}
/**
* Writes the binary data for the class represented by this ClassFile
* object to the specified
* output stream, using the Java Class File format. Throws either an
* IOException or a jasError if something goes wrong.
*/
public void write(OutputStream outp) throws IOException, jasError {
class_env.setSource(source_name);
class_env.write(new DataOutputStream(outp));
}
};
/* --- Revision History ---------------------------------------------------
--- Iouri Kharon, Aug 10 2006
Added 'Wide' prefix support to some instructions
--- Iouri Kharon, Feb 17 2006
Added extended syntax for .stack
--- Iouri Kharon, Dec 30 2005
Added multiline .field, directive .inner and .anotation
--- Iouri Kharon, Dec 20 2005
Added LocalVariableTypeTable support in addVar methods (called by .var)
--- Daniel Reynaud, Oct 22 2005
Added setSourceDebugExtension() method (called by .debug)
Added setEnclosingMethod() method (called by .enclosing)
--- Daniel Reynaud, Oct 19 2005
Added setVersion() method (called by .bytecode)
Changed BGN_METHOD, END_METHOD and line number label to avoid collision
--- Jonathan Meyer, April 11 1997
Fixed bug where source_name was not being set in class_env.
--- Jonathan Meyer, Mar 1 1997
Renamed "Jasmin" class "ClassFile".
--- Jonathan Meyer, Feb 8 1997
Converted to non-static. Made a public API. Split off InsnInfo to a
separate file.
--- Jonathan Meyer, Oct 1 1996
Added addInterface method, used by the .implements directive.
--- Jonathan Meyer, July 25 1996
Added setLine and line_num, to fix problem with autoNumber.
Added report_error method.
--- Jonathan Meyer, July 24 1996 added version constant.
*/
|