/* * The JastAdd Extensible Java Compiler (http://jastadd.org) is covered * by the modified BSD License. You should have received a copy of the * modified BSD license with this compiler. *  * Copyright (c) 2005-2008, Torbjorn Ekman * All rights reserved. */import java.io.*;aspect Attributes {       class Attribute {    int attribute_name_index;    ByteArrayOutputStream buf = new ByteArrayOutputStream();    DataOutputStream output = new DataOutputStream(buf);    public Attribute(ConstantPool cp, String name) {      attribute_name_index = cp.addUtf8(name);    }    public void emit(DataOutputStream out) throws IOException {      out.writeChar(attribute_name_index);      out.writeInt(buf.size());      buf.writeTo(out);      output.close();      buf.close();    }    public int size() { return buf.size(); }    public void u1(int v) { try { output.writeByte(v); } catch(IOException e) {} }    public void u2(int v) { try { output.writeChar(v); } catch(IOException e) {} }    public void u4(int v) { try { output.writeInt(v); } catch(IOException e) {} }    public void append(byte[] data) { try { output.write(data, 0, data.length); } catch(IOException e) {} }    public void append(Attribute attribute) { try { attribute.emit(output); } catch(IOException e) {} }  }  class SourceFileAttribute extends Attribute {    public SourceFileAttribute(ConstantPool p, String sourcefile) {      super(p, "SourceFile");      u2(p.addUtf8(sourcefile));    }  }  class SyntheticAttribute extends Attribute {    public SyntheticAttribute(ConstantPool p) {			super(p, "Synthetic");    }  }  class ConstantValueAttribute extends Attribute {    public ConstantValueAttribute(ConstantPool p, FieldDeclaration f) {      super(p, "ConstantValue");      int constantvalue_index = constantvalue_index = f.type().addConstant(p, f.getInit().constant());      u2(constantvalue_index);    }  }  public int TypeDecl.addConstant(ConstantPool p, Constant c)     {     if(isString()) return p.addConstant(c.stringValue());    throw new Error("Not supported");   }  public int BooleanType.addConstant(ConstantPool p, Constant c)  { return p.addConstant(c.booleanValue() ? 1 : 0); }   public int IntegralType.addConstant(ConstantPool p, Constant c) { return p.addConstant(c.intValue()); }  public int LongType.addConstant(ConstantPool p, Constant c)     { return p.addConstant(c.longValue()); }  public int FloatType.addConstant(ConstantPool p, Constant c)    { return p.addConstant(c.floatValue()); }  public int DoubleType.addConstant(ConstantPool p, Constant c)   { return p.addConstant(c.doubleValue()); }      class InnerClassesAttribute extends Attribute {    public InnerClassesAttribute(TypeDecl typeDecl) {      super(typeDecl.constantPool(), "InnerClasses");      ConstantPool c = typeDecl.constantPool();      Collection list = typeDecl.innerClassesAttributeEntries();      u2(list.size());      for(Iterator iter = list.iterator(); iter.hasNext(); ) {        TypeDecl type = (TypeDecl)iter.next();        u2(c.addClass(type.constantPoolName())); // inner_class_info_index        u2(type.isMemberType() ? c.addClass(type.enclosingType().constantPoolName()) : 0); // outer_class_info_index        u2(type.isAnonymous() ? 0 : c.addUtf8(type.name())); // inner_name_index        u2(type.isInterfaceDecl() ? (type.flags() | Modifiers.ACC_INTERFACE) : type.flags()); // inner_class_access_flags      }    }  }  syn lazy Collection TypeDecl.innerClassesAttributeEntries() {    HashSet list = new HashSet();    if(isNestedType())      list.add(this);    for(Iterator iter = nestedTypes().iterator(); iter.hasNext(); )      list.add(iter.next());    for(Iterator iter = usedNestedTypes().iterator(); iter.hasNext(); )      list.add(iter.next());    return list;  }  class LocalVariableTableAttribute extends Attribute {    public LocalVariableTableAttribute(CodeGeneration gen) {      super(gen.constantPool(), "LocalVariableTable");      u2(gen.localVariableTable.size());      for(Iterator iter = gen.localVariableTable.iterator(); iter.hasNext(); ) {        CodeGeneration.LocalVariableEntry e = (CodeGeneration.LocalVariableEntry)iter.next();        u2(e.start_pc);        u2(e.length);        u2(e.name_index);        u2(e.descriptor_index);        u2(e.index);      }    }  }  class LineNumberTableAttribute extends Attribute {    public LineNumberTableAttribute(CodeGeneration gen) {      super(gen.constantPool(), "LineNumberTable");      u2(gen.lineNumberTable.size());      for(Iterator iter = gen.lineNumberTable.iterator(); iter.hasNext(); ) {        CodeGeneration.LineNumberEntry e = (CodeGeneration.LineNumberEntry)iter.next();        u2(e.start_pc);        u2(e.line_number);      }    }  }      class CodeAttribute extends Attribute {    public CodeAttribute(CodeGeneration codeGen, MethodDecl m) {      super(codeGen.constantPool(), "Code");      u2(codeGen.maxStackDepth());      u2(codeGen.maxLocals());      u4(codeGen.pos()); // code_length      append(codeGen.toArray());      u2(codeGen.exceptions.size());      for(Iterator iter = codeGen.exceptions.iterator(); iter.hasNext(); ) {        CodeGeneration.ExceptionEntry e = (CodeGeneration.ExceptionEntry)iter.next();        u2(e.start_pc);        u2(e.end_pc);        u2(e.handler_pc);        u2(e.catch_type);      }      if(m == null || !m.getModifiers().isSynthetic()) {        u2(2); // Attribute count        append(new LineNumberTableAttribute(codeGen));        append(new LocalVariableTableAttribute(codeGen));      }      else {        u2(0); // Attribute count      }    }  }  interface ExceptionHolder {    public int getNumException();    public Access getException(int i);  }  MethodDecl implements ExceptionHolder;  ConstructorDecl implements ExceptionHolder;      class ExceptionsAttribute extends Attribute {    public ExceptionsAttribute(CodeGeneration gen, ExceptionHolder m) {      super(gen.constantPool(), "Exceptions");      u2(m.getNumException());      for(int i = 0; i < m.getNumException(); i++)        u2(gen.constantPool().addClass(m.getException(i).type().constantPoolName()));    }  }  syn lazy Collection TypeDecl.attributes() {    Collection c = new ArrayList();    if(!innerClassesAttributeEntries().isEmpty())      c.add(new InnerClassesAttribute(this));    if(isSynthetic())      c.add(new SyntheticAttribute(constantPool()));    if(compilationUnit().fromSource()) {      String relativeName = compilationUnit().relativeName();      if(relativeName != null) {        String splitToken = java.io.File.separator;        if(splitToken.equals("\\"))          splitToken = "\\\\";        String[] strings = relativeName.split(splitToken);        c.add(new SourceFileAttribute(constantPool(), strings[strings.length-1]));      }    }    return c;  }  syn lazy Collection BodyDecl.attributes() = new ArrayList();  eq FieldDeclaration.attributes() {    ArrayList l = new ArrayList();    if(isStatic() && isFinal() && isConstant() && (type().isPrimitive() || type().isString()))      l.add(new ConstantValueAttribute(hostType().constantPool(), this));    return l;  }  eq MethodDecl.attributes() {    ArrayList l = new ArrayList();    l.add(new ExceptionsAttribute(bytecodes(hostType().constantPool()), this));    if(isAbstract() || isNative()) return l;    l.add(new CodeAttribute(bytecodes(hostType().constantPool()), this));    if(getModifiers().isSynthetic())      l.add(new SyntheticAttribute(hostType().constantPool()));    return l;  }  eq ConstructorDecl.attributes() {    ArrayList l = new ArrayList();    l.add(new CodeAttribute(bytecodes(hostType().constantPool()), null));    l.add(new ExceptionsAttribute(bytecodes(hostType().constantPool()), this));    if(getModifiers().isSynthetic())      l.add(new SyntheticAttribute(hostType().constantPool()));    return l;  }  syn lazy Collection TypeDecl.clinit_attributes() {    ArrayList l = new ArrayList();    l.add(new CodeAttribute(bytecodes(constantPool()), null));    return l;  }}