public static void reconstructHeaders(Iterable<NativeLibrary> libraries, PrintWriter out) {
    List<MemberRef> orphanMembers = new ArrayList<MemberRef>();
    Map<TypeRef, List<MemberRef>> membersByClass = new HashMap<TypeRef, List<MemberRef>>();
    for (NativeLibrary library : libraries) {
      for (Symbol symbol : library.getSymbols()) {
        MemberRef mr = symbol.getParsedRef();
        if (mr == null) continue;

        TypeRef et = mr.getEnclosingType();
        if (et == null) orphanMembers.add(mr);
        else {
          List<MemberRef> mrs = membersByClass.get(et);
          if (mrs == null) membersByClass.put(et, mrs = new ArrayList<MemberRef>());
          mrs.add(mr);
        }
      }
    }
    for (TypeRef tr : membersByClass.keySet()) out.println("class " + tr + ";");

    for (MemberRef mr : orphanMembers) out.println(mr + ";");

    for (Map.Entry<TypeRef, List<MemberRef>> e : membersByClass.entrySet()) {
      TypeRef tr = e.getKey();
      List<MemberRef> mrs = e.getValue();
      out.println("class " + tr + " \n{");
      for (MemberRef mr : mrs) {
        out.println("\t" + mr + ";");
      }
      out.println("}");
    }
  }
示例#2
0
  /**
   * Register.
   *
   * @param natives the natives
   * @param jni the jni
   * @param preload the preload
   */
  public static void register(String[] natives, String[] jni, Class<?>[] preload) {

    /*
     * Load JNI libraries. These libraries have definitions for our class
     * methods marked with native modifier. JNI libraries are loaded using
     * System.loadLibrary() call.
     */
    for (String name : jni) {
      JNILibrary.loadLibrary(name);
    }

    /*
     * Load 3rd party, external native raw libraries. These libraries are opened
     * using dlopen call, and not loaded like JNI libraries. They are typically
     * loaded as a dependency to one of the JNI libraries, but not necessarily.
     * Any native library can be opened this way.
     */
    for (String name : natives) {
      NativeLibrary.loadLibrary(name);
    }

    /*
     * Pre-load a list of classes. This forces each class to be loaded and
     * initialized. It also allows each of those classes to register themselves
     * and initialize their own libraries.
     */
    for (Class<?> clazz : preload) {
      try {
        Class.forName(clazz.getCanonicalName());
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
      }
    }
  }
示例#3
0
  static {

    // We don't seem to need an AccessController.doPrivileged() block
    // here as these system properties are visible even to unsigned
    // applets
    OS = System.getProperty("os.name");
    OS_VERSION = System.getProperty("os.version");
    ARCH = System.getProperty("os.arch");
    JAVA_VENDOR = System.getProperty("java.vendor");
    JAVA_VENDOR_URL = System.getProperty("java.vendor.url");
    JAVA_VERSION = System.getProperty("java.version");
    NEWLINE = System.getProperty("line.separator");

    JAVA_SE = initIsJavaSE();
    LITTLE_ENDIAN = initByteOrder();

    boolean libsLoaded = true;
    try {
      NativeLibrary.ensureNativeLibLoaded();
    } catch (UnsatisfiedLinkError err) {
      libsLoaded = false;
    }

    if (libsLoaded) {
      pointerSizeInBits = getPointerSizeInBitsImpl();
      final long pageSizeL = getPageSizeImpl();
      if (Integer.MAX_VALUE < pageSizeL) {
        throw new InternalError("PageSize exceeds integer value: " + pageSizeL);
      }
      pageSize = (int) pageSizeL;
    } else {
      pointerSizeInBits = -1;
      pageSize = -1;
    }

    is32Bit = initArch();
  }