1 /*

     2  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package xmlkit; // -*- mode: java; indent-tabs-mode: nil -*-

    26 

    27 import java.util.*;

    28 import java.lang.reflect.*;

    29 import java.io.*;

    30 import xmlkit.XMLKit.Element;

    31 /*

    32  * @author jrose

    33  */

    34 public class ClassWriter extends ClassSyntax implements ClassSyntax.GetCPIndex {

    35 

    36     private static final CommandLineParser CLP = new CommandLineParser(""

    37             + "-source:     +>  = \n"

    38             + "-dest:       +>  = \n"

    39             + "-encoding:   +>  = \n"

    40             + "-parseBytes      $ \n"

    41             + "-               *? \n"

    42             + "\n");

    43 

    44     public static void main(String[] ava) throws IOException {

    45         ArrayList<String> av = new ArrayList<String>(Arrays.asList(ava));

    46         HashMap<String, String> props = new HashMap<String, String>();

    47         props.put("-encoding:", "UTF8");  // default

    48         CLP.parse(av, props);

    49         File source = asFile(props.get("-source:"));

    50         File dest = asFile(props.get("-dest:"));

    51         String encoding = props.get("-encoding:");

    52         boolean parseBytes = props.containsKey("-parseBytes");

    53         boolean destMade = false;

    54 

    55         for (String a : av) {

    56             File f;

    57             File inf = new File(source, a);

    58             System.out.println("Reading " + inf);

    59             Element e;

    60             if (inf.getName().endsWith(".class")) {

    61                 ClassReader cr = new ClassReader();

    62                 cr.parseBytes = parseBytes;

    63                 e = cr.readFrom(inf);

    64                 f = new File(a);

    65             } else if (inf.getName().endsWith(".xml")) {

    66                 InputStream in = new FileInputStream(inf);

    67                 Reader inw = ClassReader.makeReader(in, encoding);

    68                 e = XMLKit.readFrom(inw);

    69                 e.findAllInTree(XMLKit.and(XMLKit.elementFilter(nonAttrTags()),

    70                         XMLKit.methodFilter(Element.method("trimText"))));

    71                 //System.out.println(e);

    72                 inw.close();

    73                 f = new File(a.substring(0, a.length() - ".xml".length()) + ".class");

    74             } else {

    75                 System.out.println("Warning: unknown input " + a);

    76                 continue;

    77             }

    78             // Now write it:

    79             if (!destMade) {

    80                 destMade = true;

    81                 if (dest == null) {

    82                     dest = File.createTempFile("TestOut", ".dir", new File("."));

    83                     dest.delete();

    84                     System.out.println("Writing results to " + dest);

    85                 }

    86                 if (!(dest.isDirectory() || dest.mkdir())) {

    87                     throw new RuntimeException("Cannot create " + dest);

    88                 }

    89             }

    90             File outf = new File(dest, f.isAbsolute() ? f.getName() : f.getPath());

    91             outf.getParentFile().mkdirs();

    92             new ClassWriter(e).writeTo(outf);

    93         }

    94     }

    95 

    96     private static File asFile(String str) {

    97         return (str == null) ? null : new File(str);

    98     }

    99 

   100     public void writeTo(File file) throws IOException {

   101         OutputStream out = null;

   102         try {

   103             out = new BufferedOutputStream(new FileOutputStream(file));

   104             writeTo(out);

   105         } finally {

   106             if (out != null) {

   107                 out.close();

   108             }

   109         }

   110     }

   111     protected String[] callables;     // varies

   112     protected int cpoolSize = 0;

   113     protected HashMap<String, String> attrTypesByTag;

   114     protected OutputStream out;

   115     protected HashMap<String, int[]> cpMap = new HashMap<String, int[]>();

   116     protected ArrayList<ByteArrayOutputStream> attrBufs = new ArrayList<ByteArrayOutputStream>();

   117 

   118     private void setupAttrTypes() {

   119         attrTypesByTag = new HashMap<String, String>();

   120         for (String key : attrTypes.keySet()) {

   121             String pfx = key.substring(0, key.indexOf('.') + 1);

   122             String val = attrTypes.get(key);

   123             int pos = val.indexOf('<');

   124             if (pos >= 0) {

   125                 String tag = val.substring(pos + 1, val.indexOf('>', pos));

   126                 attrTypesByTag.put(pfx + tag, key);

   127             }

   128         }

   129         //System.out.println("attrTypesByTag: "+attrTypesByTag);

   130     }

   131 

   132     protected ByteArrayOutputStream getAttrBuf() {

   133         int nab = attrBufs.size();

   134         if (nab == 0) {

   135             return new ByteArrayOutputStream(1024);

   136         }

   137         ByteArrayOutputStream ab = attrBufs.get(nab - 1);

   138         attrBufs.remove(nab - 1);

   139         return ab;

   140     }

   141 

   142     protected void putAttrBuf(ByteArrayOutputStream ab) {

   143         ab.reset();

   144         attrBufs.add(ab);

   145     }

   146 

   147     public ClassWriter(Element root) {

   148         this(root, null);

   149     }

   150 

   151     public ClassWriter(Element root, ClassSyntax cr) {

   152         if (cr != null) {

   153             attrTypes = cr.attrTypes;

   154         }

   155         setupAttrTypes();

   156         if (root.getName() == "ClassFile") {

   157             cfile = root;

   158             cpool = root.findElement("ConstantPool");

   159             klass = root.findElement("Class");

   160         } else if (root.getName() == "Class") {

   161             cfile = new Element("ClassFile",

   162                     new String[]{

   163                         "magic", String.valueOf(0xCAFEBABE),

   164                         "minver", "0", "majver", "46",});

   165             cpool = new Element("ConstantPool");

   166             klass = root;

   167         } else {

   168             throw new IllegalArgumentException("bad element type " + root.getName());

   169         }

   170         if (cpool == null) {

   171             cpool = new Element("ConstantPool");

   172         }

   173 

   174         int cpLen = 1 + cpool.size();

   175         for (Element c : cpool.elements()) {

   176             int id = (int) c.getAttrLong("id");

   177             int tag = cpTagValue(c.getName());

   178             setCPIndex(tag, c.getText().toString(), id);

   179             switch (tag) {

   180                 case CONSTANT_Long:

   181                 case CONSTANT_Double:

   182                     cpLen += 1;

   183             }

   184         }

   185         cpoolSize = cpLen;

   186     }

   187 

   188     public int findCPIndex(int tag, String name) {

   189         if (name == null) {

   190             return 0;

   191         }

   192         int[] ids = cpMap.get(name.toString());

   193         return (ids == null) ? 0 : ids[tag];

   194     }

   195 

   196     public int getCPIndex(int tag, String name) {

   197         //System.out.println("getCPIndex "+cpTagName(tag)+" "+name);

   198         if (name == null) {

   199             return 0;

   200         }

   201         int id = findCPIndex(tag, name);

   202         if (id == 0) {

   203             id = cpoolSize;

   204             cpoolSize += 1;

   205             setCPIndex(tag, name, id);

   206             cpool.add(new Element(cpTagName(tag),

   207                     new String[]{"id", "" + id},

   208                     new Object[]{name}));

   209             int pos;

   210             switch (tag) {

   211                 case CONSTANT_Long:

   212                 case CONSTANT_Double:

   213                     cpoolSize += 1;

   214                     break;

   215                 case CONSTANT_Class:

   216                 case CONSTANT_String:

   217                     getCPIndex(CONSTANT_Utf8, name);

   218                     break;

   219                 case CONSTANT_Fieldref:

   220                 case CONSTANT_Methodref:

   221                 case CONSTANT_InterfaceMethodref:

   222                     pos = name.indexOf(' ');

   223                     getCPIndex(CONSTANT_Class, name.substring(0, pos));

   224                     getCPIndex(CONSTANT_NameAndType, name.substring(pos + 1));

   225                     break;

   226                 case CONSTANT_NameAndType:

   227                     pos = name.indexOf(' ');

   228                     getCPIndex(CONSTANT_Utf8, name.substring(0, pos));

   229                     getCPIndex(CONSTANT_Utf8, name.substring(pos + 1));

   230                     break;

   231             }

   232         }

   233         return id;

   234     }

   235 

   236     public void setCPIndex(int tag, String name, int id) {

   237         //System.out.println("setCPIndex id="+id+" tag="+tag+" name="+name);

   238         int[] ids = cpMap.get(name);

   239         if (ids == null) {

   240             cpMap.put(name, ids = new int[13]);

   241         }

   242         if (ids[tag] != 0 && ids[tag] != id) {

   243             System.out.println("Warning: Duplicate CP entries for " + ids[tag] + " and " + id);

   244         }

   245         //assert(ids[tag] == 0 || ids[tag] == id);

   246         ids[tag] = id;

   247     }

   248 

   249     public int parseFlags(String flagString) {

   250         int flags = 0;

   251         int i = -1;

   252         for (String[] names : modifierNames) {

   253             ++i;

   254             for (String name : names) {

   255                 if (name == null) {

   256                     continue;

   257                 }

   258                 int pos = flagString.indexOf(name);

   259                 if (pos >= 0) {

   260                     flags |= (1 << i);

   261                 }

   262             }

   263         }

   264         return flags;

   265     }

   266 

   267     public void writeTo(OutputStream realOut) throws IOException {

   268         OutputStream headOut = realOut;

   269         ByteArrayOutputStream tailOut = new ByteArrayOutputStream();

   270 

   271         // write the body of the class file first

   272         this.out = tailOut;

   273         writeClass();

   274 

   275         // write the file header last

   276         this.out = headOut;

   277         u4((int) cfile.getAttrLong("magic"));

   278         u2((int) cfile.getAttrLong("minver"));

   279         u2((int) cfile.getAttrLong("majver"));

   280         writeCP();

   281 

   282         // recopy the file tail

   283         this.out = null;

   284         tailOut.writeTo(realOut);

   285     }

   286 

   287     void writeClass() throws IOException {

   288         int flags = parseFlags(klass.getAttr("flags"));

   289         flags ^= Modifier.SYNCHRONIZED;

   290         u2(flags);

   291         cpRef(CONSTANT_Class, klass.getAttr("name"));

   292         cpRef(CONSTANT_Class, klass.getAttr("super"));

   293         Element interfaces = klass.findAllElements("Interface");

   294         u2(interfaces.size());

   295         for (Element e : interfaces.elements()) {

   296             cpRef(CONSTANT_Class, e.getAttr("name"));

   297         }

   298         for (int isMethod = 0; isMethod <= 1; isMethod++) {

   299             Element members = klass.findAllElements(isMethod != 0 ? "Method" : "Field");

   300             u2(members.size());

   301             for (Element m : members.elements()) {

   302                 writeMember(m, isMethod != 0);

   303             }

   304         }

   305         writeAttributesFor(klass);

   306     }

   307 

   308     private void writeMember(Element member, boolean isMethod) throws IOException {

   309         //System.out.println("writeMember "+member);

   310         u2(parseFlags(member.getAttr("flags")));

   311         cpRef(CONSTANT_Utf8, member.getAttr("name"));

   312         cpRef(CONSTANT_Utf8, member.getAttr("type"));

   313         writeAttributesFor(member);

   314     }

   315 

   316     protected void writeAttributesFor(Element x) throws IOException {

   317         LinkedHashSet<String> attrNames = new LinkedHashSet<String>();

   318         for (Element e : x.elements()) {

   319             attrNames.add(e.getName());  // uniquifying

   320         }

   321         attrNames.removeAll(nonAttrTags());

   322         u2(attrNames.size());

   323         if (attrNames.isEmpty()) {

   324             return;

   325         }

   326         Element prevCurrent;

   327         if (x.getName() == "Code") {

   328             prevCurrent = currentCode;

   329             currentCode = x;

   330         } else {

   331             prevCurrent = currentMember;

   332             currentMember = x;

   333         }

   334         OutputStream realOut = this.out;

   335         for (String utag : attrNames) {

   336             String qtag = x.getName() + "." + utag;

   337             String wtag = "*." + utag;

   338             String key = attrTypesByTag.get(qtag);

   339             if (key == null) {

   340                 key = attrTypesByTag.get(wtag);

   341             }

   342             String type = attrTypes.get(key);

   343             //System.out.println("tag "+qtag+" => key "+key+"; type "+type);

   344             Element attrs = x.findAllElements(utag);

   345             ByteArrayOutputStream attrBuf = getAttrBuf();

   346             if (type == null) {

   347                 if (attrs.size() != 1 || !attrs.get(0).equals(new Element(utag))) {

   348                     System.out.println("Warning:  No attribute type description: " + qtag);

   349                 }

   350                 key = wtag;

   351             } else {

   352                 try {

   353                     this.out = attrBuf;

   354                     // unparse according to type desc.

   355                     if (type.equals("<Code>...")) {

   356                         writeCode((Element) attrs.get(0));  // assume only 1

   357                     } else if (type.equals("<Frame>...")) {

   358                         writeStackMap(attrs, false);

   359                     } else if (type.equals("<FrameX>...")) {

   360                         writeStackMap(attrs, true);

   361                     } else if (type.startsWith("[")) {

   362                         writeAttributeRecursive(attrs, type);

   363                     } else {

   364                         writeAttribute(attrs, type);

   365                     }

   366                 } finally {

   367                     //System.out.println("Attr Bytes = \""+attrBuf.toString(EIGHT_BIT_CHAR_ENCODING).replace('"', (char)('"'|0x80))+"\"");

   368                     this.out = realOut;

   369                 }

   370             }

   371             cpRef(CONSTANT_Utf8, key.substring(key.indexOf('.') + 1));

   372             u4(attrBuf.size());

   373             attrBuf.writeTo(out);

   374             putAttrBuf(attrBuf);

   375         }

   376         if (x.getName() == "Code") {

   377             currentCode = prevCurrent;

   378         } else {

   379             currentMember = prevCurrent;

   380         }

   381     }

   382 

   383     private void writeAttributeRecursive(Element aval, String type) throws IOException {

   384         assert (callables == null);

   385         callables = getBodies(type);

   386         writeAttribute(aval, callables[0]);

   387         callables = null;

   388     }

   389 

   390     private void writeAttribute(Element aval, String type) throws IOException {

   391         //System.out.println("writeAttribute "+aval+"  using "+type);

   392         String nextAttrName = null;

   393         boolean afterElemHead = false;

   394         for (int len = type.length(), next, i = 0; i < len; i = next) {

   395             int value;

   396             char intKind;

   397             int tag;

   398             int sigChar;

   399             String attrValue;

   400             switch (type.charAt(i)) {

   401                 case '<':

   402                     assert (nextAttrName == null);

   403                     next = type.indexOf('>', i);

   404                     String form = type.substring(i + 1, next++);

   405                     if (form.indexOf('=') < 0) {

   406                         //  elem_placement = '<' elemname '>'

   407                         if (aval.isAnonymous()) {

   408                             assert (aval.size() == 1);

   409                             aval = (Element) aval.get(0);

   410                         }

   411                         assert (aval.getName().equals(form)) : aval + " // " + form;

   412                         afterElemHead = true;

   413                     } else {

   414                         //  attr_placement = '(' attrname '=' (value)? ')'

   415                         int eqPos = form.indexOf('=');

   416                         assert (eqPos >= 0);

   417                         nextAttrName = form.substring(0, eqPos).intern();

   418                         if (eqPos != form.length() - 1) {

   419                             // value is implicit, not placed in file

   420                             nextAttrName = null;

   421                         }

   422                         afterElemHead = false;

   423                     }

   424                     continue;

   425                 case '(':

   426                     next = type.indexOf(')', ++i);

   427                     int callee = Integer.parseInt(type.substring(i, next++));

   428                     writeAttribute(aval, callables[callee]);

   429                     continue;

   430                 case 'N': // replication = 'N' int '[' type ... ']'

   431                 {

   432                     assert (nextAttrName == null);

   433                     afterElemHead = false;

   434                     char countType = type.charAt(i + 1);

   435                     next = i + 2;

   436                     String type1 = getBody(type, next);

   437                     Element elems = aval;

   438                     if (type1.startsWith("<")) {

   439                         // Select only matching members of aval.

   440                         String elemName = type1.substring(1, type1.indexOf('>'));

   441                         elems = aval.findAllElements(elemName);

   442                     }

   443                     putInt(elems.size(), countType);

   444                     next += type1.length() + 2;  // skip body and brackets

   445                     for (Element elem : elems.elements()) {

   446                         writeAttribute(elem, type1);

   447                     }

   448                 }

   449                 continue;

   450                 case 'T': // union = 'T' any_int union_case* '(' ')' '[' body ']'

   451                     // write the value

   452                     value = (int) aval.getAttrLong("tag");

   453                     assert (aval.getAttr("tag") != null) : aval;

   454                     intKind = type.charAt(++i);

   455                     if (intKind == 'S') {

   456                         intKind = type.charAt(++i);

   457                     }

   458                     putInt(value, intKind);

   459                     nextAttrName = null;

   460                     afterElemHead = false;

   461                     ++i;  // skip the int type char

   462                     // union_case = '(' ('-')? digit+ ')' '[' body ']'

   463                     for (boolean foundCase = false;;) {

   464                         assert (type.charAt(i) == '(');

   465                         next = type.indexOf(')', ++i);

   466                         assert (next >= i);

   467                         String caseStr = type.substring(i, next++);

   468                         String type1 = getBody(type, next);

   469                         next += type1.length() + 2;  // skip body and brackets

   470                         boolean lastCase = (caseStr.length() == 0);

   471                         if (!foundCase

   472                                 && (lastCase || matchTag(value, caseStr))) {

   473                             foundCase = true;

   474                             // Execute this body.

   475                             writeAttribute(aval, type1);

   476                         }

   477                         if (lastCase) {

   478                             break;

   479                         }

   480                     }

   481                     continue;

   482                 case 'B':

   483                 case 'H':

   484                 case 'I': // int = oneof "BHI"

   485                     value = (int) aval.getAttrLong(nextAttrName);

   486                     intKind = type.charAt(i);

   487                     next = i + 1;

   488                     break;

   489                 case 'K':

   490                     sigChar = type.charAt(i + 1);

   491                     if (sigChar == 'Q') {

   492                         assert (currentMember.getName() == "Field");

   493                         assert (aval.getName() == "ConstantValue");

   494                         String sig = currentMember.getAttr("type");

   495                         sigChar = sig.charAt(0);

   496                         switch (sigChar) {

   497                             case 'Z':

   498                             case 'B':

   499                             case 'C':

   500                             case 'S':

   501                                 sigChar = 'I';

   502                                 break;

   503                         }

   504                     }

   505                     switch (sigChar) {

   506                         case 'I':

   507                             tag = CONSTANT_Integer;

   508                             break;

   509                         case 'J':

   510                             tag = CONSTANT_Long;

   511                             break;

   512                         case 'F':

   513                             tag = CONSTANT_Float;

   514                             break;

   515                         case 'D':

   516                             tag = CONSTANT_Double;

   517                             break;

   518                         case 'L':

   519                             tag = CONSTANT_String;

   520                             break;

   521                         default:

   522                             assert (false);

   523                             tag = 0;

   524                     }

   525                     assert (type.charAt(i + 2) == 'H');  // only H works for now

   526                     next = i + 3;

   527                     assert (afterElemHead || nextAttrName != null);

   528                     //System.out.println("get attr "+nextAttrName+" in "+aval);

   529                     if (nextAttrName != null) {

   530                         attrValue = aval.getAttr(nextAttrName);

   531                         assert (attrValue != null);

   532                     } else {

   533                         assert (aval.isText()) : aval;

   534                         attrValue = aval.getText().toString();

   535                     }

   536                     value = getCPIndex(tag, attrValue);

   537                     intKind = 'H'; //type.charAt(i+2);

   538                     break;

   539                 case 'R':

   540                     sigChar = type.charAt(i + 1);

   541                     switch (sigChar) {

   542                         case 'C':

   543                             tag = CONSTANT_Class;

   544                             break;

   545                         case 'S':

   546                             tag = CONSTANT_Utf8;

   547                             break;

   548                         case 'D':

   549                             tag = CONSTANT_Class;

   550                             break;

   551                         case 'F':

   552                             tag = CONSTANT_Fieldref;

   553                             break;

   554                         case 'M':

   555                             tag = CONSTANT_Methodref;

   556                             break;

   557                         case 'I':

   558                             tag = CONSTANT_InterfaceMethodref;

   559                             break;

   560                         case 'U':

   561                             tag = CONSTANT_Utf8;

   562                             break;

   563                         //case 'Q': tag = CONSTANT_Class; break;

   564                         default:

   565                             assert (false);

   566                             tag = 0;

   567                     }

   568                     assert (type.charAt(i + 2) == 'H');  // only H works for now

   569                     next = i + 3;

   570                     assert (afterElemHead || nextAttrName != null);

   571                     //System.out.println("get attr "+nextAttrName+" in "+aval);

   572                     if (nextAttrName != null) {

   573                         attrValue = aval.getAttr(nextAttrName);

   574                     } else if (aval.hasText()) {

   575                         attrValue = aval.getText().toString();

   576                     } else {

   577                         attrValue = null;

   578                     }

   579                     value = getCPIndex(tag, attrValue);

   580                     intKind = 'H'; //type.charAt(i+2);

   581                     break;

   582                 case 'P':  // bci = 'P' int

   583                 case 'S':  // signed_int = 'S' int

   584                     next = i + 2;

   585                     value = (int) aval.getAttrLong(nextAttrName);

   586                     intKind = type.charAt(i + 1);

   587                     break;

   588                 case 'F':

   589                     next = i + 2;

   590                     value = parseFlags(aval.getAttr(nextAttrName));

   591                     intKind = type.charAt(i + 1);

   592                     break;

   593                 default:

   594                     throw new RuntimeException("bad attr format '" + type.charAt(i) + "': " + type);

   595             }

   596             // write the value

   597             putInt(value, intKind);

   598             nextAttrName = null;

   599             afterElemHead = false;

   600         }

   601         assert (nextAttrName == null);

   602     }

   603 

   604     private void putInt(int x, char ch) throws IOException {

   605         switch (ch) {

   606             case 'B':

   607                 u1(x);

   608                 break;

   609             case 'H':

   610                 u2(x);

   611                 break;

   612             case 'I':

   613                 u4(x);

   614                 break;

   615         }

   616         assert ("BHI".indexOf(ch) >= 0);

   617     }

   618 

   619     private void writeCode(Element code) throws IOException {

   620         //System.out.println("writeCode "+code);

   621         //Element m = new Element(currentMember); m.remove(code);

   622         //System.out.println("       in "+m);

   623         int stack = (int) code.getAttrLong("stack");

   624         int local = (int) code.getAttrLong("local");

   625         Element bytes = code.findElement("Bytes");

   626         Element insns = code.findElement("Instructions");

   627         String bytecodes;

   628         if (insns == null) {

   629             bytecodes = bytes.getText().toString();

   630         } else {

   631             bytecodes = InstructionSyntax.assemble(insns, this);

   632             // Cache the assembled bytecodes:

   633             bytes = new Element("Bytes", (String[]) null, bytecodes);

   634             code.add(0, bytes);

   635         }

   636         u2(stack);

   637         u2(local);

   638         int length = bytecodes.length();

   639         u4(length);

   640         for (int i = 0; i < length; i++) {

   641             u1((byte) bytecodes.charAt(i));

   642         }

   643         Element handlers = code.findAllElements("Handler");

   644         u2(handlers.size());

   645         for (Element handler : handlers.elements()) {

   646             int start = (int) handler.getAttrLong("start");

   647             int end = (int) handler.getAttrLong("end");

   648             int catsh = (int) handler.getAttrLong("catch");

   649             u2(start);

   650             u2(end);

   651             u2(catsh);

   652             cpRef(CONSTANT_Class, handler.getAttr("class"));

   653         }

   654         writeAttributesFor(code);

   655     }

   656 

   657     protected void writeStackMap(Element attrs, boolean hasXOption) throws IOException {

   658         Element bytes = currentCode.findElement("Bytes");

   659         assert (bytes != null && bytes.size() == 1);

   660         int byteLength = ((String) bytes.get(0)).length();

   661         boolean uoffsetIsU4 = (byteLength >= (1 << 16));

   662         boolean ulocalvarIsU4 = currentCode.getAttrLong("local") >= (1 << 16);

   663         boolean ustackIsU4 = currentCode.getAttrLong("stack") >= (1 << 16);

   664         if (uoffsetIsU4) {

   665             u4(attrs.size());

   666         } else {

   667             u2(attrs.size());

   668         }

   669         for (Element frame : attrs.elements()) {

   670             int bci = (int) frame.getAttrLong("bci");

   671             if (uoffsetIsU4) {

   672                 u4(bci);

   673             } else {

   674                 u2(bci);

   675             }

   676             if (hasXOption) {

   677                 u1((int) frame.getAttrLong("flags"));

   678             }

   679             // Scan local and stack types in this frame:

   680             final int LOCALS = 0, STACK = 1;

   681             for (int j = LOCALS; j <= STACK; j++) {

   682                 Element types = frame.findElement(j == LOCALS ? "Local" : "Stack");

   683                 int typeSize = (types == null) ? 0 : types.size();

   684                 if (j == LOCALS) {

   685                     if (ulocalvarIsU4) {

   686                         u4(typeSize);

   687                     } else {

   688                         u2(typeSize);

   689                     }

   690                 } else { // STACK

   691                     if (ustackIsU4) {

   692                         u4(typeSize);

   693                     } else {

   694                         u2(typeSize);

   695                     }

   696                 }

   697                 if (types == null) {

   698                     continue;

   699                 }

   700                 for (Element type : types.elements()) {

   701                     int tag = itemTagValue(type.getName());

   702                     u1(tag);

   703                     switch (tag) {

   704                         case ITEM_Object:

   705                             cpRef(CONSTANT_Class, type.getAttr("class"));

   706                             break;

   707                         case ITEM_Uninitialized:

   708                         case ITEM_ReturnAddress: {

   709                             int offset = (int) type.getAttrLong("bci");

   710                             if (uoffsetIsU4) {

   711                                 u4(offset);

   712                             } else {

   713                                 u2(offset);

   714                             }

   715                         }

   716                         break;

   717                     }

   718                 }

   719             }

   720         }

   721     }

   722 

   723     public void writeCP() throws IOException {

   724         int cpLen = cpoolSize;

   725         u2(cpLen);

   726         ByteArrayOutputStream buf = getAttrBuf();

   727         for (Element c : cpool.elements()) {

   728             if (!c.isText()) {

   729                 System.out.println("## !isText " + c);

   730             }

   731             int id = (int) c.getAttrLong("id");

   732             int tag = cpTagValue(c.getName());

   733             String name = c.getText().toString();

   734             int pos;

   735             u1(tag);

   736             switch (tag) {

   737                 case CONSTANT_Utf8: {

   738                     int done = 0;

   739                     buf.reset();

   740                     int nameLen = name.length();

   741                     while (done < nameLen) {

   742                         int next = name.indexOf((char) 0, done);

   743                         if (next < 0) {

   744                             next = nameLen;

   745                         }

   746                         if (done < next) {

   747                             buf.write(name.substring(done, next).getBytes(UTF8_ENCODING));

   748                         }

   749                         if (next < nameLen) {

   750                             buf.write(0300);

   751                             buf.write(0200);

   752                             next++;

   753                         }

   754                         done = next;

   755                     }

   756                     u2(buf.size());

   757                     buf.writeTo(out);

   758                 }

   759                 break;

   760                 case CONSTANT_Integer:

   761                     u4(Integer.parseInt(name));

   762                     break;

   763                 case CONSTANT_Float:

   764                     u4(Float.floatToIntBits(Float.parseFloat(name)));

   765                     break;

   766                 case CONSTANT_Long:

   767                     u8(Long.parseLong(name));

   768                     //i += 1;  // no need:  extra cp slot is implicit

   769                     break;

   770                 case CONSTANT_Double:

   771                     u8(Double.doubleToLongBits(Double.parseDouble(name)));

   772                     //i += 1;  // no need:  extra cp slot is implicit

   773                     break;

   774                 case CONSTANT_Class:

   775                 case CONSTANT_String:

   776                     u2(getCPIndex(CONSTANT_Utf8, name));

   777                     break;

   778                 case CONSTANT_Fieldref:

   779                 case CONSTANT_Methodref:

   780                 case CONSTANT_InterfaceMethodref:

   781                     pos = name.indexOf(' ');

   782                     u2(getCPIndex(CONSTANT_Class, name.substring(0, pos)));

   783                     u2(getCPIndex(CONSTANT_NameAndType, name.substring(pos + 1)));

   784                     break;

   785                 case CONSTANT_NameAndType:

   786                     pos = name.indexOf(' ');

   787                     u2(getCPIndex(CONSTANT_Utf8, name.substring(0, pos)));

   788                     u2(getCPIndex(CONSTANT_Utf8, name.substring(pos + 1)));

   789                     break;

   790             }

   791         }

   792         putAttrBuf(buf);

   793     }

   794 

   795     public void cpRef(int tag, String name) throws IOException {

   796         u2(getCPIndex(tag, name));

   797     }

   798 

   799     public void u8(long x) throws IOException {

   800         u4((int) (x >>> 32));

   801         u4((int) (x >>> 0));

   802     }

   803 

   804     public void u4(int x) throws IOException {

   805         u2(x >>> 16);

   806         u2(x >>> 0);

   807     }

   808 

   809     public void u2(int x) throws IOException {

   810         u1(x >>> 8);

   811         u1(x >>> 0);

   812     }

   813 

   814     public void u1(int x) throws IOException {

   815         out.write(x & 0xFF);

   816     }

   817 }

   818