Subversion Repositories openrisc

/* ClassWrapper.java - wrap ASM class objects

 Copyright (C) 2006, 2007 Free Software Foundation, Inc.

 This file is part of GNU Classpath.

 GNU Classpath is free software; you can redistribute it and/or modify

 it under the terms of the GNU General Public License as published by

 the Free Software Foundation; either version 2, or (at your option)

 any later version.

 GNU Classpath is distributed in the hope that it will be useful, but

 WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 General Public License for more details.

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

 along with GNU Classpath; see the file COPYING.  If not, write to the

 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 02110-1301 USA.

 Linking this library statically or dynamically with other modules is

 making a combined work based on this library.  Thus, the terms and

 conditions of the GNU General Public License cover the whole

 combination.

 As a special exception, the copyright holders of this library give you

 permission to link this library with independent modules to produce an

 executable, regardless of the license terms of these independent

 modules, and to copy and distribute the resulting executable under

 terms of your choice, provided that you also meet, for each linked

 independent module, the terms and conditions of the license of that

 module.  An independent module is a module which is not derived from

 or based on this library.  If you modify this library, you may extend

 this exception to your version of the library, but you are not

 obligated to do so.  If you do not wish to do so, delete this

 exception statement from your version. */

package gnu.classpath.tools.javah;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.PrintStream;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import org.objectweb.asm.tree.ClassNode;

import org.objectweb.asm.tree.FieldNode;

import org.objectweb.asm.tree.MethodNode;

public class ClassWrapper

    extends ClassNode

