scene-lib/src/annotations/io/JavapParser.java - platform/external/annotation-tools - Git at Google

 package annotations.io;

 /*>>>
 import org.checkerframework.checker.nullness.qual.*;
 */

 import java.io.*;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import annotations.Annotation;
 import annotations.AnnotationBuilder;
 import annotations.AnnotationFactory;
 import annotations.Annotations;
 import annotations.el.*;

 import com.sun.tools.javac.code.TargetType;
 import com.sun.tools.javac.code.TypeAnnotationPosition;

 import plume.FileIOException;

 /**
  * <code>JavapParser</code> provides a static method that parses a class dump
  * in the form produced by <code>xjavap -s -verbose -annotations</code> and adds
  * the annotations to an {@link AScene}, using the scene's
  * {@link AnnotationFactory} to build individual annotations.
  * If the scene's {@link AnnotationFactory} announces that it does not want an
  * annotation found in the javap output, that annotation is skipped. Annotations
  * from the javap output are merged into the scene; it is an error if both the
  * scene and the javap output contain annotations of the same type on the same
  * element.
  *
  * <p>
  * THIS CLASS IS NOT FINISHED YET!
  *
  * <p>
  * This class does not yet perform any error checking.  Expect strange
  * behavior and/or exceptions if you give it bad input.
  */
 public final class JavapParser {
     private static final String SECTION_TITLE_PREFIX = "  ";
     private static final String SECTION_DATA_PREFIX = "   ";
     private static final String CONST_POOL_DATA_PREFIX = "const #";

     private final AScene scene;

     private final BufferedReader bin;
     private String line; // null means end-of-file

     private int lineNo = 0; // TEMP

     private void nextLine() throws IOException {
         do {
             line = bin.readLine();
             lineNo++;
         } while (line != null && line.equals(""));
     }

     private void trim(String prefix) {
         if (line.startsWith(prefix)) {
             line = line.substring(prefix.length());
         }
     }

     private boolean inMember() {
         return line.startsWith(SECTION_TITLE_PREFIX);
     }

     private boolean inData() {
         return line.startsWith(SECTION_DATA_PREFIX) ||
             line.startsWith(CONST_POOL_DATA_PREFIX);
     }

     private enum TargetMode {
         ORIGINAL, PARAMETER, EXTENDED
     }

     // This name comes from the section of the javap output that is being read.
     private enum AnnotationSection {
         RVA("RuntimeVisibleAnnotations", RetentionPolicy.RUNTIME, TargetMode.ORIGINAL),
         RIA("RuntimeInvisibleAnnotations", RetentionPolicy.CLASS, TargetMode.ORIGINAL),
         RVPA("RuntimeVisibleParameterAnnotations", RetentionPolicy.RUNTIME, TargetMode.PARAMETER),
         RIPA("RuntimeInvisibleParameterAnnotations", RetentionPolicy.CLASS, TargetMode.PARAMETER),
         RVEA("RuntimeVisibleTypeAnnotations", RetentionPolicy.RUNTIME, TargetMode.EXTENDED),
         RIEA("RuntimeInvisibleTypeAnnotations", RetentionPolicy.CLASS, TargetMode.EXTENDED),
         ;

         final String secTitle;
         final RetentionPolicy retention;
         final TargetMode locMode;

         AnnotationSection(String secTitle, RetentionPolicy retention, TargetMode locMode) {
             this.secTitle = secTitle;
             this.retention = retention;
             this.locMode = locMode;
         }
     }

     private String parseAnnotationHead() throws IOException, ParseException {
         String annoTypeName = line.substring(
                 line.indexOf(annotationHead) + annotationHead.length(),
                 line.length() - 1).replace('/', '.');
         nextLine();
         return annoTypeName;
     }

     private static final String annotationHead = "//Annotation L"; // TEMP
     private static final String tagHead = "type = "; // TEMP

     private Annotation parseAnnotationBody(
             AnnotationBuilder ab,
             String indent) throws IOException, ParseException {
         // Grab the fields
         String fieldIndent = indent + " ";
         while (line.startsWith(fieldIndent)) {
             String line2 = line.substring(fieldIndent.length());
             // Let the caller deal with location information, if any
             if (line2.startsWith("target") || line2.startsWith("parameter")) {
                 break;
             }
             String fieldName =
                 line2.substring(line2.indexOf("//") + "//".length());
             nextLine();
             char tag = line.charAt(line.indexOf(tagHead) + tagHead.length());
             switch (tag) {
             case '[':
                 break;
             case '@':
                 break;
             case 'c':
                 break;
             case 'e':
                 break;
             }
             // FINISH
         }
         return ab.finish();
     }

     private static final String paramIdxHead = "parameter = ";
     private static final String offsetHead = "offset = ";
     private static final String typeIndexHead = "type_index = ";
     private static final Pattern localLocRegex =
         Pattern.compile("^\\s*start_pc = (\\d+), length = (\\d+), index = (\\d+)$");
     private static final String itlnHead = "location = ";

     private int parseOffset() throws IOException, ParseException {
         int offset = Integer.parseInt(
                 line.substring(line.indexOf(offsetHead) + offsetHead.length()));
         nextLine();
         return offset;
     }

     private int parseTypeIndex() throws IOException, ParseException {
         int typeIndex = Integer.parseInt(
                 line.substring(line.indexOf(typeIndexHead) + typeIndexHead.length()));
         nextLine();
         return typeIndex;
     }

     private List<Integer> parseInnerTypeLocationNums() throws IOException, ParseException {
         String numsStr
             = line.substring(line.indexOf(itlnHead) + itlnHead.length());
         List<Integer> nums = new ArrayList<Integer>();
         for (;;) {
             int comma = numsStr.indexOf(',');
             if (comma == -1) {
                 nums.add(Integer.parseInt(numsStr));
                 break;
             }
             nums.add(Integer.parseInt(numsStr.substring(0, comma)));
             numsStr = numsStr.substring(comma + 2);
         }
         nextLine();
         return nums;
     }

     private AElement chooseSubElement(AElement member, AnnotationSection sec) throws IOException, ParseException {
         switch (sec.locMode) {
         case ORIGINAL:
             // There can be no location information.
             return member;
         case PARAMETER:
         {
             // should have a "parameter = "
             int paramIdx = Integer.parseInt(
                     line.substring(
                     line.indexOf(paramIdxHead) + paramIdxHead.length()));
             nextLine();
             return ((AMethod) member).parameters.vivify(paramIdx);
         }
         case EXTENDED:
             // should have a "target = "
             String targetTypeName =
                 line.substring(line.indexOf("//") + "//".length());
             TargetType targetType;
             TargetType tt = TargetType.valueOf(targetTypeName);
             if (tt != null) {
                 targetType = tt;
             } else {
                 throw new RuntimeException("null target type");
             }
             nextLine();
             ATypeElement subOuterType;
             AElement subElement;
             switch (targetType) {
             case FIELD:
             case METHOD_RETURN:
                 subOuterType = (ATypeElement) member;
                 break;
             case METHOD_RECEIVER:
                 subOuterType = ((AMethod) member).receiver.type;
                 break;
             case METHOD_FORMAL_PARAMETER:
                 int paramIdx = Integer.parseInt(
                         line.substring(
                         line.indexOf(paramIdxHead) + paramIdxHead.length()));
                 nextLine();
                 subOuterType = ((AMethod) member).parameters.vivify(paramIdx).type;
                 break;
             case LOCAL_VARIABLE:
             case RESOURCE_VARIABLE:
                 int index, scopeStart, scopeLength;
                 Matcher m = localLocRegex.matcher(line);
                 m.matches();
                 index = Integer.parseInt(m.group(1));
                 scopeStart = Integer.parseInt(m.group(2));
                 scopeLength = Integer.parseInt(m.group(3));
                 LocalLocation ll =
                     new LocalLocation(index, scopeStart, scopeLength);
                 nextLine();
                 subOuterType = ((AMethod) member).body.locals.vivify(ll).type;
                 break;
             case CAST:
             {
                 int offset = parseOffset();
                 int typeIndex = parseTypeIndex();
                 subOuterType = ((AMethod) member).body.typecasts.vivify(RelativeLocation.createOffset(offset, typeIndex));
                 break;
             }
             case INSTANCEOF:
             {
                 int offset = parseOffset();
                 subOuterType = ((AMethod) member).body.instanceofs.vivify(RelativeLocation.createOffset(offset, 0));
                 break;
             }
             case NEW:
             {
                 int offset = parseOffset();
                 subOuterType = ((AMethod) member).body.news.vivify(RelativeLocation.createOffset(offset, 0));
                 break;
             }
             default:
                 throw new AssertionError();
             }
             // TODO: update location representation
             // if (targetType.) {
                 List<Integer> location = parseInnerTypeLocationNums();
                 InnerTypeLocation itl = new InnerTypeLocation(TypeAnnotationPosition.getTypePathFromBinary(location));
                 subElement = subOuterType.innerTypes.vivify(itl);
             // } else
             //    subElement = subOuterType;
             return subElement;
         default:
             throw new AssertionError();
         }
     }

     private void parseAnnotationSection(AElement member, AnnotationSection sec) throws IOException, ParseException {
         // FILL
         while (inData()) {
             String annoTypeName = parseAnnotationHead();
             RetentionPolicy retention = sec.retention;
             AnnotationBuilder ab = AnnotationFactory.saf.beginAnnotation(annoTypeName, Annotations.getRetentionPolicyMetaAnnotationSet(retention));
             if (ab == null) {
                 // don't care about the result
                 // but need to skip over it anyway
                 parseAnnotationBody(
                         AnnotationFactory.saf.beginAnnotation(annoTypeName, Annotations.noAnnotations),
                         SECTION_DATA_PREFIX);
             } else {
                 // Wrap it in a TLA with the appropriate retention policy
                 Annotation a = parseAnnotationBody(ab, SECTION_DATA_PREFIX);
                 // Now we need to parse the location information to determine
                 // which element gets the annotation.
                 AElement annoMember = chooseSubElement(member, sec);
                 annoMember.tlAnnotationsHere.add(a);
             }
         }
     }

     private void parseMember(AElement member) throws IOException, ParseException {
         while (inMember()) {
             // New section
             String secTitle =
                 line.substring(2, line.indexOf(':'));
             AnnotationSection sec0 = null;
             for (AnnotationSection s : AnnotationSection.values()) {
                 if (s.secTitle.equals(secTitle)) {
                     sec0 = s;
                 }
             }
             if (sec0 != null) {
                 AnnotationSection sec = sec0;
                 nextLine();
                 System.out.println("Got section " + secTitle);
                 parseAnnotationSection(member, sec);
             } else {
                 System.out.println("Got unrecognized section " + secTitle);
                 nextLine();
                 // Skip the section
                 while (inData()) {
                     nextLine();
                 }
             }
         }
     }

     private void parseMethodBody(AElement clazz, String methodName) throws IOException, ParseException {
         String sig = line.substring((SECTION_TITLE_PREFIX + "Signature: ").length());
         nextLine();
         String methodKey = methodName + sig;
         System.out.println("Got method " + methodKey); // TEMP
         parseMember(((AClass) clazz).methods.vivify(methodKey));
     }

     // the "clazz" might actually be a package in case of "interface package-info"
     private void parseClass(AElement clazz) throws IOException, ParseException {
         parseMember(clazz);

         nextLine(); // {

         while (!line.equals("}")) {
             // new member
             if (line.indexOf("static {}") >= 0) {
                 nextLine();
                 parseMethodBody(clazz, "<clinit>");
             } else {
                 int lparen = line.indexOf('(');
                 if (lparen == -1) {
                     // field
                     int space = line.lastIndexOf(' ');
                     String fieldName = line.substring(space + 1, line.length() - 1);
                     nextLine();
                     System.out.println("Got field " + fieldName); // TEMP
                     parseMember(((AClass) clazz).fields.vivify(fieldName));
                 } else {
                     // method
                     int space = line.lastIndexOf(' ', lparen);
                     String methodName = line.substring(space + 1, lparen);
                     nextLine();
                     parseMethodBody(clazz, methodName);
                 }
             }
         }
         nextLine(); // }
     }

     private void parse() throws IOException, ParseException {
         try { // TEMP
         nextLine(); // get the first line

         while (line != null) {
             // new class
             nextLine();
             trim("public ");
             trim("protected ");
             trim("private ");
             trim("abstract ");
             trim("final ");
             trim("class ");
             trim("interface ");
             int nameEnd = line.indexOf(' ');
             String className = (nameEnd == -1) ? line
                     : line.substring(0, line.indexOf(' '));
             String pp = annotations.io.IOUtils.packagePart(className), bp = annotations.io.IOUtils.basenamePart(className);
             nextLine();
             if (bp.equals("package-info")) {
                 parseClass(scene.packages.vivify(pp));
             } else {
                 parseClass(scene.classes.vivify(className));
             }
         }
         } catch (RuntimeException e) {
             throw new RuntimeException("Line " + lineNo, e);
         }
     }

     private JavapParser(Reader in, AScene scene) {
         bin = new BufferedReader(in);

         this.scene = scene;
     }

     /**
      * Transfers annotations from <code>in</code> to <code>scene</code>.
      */
     public static void parse(Reader in, AScene scene) throws IOException, ParseException {
         new JavapParser(in, scene).parse();
     }

     public static void parse(String filename, AScene scene) throws IOException, FileIOException {
         LineNumberReader lnr = new LineNumberReader(new FileReader(filename));
         try {
             parse(lnr, scene);
         } catch (ParseException e) {
             throw new FileIOException(lnr, filename, e);
         }
     }
 }
	package annotations.io;

	/*>>>
	import org.checkerframework.checker.nullness.qual.*;
	*/

	import java.io.*;
	import java.lang.annotation.RetentionPolicy;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import annotations.Annotation;
	import annotations.AnnotationBuilder;
	import annotations.AnnotationFactory;
	import annotations.Annotations;
	import annotations.el.*;

	import com.sun.tools.javac.code.TargetType;
	import com.sun.tools.javac.code.TypeAnnotationPosition;

	import plume.FileIOException;

	/**
	* <code>JavapParser</code> provides a static method that parses a class dump
	* in the form produced by <code>xjavap -s -verbose -annotations</code> and adds
	* the annotations to an {@link AScene}, using the scene's
	* {@link AnnotationFactory} to build individual annotations.
	* If the scene's {@link AnnotationFactory} announces that it does not want an
	* annotation found in the javap output, that annotation is skipped. Annotations
	* from the javap output are merged into the scene; it is an error if both the
	* scene and the javap output contain annotations of the same type on the same
	* element.
	*
	* <p>
	* THIS CLASS IS NOT FINISHED YET!
	*
	* <p>
	* This class does not yet perform any error checking. Expect strange
	* behavior and/or exceptions if you give it bad input.
	*/
	public final class JavapParser {
	private static final String SECTION_TITLE_PREFIX = " ";
	private static final String SECTION_DATA_PREFIX = " ";
	private static final String CONST_POOL_DATA_PREFIX = "const #";

	private final AScene scene;

	private final BufferedReader bin;
	private String line; // null means end-of-file

	private int lineNo = 0; // TEMP

	private void nextLine() throws IOException {
	do {
	line = bin.readLine();
	lineNo++;
	} while (line != null && line.equals(""));
	}

	private void trim(String prefix) {
	if (line.startsWith(prefix)) {
	line = line.substring(prefix.length());
	}
	}

	private boolean inMember() {
	return line.startsWith(SECTION_TITLE_PREFIX);
	}

	private boolean inData() {
	return line.startsWith(SECTION_DATA_PREFIX) \|\|
	line.startsWith(CONST_POOL_DATA_PREFIX);
	}

	private enum TargetMode {
	ORIGINAL, PARAMETER, EXTENDED
	}

	// This name comes from the section of the javap output that is being read.
	private enum AnnotationSection {
	RVA("RuntimeVisibleAnnotations", RetentionPolicy.RUNTIME, TargetMode.ORIGINAL),
	RIA("RuntimeInvisibleAnnotations", RetentionPolicy.CLASS, TargetMode.ORIGINAL),
	RVPA("RuntimeVisibleParameterAnnotations", RetentionPolicy.RUNTIME, TargetMode.PARAMETER),
	RIPA("RuntimeInvisibleParameterAnnotations", RetentionPolicy.CLASS, TargetMode.PARAMETER),
	RVEA("RuntimeVisibleTypeAnnotations", RetentionPolicy.RUNTIME, TargetMode.EXTENDED),
	RIEA("RuntimeInvisibleTypeAnnotations", RetentionPolicy.CLASS, TargetMode.EXTENDED),
	;

	final String secTitle;
	final RetentionPolicy retention;
	final TargetMode locMode;

	AnnotationSection(String secTitle, RetentionPolicy retention, TargetMode locMode) {
	this.secTitle = secTitle;
	this.retention = retention;
	this.locMode = locMode;
	}
	}

	private String parseAnnotationHead() throws IOException, ParseException {
	String annoTypeName = line.substring(
	line.indexOf(annotationHead) + annotationHead.length(),
	line.length() - 1).replace('/', '.');
	nextLine();
	return annoTypeName;
	}

	private static final String annotationHead = "//Annotation L"; // TEMP
	private static final String tagHead = "type = "; // TEMP

	private Annotation parseAnnotationBody(
	AnnotationBuilder ab,
	String indent) throws IOException, ParseException {
	// Grab the fields
	String fieldIndent = indent + " ";
	while (line.startsWith(fieldIndent)) {
	String line2 = line.substring(fieldIndent.length());
	// Let the caller deal with location information, if any
	if (line2.startsWith("target") \|\| line2.startsWith("parameter")) {
	break;
	}
	String fieldName =
	line2.substring(line2.indexOf("//") + "//".length());
	nextLine();
	char tag = line.charAt(line.indexOf(tagHead) + tagHead.length());
	switch (tag) {
	case '[':
	break;
	case '@':
	break;
	case 'c':
	break;
	case 'e':
	break;
	}
	// FINISH
	}
	return ab.finish();
	}

	private static final String paramIdxHead = "parameter = ";
	private static final String offsetHead = "offset = ";
	private static final String typeIndexHead = "type_index = ";
	private static final Pattern localLocRegex =
	Pattern.compile("^\\s*start_pc = (\\d+), length = (\\d+), index = (\\d+)$");
	private static final String itlnHead = "location = ";

	private int parseOffset() throws IOException, ParseException {
	int offset = Integer.parseInt(
	line.substring(line.indexOf(offsetHead) + offsetHead.length()));
	nextLine();
	return offset;
	}

	private int parseTypeIndex() throws IOException, ParseException {
	int typeIndex = Integer.parseInt(
	line.substring(line.indexOf(typeIndexHead) + typeIndexHead.length()));
	nextLine();
	return typeIndex;
	}

	private List<Integer> parseInnerTypeLocationNums() throws IOException, ParseException {
	String numsStr
	= line.substring(line.indexOf(itlnHead) + itlnHead.length());
	List<Integer> nums = new ArrayList<Integer>();
	for (;;) {
	int comma = numsStr.indexOf(',');
	if (comma == -1) {
	nums.add(Integer.parseInt(numsStr));
	break;
	}
	nums.add(Integer.parseInt(numsStr.substring(0, comma)));
	numsStr = numsStr.substring(comma + 2);
	}
	nextLine();
	return nums;
	}

	private AElement chooseSubElement(AElement member, AnnotationSection sec) throws IOException, ParseException {
	switch (sec.locMode) {
	case ORIGINAL:
	// There can be no location information.
	return member;
	case PARAMETER:
	{
	// should have a "parameter = "
	int paramIdx = Integer.parseInt(
	line.substring(
	line.indexOf(paramIdxHead) + paramIdxHead.length()));
	nextLine();
	return ((AMethod) member).parameters.vivify(paramIdx);
	}
	case EXTENDED:
	// should have a "target = "
	String targetTypeName =
	line.substring(line.indexOf("//") + "//".length());
	TargetType targetType;
	TargetType tt = TargetType.valueOf(targetTypeName);
	if (tt != null) {
	targetType = tt;
	} else {
	throw new RuntimeException("null target type");
	}
	nextLine();
	ATypeElement subOuterType;
	AElement subElement;
	switch (targetType) {
	case FIELD:
	case METHOD_RETURN:
	subOuterType = (ATypeElement) member;
	break;
	case METHOD_RECEIVER:
	subOuterType = ((AMethod) member).receiver.type;
	break;
	case METHOD_FORMAL_PARAMETER:
	int paramIdx = Integer.parseInt(
	line.substring(
	line.indexOf(paramIdxHead) + paramIdxHead.length()));
	nextLine();
	subOuterType = ((AMethod) member).parameters.vivify(paramIdx).type;
	break;
	case LOCAL_VARIABLE:
	case RESOURCE_VARIABLE:
	int index, scopeStart, scopeLength;
	Matcher m = localLocRegex.matcher(line);
	m.matches();
	index = Integer.parseInt(m.group(1));
	scopeStart = Integer.parseInt(m.group(2));
	scopeLength = Integer.parseInt(m.group(3));
	LocalLocation ll =
	new LocalLocation(index, scopeStart, scopeLength);
	nextLine();
	subOuterType = ((AMethod) member).body.locals.vivify(ll).type;
	break;
	case CAST:
	{
	int offset = parseOffset();
	int typeIndex = parseTypeIndex();
	subOuterType = ((AMethod) member).body.typecasts.vivify(RelativeLocation.createOffset(offset, typeIndex));
	break;
	}
	case INSTANCEOF:
	{
	int offset = parseOffset();
	subOuterType = ((AMethod) member).body.instanceofs.vivify(RelativeLocation.createOffset(offset, 0));
	break;
	}
	case NEW:
	{
	int offset = parseOffset();
	subOuterType = ((AMethod) member).body.news.vivify(RelativeLocation.createOffset(offset, 0));
	break;
	}
	default:
	throw new AssertionError();
	}
	// TODO: update location representation
	// if (targetType.) {
	List<Integer> location = parseInnerTypeLocationNums();
	InnerTypeLocation itl = new InnerTypeLocation(TypeAnnotationPosition.getTypePathFromBinary(location));
	subElement = subOuterType.innerTypes.vivify(itl);
	// } else
	// subElement = subOuterType;
	return subElement;
	default:
	throw new AssertionError();
	}
	}

	private void parseAnnotationSection(AElement member, AnnotationSection sec) throws IOException, ParseException {
	// FILL
	while (inData()) {
	String annoTypeName = parseAnnotationHead();
	RetentionPolicy retention = sec.retention;
	AnnotationBuilder ab = AnnotationFactory.saf.beginAnnotation(annoTypeName, Annotations.getRetentionPolicyMetaAnnotationSet(retention));
	if (ab == null) {
	// don't care about the result
	// but need to skip over it anyway
	parseAnnotationBody(
	AnnotationFactory.saf.beginAnnotation(annoTypeName, Annotations.noAnnotations),
	SECTION_DATA_PREFIX);
	} else {
	// Wrap it in a TLA with the appropriate retention policy
	Annotation a = parseAnnotationBody(ab, SECTION_DATA_PREFIX);
	// Now we need to parse the location information to determine
	// which element gets the annotation.
	AElement annoMember = chooseSubElement(member, sec);
	annoMember.tlAnnotationsHere.add(a);
	}
	}
	}

	private void parseMember(AElement member) throws IOException, ParseException {
	while (inMember()) {
	// New section
	String secTitle =
	line.substring(2, line.indexOf(':'));
	AnnotationSection sec0 = null;
	for (AnnotationSection s : AnnotationSection.values()) {
	if (s.secTitle.equals(secTitle)) {
	sec0 = s;
	}
	}
	if (sec0 != null) {
	AnnotationSection sec = sec0;
	nextLine();
	System.out.println("Got section " + secTitle);
	parseAnnotationSection(member, sec);
	} else {
	System.out.println("Got unrecognized section " + secTitle);
	nextLine();
	// Skip the section
	while (inData()) {
	nextLine();
	}
	}
	}
	}

	private void parseMethodBody(AElement clazz, String methodName) throws IOException, ParseException {
	String sig = line.substring((SECTION_TITLE_PREFIX + "Signature: ").length());
	nextLine();
	String methodKey = methodName + sig;
	System.out.println("Got method " + methodKey); // TEMP
	parseMember(((AClass) clazz).methods.vivify(methodKey));
	}

	// the "clazz" might actually be a package in case of "interface package-info"
	private void parseClass(AElement clazz) throws IOException, ParseException {
	parseMember(clazz);

	nextLine(); // {

	while (!line.equals("}")) {
	// new member
	if (line.indexOf("static {}") >= 0) {
	nextLine();
	parseMethodBody(clazz, "<clinit>");
	} else {
	int lparen = line.indexOf('(');
	if (lparen == -1) {
	// field
	int space = line.lastIndexOf(' ');
	String fieldName = line.substring(space + 1, line.length() - 1);
	nextLine();
	System.out.println("Got field " + fieldName); // TEMP
	parseMember(((AClass) clazz).fields.vivify(fieldName));
	} else {
	// method
	int space = line.lastIndexOf(' ', lparen);
	String methodName = line.substring(space + 1, lparen);
	nextLine();
	parseMethodBody(clazz, methodName);
	}
	}
	}
	nextLine(); // }
	}

	private void parse() throws IOException, ParseException {
	try { // TEMP
	nextLine(); // get the first line

	while (line != null) {
	// new class
	nextLine();
	trim("public ");
	trim("protected ");
	trim("private ");
	trim("abstract ");
	trim("final ");
	trim("class ");
	trim("interface ");
	int nameEnd = line.indexOf(' ');
	String className = (nameEnd == -1) ? line
	: line.substring(0, line.indexOf(' '));
	String pp = annotations.io.IOUtils.packagePart(className), bp = annotations.io.IOUtils.basenamePart(className);
	nextLine();
	if (bp.equals("package-info")) {
	parseClass(scene.packages.vivify(pp));
	} else {
	parseClass(scene.classes.vivify(className));
	}
	}
	} catch (RuntimeException e) {
	throw new RuntimeException("Line " + lineNo, e);
	}
	}

	private JavapParser(Reader in, AScene scene) {
	bin = new BufferedReader(in);

	this.scene = scene;
	}

	/**
	* Transfers annotations from <code>in</code> to <code>scene</code>.
	*/
	public static void parse(Reader in, AScene scene) throws IOException, ParseException {
	new JavapParser(in, scene).parse();
	}

	public static void parse(String filename, AScene scene) throws IOException, FileIOException {
	LineNumberReader lnr = new LineNumberReader(new FileReader(filename));
	try {
	parse(lnr, scene);
	} catch (ParseException e) {
	throw new FileIOException(lnr, filename, e);
	}
	}
	}