{

  Main classpath;

  ClassWrapper superClass;

  ArrayList<ClassWrapper> interfaceClasses;

  // The virtual table for this class.

  ArrayList<MethodNode> vtable;

  // A set of all the bridge method targets we've found.

  HashSet<String> bridgeTargets;

  // A set of all the method names in this class.

  HashSet<String> methodNames = new HashSet<String>();

  // This maps a method name + descriptor, e.g. "method()V", to the

  // name chosen for the method.  This is used when computing the

  // names of bridge method targets.

  HashMap<String,String> methodNameMap = new HashMap<String,String>();

  public ClassWrapper(Main classpath)

  {

    this.classpath = classpath;

  }

  public boolean hasNativeMethod()

  {

    Iterator<?> i = methods.iterator();

    while (i.hasNext())

      {

        MethodNode method = (MethodNode) i.next();

        if (Modifier.isNative(method.access))

          return true;

      }

    return false;

  }

  public boolean isThrowable() throws IOException

  {

    linkSupers();

    ClassWrapper self = this;

    while (self != null)

      {

        if (self.name.equals("java/lang/Throwable"))

          return true;

        self = self.superClass;

      }

    return false;

  }

  void linkSupers() throws IOException

  {

    if (superName == null)

      {

        // Object, do nothing.

        return;

      }

    if (superClass == null)

      {

        superClass = classpath.getClass(superName);

        assert interfaceClasses == null;

        interfaceClasses = new ArrayList<ClassWrapper>();

        for (int i = 0; i < interfaces.size(); ++i)

          {

            String ifname = (String) interfaces.get(i);

            ClassWrapper iface = classpath.getClass(ifname);

            iface.linkSupers();

            interfaceClasses.add(iface);

          }

      }

    superClass.linkSupers();

  }

  private int findSlot(MethodNode method)

  {

    for (int i = vtable.size() - 1; i >= 0; --i)

      {

        MethodNode base = vtable.get(i);

        if (MethodHelper.overrides(method, base))

          return i;

      }

    return - 1;

  }

  private void addInterfaceMethods(ClassWrapper iface)

  {

    Iterator<?> i = iface.methods.iterator();

    while (i.hasNext())

      {

        MethodNode im = (MethodNode) i.next();

        int slot = findSlot(im);

        if (slot == - 1)

          {

            vtable.add(im);

            // Also add it to our local methods.

            methods.add(im);

          }

      }

    addInterfaces(iface);

  }

  private void addInterfaces(ClassWrapper base)

  {

    if (base.interfaceClasses == null)

      return;

    Iterator<?> i = base.interfaceClasses.iterator();

    while (i.hasNext())

      {

        ClassWrapper iface = (ClassWrapper) i.next();

        addInterfaceMethods(iface);

      }

  }

  private void addLocalMethods()

  {

    Iterator<?> i = methods.iterator();

    while (i.hasNext())

      {

        MethodNode meth = (MethodNode) i.next();

        methodNames.add(meth.name);

        if (Modifier.isStatic(meth.access))

          continue;

        int slot = findSlot(meth);

        if (slot == - 1)

          vtable.add(meth);

        else

          vtable.set(slot, meth);

      }

  }

  private void makeVtable() throws IOException

  {

    if (vtable != null)

      return;

    if (superClass != null)

      {

        superClass.makeVtable();

        vtable = new ArrayList<MethodNode>(superClass.vtable);

        bridgeTargets = new HashSet<String>(superClass.bridgeTargets);

        methodNameMap = new HashMap<String,String>(superClass.methodNameMap);

      }

    else

      {

        // Object.

        vtable = new ArrayList<MethodNode>();

        bridgeTargets = new HashSet<String>();

        methodNameMap = new HashMap<String,String>();

      }

    addLocalMethods();

    addInterfaces(this);

    // Make a set of all the targets of bridge methods.  We rename

    // bridge target methods to avoid problems with C++.  You might

    // think we could rename the bridge methods themselves, but bridge

    // methods by definition override a method from the superclass --

    // and we have to consider the superclass' header as an

    // unchangeable entity.

    Iterator<?> i = methods.iterator();

    while (i.hasNext())

      {

        MethodNode m = (MethodNode) i.next();

        String desc = MethodHelper.getBridgeTarget(m);

        if (desc != null)

          {

            String sum = m.name + desc;

            boolean newTarget = bridgeTargets.add(sum);

            if (newTarget)

              {

                // Bridge target that is new in this class.

                String cname = this.name;

                int index = cname.lastIndexOf('/');

                cname = cname.substring(index + 1);

                methodNameMap.put(sum, cname + "$" + m.name);

              }

          }

      }

  }

  private void printFields(CniPrintStream out)

  {

    Iterator<?> i = fields.iterator();

    ClassWrapper self = superClass;

    while (i.hasNext())

      {

        FieldNode f = (FieldNode) i.next();

        boolean hasMethodName = methodNames.contains(f.name);

        if (FieldHelper.print(out, f, self, hasMethodName))

          self = null;

      }

  }

  private void printMethods(CniPrintStream out) throws IOException

  {

    makeVtable();

    // A given method is either static, overrides a super method, or

    // is already in vtable order.

    Iterator<?> i = methods.iterator();

    while (i.hasNext())

      {

        MethodNode m = (MethodNode) i.next();

        String nameToUse;

        String sum = m.name + m.desc;

        if (bridgeTargets.contains(sum))

          nameToUse = (String) methodNameMap.get(sum);

        else

          nameToUse = m.name;

        methodNameMap.put(sum, nameToUse);

        MethodHelper.print(out, m, this, nameToUse);

      }

  }

  private void printTextList(PrintStream out, int what, ArrayList<Text> textList)

  {

    if (textList == null)

      return;

    Iterator<Text> i = textList.iterator();

    boolean first = true;

    while (i.hasNext())

      {

        Text item = i.next();

        if (item.type == what)

          {

            if (first)

              {

                out.println();

                first = false;

              }

            if (what == Text.FRIEND)

              out.print("  friend ");

            out.println(item.text);

          }

      }

  }

  public void print(CniPrintStream out)

  {

    out.print("::");

    out.printName(name);

  }

  // This prints the body of a class to a CxxPrintStream.

  private void printContents(CniPrintStream out, ArrayList<Text> textList)

      throws IOException

  {

    printTextList(out, Text.PREPEND, textList);

    out.println();

    out.print("class ");

    // Don't use our print() -- we don't want the leading "::".

    out.printName(name);

    if (superClass != null)

      {

        out.print(" : public ");

        superClass.print(out);

      }

    out.println();

    out.println("{");

    printTextList(out, Text.ADD, textList);

    out.println();

    // Note: methods must come first, as we build the list

    // of method names while printing them.

    printMethods(out);

    printFields(out);

    out.setModifiers(Modifier.PUBLIC);

    out.println("  static ::java::lang::Class class$;");

    printTextList(out, Text.FRIEND, textList);

    out.print("}");

    if (Modifier.isInterface(access))

      out.print(" __attribute__ ((java_interface))");

    out.println(";");

    printTextList(out, Text.APPEND, textList);

  }

  public void printFully(PrintStream out) throws IOException

  {

    linkSupers();

    ArrayList<Text> textList = classpath.getClassTextList(name);

    out.println("// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-");

    out.println();

    String xname = "__" + name.replaceAll("/", "_") + "__";

    out.println("#ifndef " + xname);

    out.println("#define " + xname);

    out.println();

    out.println("#pragma interface");

    out.println();

    if (superClass != null)

      {

        out.print("#include <");

        out.print(superName);

        out.println(".h>");

      }

    // Write the body of the stream here. This lets

    // us emit the namespaces without a second pass.

    ByteArrayOutputStream bytes = new ByteArrayOutputStream();

    CniPrintStream cxxOut = new CniPrintStream(bytes);

    cxxOut.addClass(this);

    printContents(cxxOut, textList);

    cxxOut.printNamespaces(out);

    bytes.writeTo(out);

    out.println();

    out.println("#endif // " + xname);

  }

  public String toString()

  {

    return name;

  }

}