jar files

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

commons-exec-1.3.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Export-Package: org.apache.commons.exec;version="1.3",org.apache.commo
 ns.exec.environment;version="1.3",org.apache.commons.exec.launcher;ve
 rsion="1.3",org.apache.commons.exec.util;version="1.3"
Implementation-Title: Apache Commons Exec
Built-By: ggregory
Tool: Bnd-2.3.0.201405100607
Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.5))"
Implementation-Vendor: The Apache Software Foundation
Implementation-Vendor-Id: org.apache
Specification-Title: Apache Commons Exec
Bundle-License: http://www.apache.org/licenses/LICENSE-2.0.txt
Bundle-SymbolicName: org.apache.commons.exec
X-Compile-Target-JDK: 1.5
Implementation-Version: 1.3
Specification-Vendor: The Apache Software Foundation
Bundle-Name: Apache Commons Exec
Created-By: Apache Maven Bundle Plugin
X-Compile-Source-JDK: 1.5
Bundle-Vendor: The Apache Software Foundation
Build-Jdk: 1.7.0_71
Bundle-Version: 1.3.0
Bnd-LastModified: 1414972321055
Bundle-ManifestVersion: 2
Bundle-Description: Apache Commons Exec is a library to reliably execu
 te external processes from within the JVM.
Bundle-DocURL: http://commons.apache.org/proper/commons-exec/
Include-Resource: META-INF/LICENSE.txt=LICENSE.txt,META-INF/NOTICE.txt
 =NOTICE.txt
Specification-Version: 1.3
Implementation-Build: trunk@r1636211; 2014-11-02 23:51:55+0000
Archiver-Version: Plexus Archiver
META-INF/LICENSE.txt
/*
 * Apache License
 * Version 2.0, January 2004
 * http://www.apache.org/licenses/
 *
 * TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 *
 * 1. Definitions.
 *
 * "License" shall mean the terms and conditions for use, reproduction,
 * and distribution as defined by Sections 1 through 9 of this document.
 *
 * "Licensor" shall mean the copyright owner or entity authorized by
 * the copyright owner that is granting the License.
 *
 * "Legal Entity" shall mean the union of the acting entity and all
 * other entities that control, are controlled by, or are under common
 * control with that entity. For the purposes of this definition,
 * "control" means (i) the power, direct or indirect, to cause the
 * direction or management of such entity, whether by contract or
 * otherwise, or (ii) ownership of fifty percent (50%) or more of the
 * outstanding shares, or (iii) beneficial ownership of such entity.
 *
 * "You" (or "Your") shall mean an individual or Legal Entity
 * exercising permissions granted by this License.
 *
 * "Source" form shall mean the preferred form for making modifications,
 * including but not limited to software source code, documentation
 * source, and configuration files.
 *
 * "Object" form shall mean any form resulting from mechanical
 * transformation or translation of a Source form, including but
 * not limited to compiled object code, generated documentation,
 * and conversions to other media types.
 *
 * "Work" shall mean the work of authorship, whether in Source or
 * Object form, made available under the License, as indicated by a
 * copyright notice that is included in or attached to the work
 * (an example is provided in the Appendix below).
 *
 * "Derivative Works" shall mean any work, whether in Source or Object
 * form, that is based on (or derived from) the Work and for which the
 * editorial revisions, annotations, elaborations, or other modifications
 * represent, as a whole, an original work of authorship. For the purposes
 * of this License, Derivative Works shall not include works that remain
 * separable from, or merely link (or bind by name) to the interfaces of,
 * the Work and Derivative Works thereof.
 *
 * "Contribution" shall mean any work of authorship, including
 * the original version of the Work and any modifications or additions
 * to that Work or Derivative Works thereof, that is intentionally
 * submitted to Licensor for inclusion in the Work by the copyright owner
 * or by an individual or Legal Entity authorized to submit on behalf of
 * the copyright owner. For the purposes of this definition, "submitted"
 * means any form of electronic, verbal, or written communication sent
 * to the Licensor or its representatives, including but not limited to
 * communication on electronic mailing lists, source code control systems,
 * and issue tracking systems that are managed by, or on behalf of, the
 * Licensor for the purpose of discussing and improving the Work, but
 * excluding communication that is conspicuously marked or otherwise
 * designated in writing by the copyright owner as "Not a Contribution."
 *
 * "Contributor" shall mean Licensor and any individual or Legal Entity
 * on behalf of whom a Contribution has been received by Licensor and
 * subsequently incorporated within the Work.
 *
 * 2. Grant of Copyright License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * copyright license to reproduce, prepare Derivative Works of,
 * publicly display, publicly perform, sublicense, and distribute the
 * Work and such Derivative Works in Source or Object form.
 *
 * 3. Grant of Patent License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * (except as stated in this section) patent license to make, have made,
 * use, offer to sell, sell, import, and otherwise transfer the Work,
 * where such license applies only to those patent claims licensable
 * by such Contributor that are necessarily infringed by their
 * Contribution(s) alone or by combination of their Contribution(s)
 * with the Work to which such Contribution(s) was submitted. If You
 * institute patent litigation against any entity (including a
 * cross-claim or counterclaim in a lawsuit) alleging that the Work
 * or a Contribution incorporated within the Work constitutes direct
 * or contributory patent infringement, then any patent licenses
 * granted to You under this License for that Work shall terminate
 * as of the date such litigation is filed.
 *
 * 4. Redistribution. You may reproduce and distribute copies of the
 * Work or Derivative Works thereof in any medium, with or without
 * modifications, and in Source or Object form, provided that You
 * meet the following conditions:
 *
 * (a) You must give any other recipients of the Work or
 * Derivative Works a copy of this License; and
 *
 * (b) You must cause any modified files to carry prominent notices
 * stating that You changed the files; and
 *
 * (c) You must retain, in the Source form of any Derivative Works
 * that You distribute, all copyright, patent, trademark, and
 * attribution notices from the Source form of the Work,
 * excluding those notices that do not pertain to any part of
 * the Derivative Works; and
 *
 * (d) If the Work includes a "NOTICE" text file as part of its
 * distribution, then any Derivative Works that You distribute must
 * include a readable copy of the attribution notices contained
 * within such NOTICE file, excluding those notices that do not
 * pertain to any part of the Derivative Works, in at least one
 * of the following places: within a NOTICE text file distributed
 * as part of the Derivative Works; within the
Source form or
 * documentation, if provided along with the Derivative Works; or,
 * within a display generated by the Derivative Works, if and
 * wherever such third-party notices normally appear. The contents
 * of the NOTICE file are for informational purposes only and
 * do not modify the License. You may add Your own attribution
 * notices within Derivative Works that You distribute, alongside
 * or as an addendum to the NOTICE text from the Work, provided
 * that such additional attribution notices cannot be construed
 * as modifying the License.
 *
 * You may add Your own copyright statement to Your modifications and
 * may provide additional or different license terms and conditions
 * for use, reproduction, or distribution of Your modifications, or
 * for any such Derivative Works as a whole, provided Your use,
 * reproduction, and distribution of the Work otherwise complies with
 * the conditions stated in this License.
 *
 * 5. Submission of Contributions. Unless You explicitly state otherwise,
 * any Contribution intentionally submitted for inclusion in the Work
 * by You to the Licensor shall be under the terms and conditions of
 * this License, without any additional terms or conditions.
 * Notwithstanding the above, nothing herein shall supersede or modify
 * the terms of any separate license agreement you may have executed
 * with Licensor regarding such Contributions.
 *
 * 6. Trademarks. This License does not grant permission to use the trade
 * names, trademarks, service marks, or product names of the Licensor,
 * except as required for reasonable and customary use in describing the
 * origin of the Work and reproducing the content of the NOTICE file.
 *
 * 7. Disclaimer of Warranty. Unless required by applicable law or
 * agreed to in writing, Licensor provides the Work (and each
 * Contributor provides its Contributions) on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied, including, without limitation, any warranties or conditions
 * of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
 * PARTICULAR PURPOSE. You are solely responsible for determining the
 * appropriateness of using or redistributing the Work and assume any
 * risks associated with Your exercise of permissions under this License.
 *
 * 8. Limitation of Liability. In no event and under no legal theory,
 * whether in tort (including negligence), contract, or otherwise,
 * unless required by applicable law (such as deliberate and grossly
 * negligent acts) or agreed to in writing, shall any Contributor be
 * liable to You for damages, including any direct, indirect, special,
 * incidental, or consequential damages of any character arising as a
 * result of this License or out of the use or inability to use the
 * Work (including but not limited to damages for loss of goodwill,
 * work stoppage, computer failure or malfunction, or any and all
 * other commercial damages or losses), even if such Contributor
 * has been advised of the possibility of such damages.
 *
 * 9. Accepting Warranty or Additional Liability. While redistributing
 * the Work or Derivative Works thereof, You may choose to offer,
 * and charge a fee for, acceptance of support, warranty, indemnity,
 * or other liability obligations and/or rights consistent with this
 * License. However, in accepting such obligations, You may act only
 * on Your own behalf and on Your sole responsibility, not on behalf
 * of any other Contributor, and only if You agree to indemnify,
 * defend, and hold each Contributor harmless for any liability
 * incurred by, or claims asserted against, such Contributor by reason
 * of your accepting any such warranty or additional liability.
 *
 * END OF TERMS AND CONDITIONS
 *
 * APPENDIX: How to apply the Apache License to your work.
 *
 * To apply the Apache License to your work, attach the following
 * boilerplate notice, with the fields enclosed by brackets "[]"
 * replaced with your own identifying information. (Don't include
 * the brackets!) The text should be enclosed in the appropriate
 * comment syntax for the file format. We also recommend that a
 * file or class name and description of purpose be included on the
 * same "printed page" as the copyright notice for easier
 * identification within third-party archives.
 *
 * Copyright [yyyy] [name of copyright owner]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
META-INF/NOTICE.txt
Apache Commons Exec
Copyright 2005-2014 The Apache Software Foundation
This product includes software developed at
The Apache Software Foundation (http://www.apache.org/).
org/apache/commons/exec/CommandLine$1.class
package org.apache.commons.exec;
synchronized class CommandLine$1 {
}
org/apache/commons/exec/CommandLine$Argument.class
package org.apache.commons.exec;
synchronized class CommandLine$Argument {
 private final String value;
 private final boolean handleQuoting;
 private void CommandLine$Argument(CommandLine, String, boolean);
 private String getValue();
 private boolean isHandleQuoting();
}
org/apache/commons/exec/CommandLine.class
package org.apache.commons.exec;
public synchronized class CommandLine {
 private final java.util.Vector arguments;
 private final String executable;
 private java.util.Map substitutionMap;
 private final boolean isFile;
 public static CommandLine parse(String);
 public static CommandLine parse(String, java.util.Map);
 public void CommandLine(String);
 public void CommandLine(java.io.File);
 public void CommandLine(CommandLine);
 public String getExecutable();
 public boolean isFile();
 public CommandLine addArguments(String[]);
 public CommandLine addArguments(String[], boolean);
 public CommandLine addArguments(String);
 public CommandLine addArguments(String, boolean);
 public CommandLine addArgument(String);
 public CommandLine addArgument(String, boolean);
 public String[] getArguments();
 public java.util.Map getSubstitutionMap();
 public void setSubstitutionMap(java.util.Map);
 public String[] toStrings();
 public String toString();
 private String expandArgument(String);
 private static String[] translateCommandline(String);
 private String toCleanExecutable(String);
}
org/apache/commons/exec/DaemonExecutor.class
package org.apache.commons.exec;
public synchronized class DaemonExecutor extends DefaultExecutor {
 public void DaemonExecutor();
 protected Thread createThread(Runnable, String);
}
org/apache/commons/exec/DefaultExecuteResultHandler.class
package org.apache.commons.exec;
public synchronized class DefaultExecuteResultHandler implements ExecuteResultHandler {
 private static final int SLEEP_TIME_MS = 50;
 private volatile boolean hasResult;
 private volatile int exitValue;
 private volatile ExecuteException exception;
 public void DefaultExecuteResultHandler();
public void onProcessComplete(int);
 public void onProcessFailed(ExecuteException);
 public ExecuteException getException();
 public int getExitValue();
 public boolean hasResult();
 public void waitFor() throws InterruptedException;
 public void waitFor(long) throws InterruptedException;
}
org/apache/commons/exec/DefaultExecutor$1.class
package org.apache.commons.exec;
synchronized class DefaultExecutor$1 implements Runnable {
 void DefaultExecutor$1(DefaultExecutor, CommandLine, java.util.Map, ExecuteResultHandler);
 public void run();
}
org/apache/commons/exec/DefaultExecutor.class
package org.apache.commons.exec;
public synchronized class DefaultExecutor implements Executor {
 private ExecuteStreamHandler streamHandler;
 private java.io.File workingDirectory;
 private ExecuteWatchdog watchdog;
 private int[] exitValues;
 private final launcher.CommandLauncher launcher;
 private ProcessDestroyer processDestroyer;
 private Thread executorThread;
 private java.io.IOException exceptionCaught;
 public void DefaultExecutor();
 public ExecuteStreamHandler getStreamHandler();
 public void setStreamHandler(ExecuteStreamHandler);
 public ExecuteWatchdog getWatchdog();
 public void setWatchdog(ExecuteWatchdog);
 public ProcessDestroyer getProcessDestroyer();
 public void setProcessDestroyer(ProcessDestroyer);
 public java.io.File getWorkingDirectory();
 public void setWorkingDirectory(java.io.File);
 public int execute(CommandLine) throws ExecuteException, java.io.IOException;
 public int execute(CommandLine, java.util.Map) throws ExecuteException, java.io.IOException;
 public void execute(CommandLine, ExecuteResultHandler) throws ExecuteException, java.io.IOException;
 public void execute(CommandLine, java.util.Map, ExecuteResultHandler) throws ExecuteException, java.io.IOException;
 public void setExitValue(int);
 public void setExitValues(int[]);
 public boolean isFailure(int);
 protected Thread createThread(Runnable, String);
 protected Process launch(CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
 protected Thread getExecutorThread();
 private void closeProcessStreams(Process);
 private int executeInternal(CommandLine, java.util.Map, java.io.File, ExecuteStreamHandler) throws java.io.IOException;
 private void setExceptionCaught(java.io.IOException);
 private java.io.IOException getExceptionCaught();
}
org/apache/commons/exec/environment/DefaultProcessingEnvironment$1.class
package org.apache.commons.exec.environment;
synchronized class DefaultProcessingEnvironment$1 implements java.util.Comparator {
 void DefaultProcessingEnvironment$1(DefaultProcessingEnvironment);
 public int compare(String, String);
}
org/apache/commons/exec/environment/DefaultProcessingEnvironment.class
package org.apache.commons.exec.environment;
public synchronized class DefaultProcessingEnvironment {
 protected java.util.Map procEnvironment;
 public void DefaultProcessingEnvironment();
 public synchronized java.util.Map getProcEnvironment() throws java.io.IOException;
 protected java.util.Map createProcEnvironment() throws java.io.IOException;
 protected java.io.BufferedReader runProcEnvCommand() throws java.io.IOException;
 protected org.apache.commons.exec.CommandLine getProcEnvCommand();
 private java.util.Map createEnvironmentMap();
}
org/apache/commons/exec/environment/EnvironmentUtils.class
package org.apache.commons.exec.environment;
public synchronized class EnvironmentUtils {
 private static final DefaultProcessingEnvironment PROCESSING_ENVIRONMENT_IMPLEMENTATION;
 private void EnvironmentUtils();
 public static String[] toStrings(java.util.Map);
 public static java.util.Map getProcEnvironment() throws java.io.IOException;
 public static void addVariableToEnvironment(java.util.Map, String);
 private static String[] parseEnvironmentVariable(String);
 static void <clinit>();
}
org/apache/commons/exec/environment/OpenVmsProcessingEnvironment.class
package org.apache.commons.exec.environment;
public synchronized class OpenVmsProcessingEnvironment extends DefaultProcessingEnvironment {
 public void OpenVmsProcessingEnvironment();
}
org/apache/commons/exec/ExecuteException.class
package org.apache.commons.exec;
public synchronized class ExecuteException extends java.io.IOException {
 private static final long serialVersionUID = 3256443620654331699;
 private final Throwable cause;
 private final int exitValue;
 public void ExecuteException(String, int);
 public void ExecuteException(String, int, Throwable);
 public Throwable getCause();
 public int getExitValue();
}
org/apache/commons/exec/ExecuteResultHandler.class
package org.apache.commons.exec;
public abstract interface ExecuteResultHandler {
 public abstract void onProcessComplete(int);
 public abstract void onProcessFailed(ExecuteException);
}
org/apache/commons/exec/ExecuteStreamHandler.class
package org.apache.commons.exec;
public abstract interface ExecuteStreamHandler {
 public abstract void setProcessInputStream(java.io.OutputStream) throws java.io.IOException;
 public abstract void setProcessErrorStream(java.io.InputStream) throws java.io.IOException;
 public abstract void setProcessOutputStream(java.io.InputStream) throws java.io.IOException;
 public abstract void start() throws java.io.IOException;
 public abstract void stop() throws java.io.IOException;
}
org/apache/commons/exec/ExecuteWatchdog.class
package org.apache.commons.exec;
public synchronized class ExecuteWatchdog implements TimeoutObserver {
 public static final long INFINITE_TIMEOUT = -1;
 private Process process;
 private final boolean hasWatchdog;
 private boolean watch;
 private Exception caught;
 private boolean killedProcess;
 private final Watchdog watchdog;
 private volatile boolean processStarted;
 public void ExecuteWatchdog(long);
 public synchronized void start(Process);
 public synchronized void stop();
 public synchronized void destroyProcess();
 public synchronized void timeoutOccured(Watchdog);
 public synchronized void checkException() throws Exception;
 public synchronized boolean isWatching();
 public synchronized boolean killedProcess();
 protected synchronized void cleanUp();
 void setProcessNotStarted();
 private void ensureStarted();
}
org/apache/commons/exec/Executor.class
package org.apache.commons.exec;
public abstract interface Executor {
 public static final int INVALID_EXITVALUE = -559038737;
 public abstract void setExitValue(int);
 public abstract void setExitValues(int[]);
 public abstract boolean isFailure(int);
 public abstract ExecuteStreamHandler getStreamHandler();
 public abstract void setStreamHandler(ExecuteStreamHandler);
 public abstract ExecuteWatchdog getWatchdog();
 public abstract void setWatchdog(ExecuteWatchdog);
 public abstract ProcessDestroyer getProcessDestroyer();
 public abstract void setProcessDestroyer(ProcessDestroyer);
 public abstract java.io.File getWorkingDirectory();
 public abstract void setWorkingDirectory(java.io.File);
 public abstract int execute(CommandLine) throws ExecuteException, java.io.IOException;
 public abstract int execute(CommandLine, java.util.Map) throws ExecuteException, java.io.IOException;
 public abstract void execute(CommandLine, ExecuteResultHandler) throws ExecuteException, java.io.IOException;
 public abstract void execute(CommandLine, java.util.Map, ExecuteResultHandler) throws ExecuteException, java.io.IOException;
}
org/apache/commons/exec/InputStreamPumper.class
package org.apache.commons.exec;
public synchronized class InputStreamPumper implements Runnable {
 public static final int SLEEPING_TIME = 100;
 private final java.io.InputStream is;
 private final java.io.OutputStream os;
 private volatile boolean stop;
 public void InputStreamPumper(java.io.InputStream, java.io.OutputStream);
 public void run();
 public void stopProcessing();
}
org/apache/commons/exec/launcher/CommandLauncher.class
package org.apache.commons.exec.launcher;
public abstract interface CommandLauncher {
 public abstract Process exec(org.apache.commons.exec.CommandLine, java.util.Map) throws java.io.IOException;
 public abstract Process exec(org.apache.commons.exec.CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
 public abstract boolean isFailure(int);
}
org/apache/commons/exec/launcher/CommandLauncherFactory.class
package org.apache.commons.exec.launcher;
public final synchronized class CommandLauncherFactory {
 private void CommandLauncherFactory();
 public static CommandLauncher createVMLauncher();
}
org/apache/commons/exec/launcher/CommandLauncherImpl.class
package org.apache.commons.exec.launcher;
public abstract synchronized class CommandLauncherImpl implements CommandLauncher {
 public void CommandLauncherImpl();
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map) throws java.io.IOException;
 public abstract Process exec(org.apache.commons.exec.CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
 public boolean isFailure(int);
}
org/apache/commons/exec/launcher/CommandLauncherProxy.class
package org.apache.commons.exec.launcher;
public abstract synchronized class CommandLauncherProxy extends CommandLauncherImpl {
 private final CommandLauncher myLauncher;
 public void CommandLauncherProxy(CommandLauncher);
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map) throws java.io.IOException;
}
org/apache/commons/exec/launcher/Java13CommandLauncher.class
package org.apache.commons.exec.launcher;
public synchronized class Java13CommandLauncher extends CommandLauncherImpl {
 public void Java13CommandLauncher();
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
}
org/apache/commons/exec/launcher/OS2CommandLauncher.class
package org.apache.commons.exec.launcher;
public synchronized class OS2CommandLauncher extends CommandLauncherProxy {
 public void OS2CommandLauncher(CommandLauncher);
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
}
org/apache/commons/exec/launcher/VmsCommandLauncher.class
package org.apache.commons.exec.launcher;
public synchronized class VmsCommandLauncher extends Java13CommandLauncher {
 public void VmsCommandLauncher();
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map) throws java.io.IOException;
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
 public boolean isFailure(int);
 private java.io.File createCommandFile(org.apache.commons.exec.CommandLine, java.util.Map) throws java.io.IOException;
}
org/apache/commons/exec/launcher/WinNTCommandLauncher.class
package org.apache.commons.exec.launcher;
public synchronized class WinNTCommandLauncher extends CommandLauncherProxy {
 public void WinNTCommandLauncher(CommandLauncher);
 public Process exec(org.apache.commons.exec.CommandLine, java.util.Map, java.io.File) throws java.io.IOException;
}
org/apache/commons/exec/LogOutputStream.class
package org.apache.commons.exec;
public abstract synchronized class LogOutputStream extends java.io.OutputStream {
 private static final int INTIAL_SIZE = 132;
 private static final int CR = 13;
 private static final int LF = 10;
 private final java.io.ByteArrayOutputStream buffer;
 private boolean skip;
 private final int level;
 public void LogOutputStream();
 public void LogOutputStream(int);
 public void write(int) throws java.io.IOException;
 public void flush();
 public void close() throws java.io.IOException;
 public int getMessageLevel();
 public void write(byte[], int, int) throws java.io.IOException;
 protected void processBuffer();
 protected void processLine(String);
 protected abstract void processLine(String, int);
}
org/apache/commons/exec/OS.class
package org.apache.commons.exec;
public final synchronized class OS {
 private static final String FAMILY_OS_400 = os/400;
 private static final String FAMILY_Z_OS = z/os;
 private static final String FAMILY_WIN9X = win9x;
 private static final String FAMILY_OPENVMS = openvms;
 private static final String FAMILY_UNIX = unix;
 private static final String FAMILY_TANDEM = tandem;
 private static final String FAMILY_MAC = mac;
 private static final String FAMILY_DOS = dos;
 private static final String FAMILY_NETWARE = netware;
 private static final String FAMILY_OS_2 = os/2;
 private static final String FAMILY_WINDOWS = windows;
 private static final String OS_NAME;
 private static final String OS_ARCH;
 private static final String OS_VERSION;
 private static final String PATH_SEP;
 private void OS();
 private static boolean isFamily(String);
 public static boolean isFamilyDOS();
 public static boolean isFamilyMac();
 public static boolean isFamilyNetware();
 public static boolean isFamilyOS2();
 public static boolean isFamilyTandem();
 public static boolean isFamilyUnix();
 public static boolean isFamilyWindows();
 public static boolean isFamilyWin9x();
 public static boolean isFamilyZOS();
 public static boolean isFamilyOS400();
 public static boolean isFamilyOpenVms();
 public static boolean isName(String);
 public static boolean isArch(String);
 public static boolean isVersion(String);
 public static boolean isOs(String, String, String, String);
 static void <clinit>();
}
org/apache/commons/exec/ProcessDestroyer.class
package org.apache.commons.exec;
public abstract interface ProcessDestroyer {
 public abstract boolean add(Process);
 public abstract boolean remove(Process);
 public abstract int size();
}
org/apache/commons/exec/PumpStreamHandler.class
package org.apache.commons.exec;
public synchronized class PumpStreamHandler implements ExecuteStreamHandler {
 private static final long STOP_TIMEOUT_ADDITION = 2000;
 private Thread outputThread;
 private Thread errorThread;
 private Thread inputThread;
 private final java.io.OutputStream out;
 private final java.io.OutputStream err;
 private final java.io.InputStream input;
 private InputStreamPumper inputStreamPumper;
 private long stopTimeout;
 private java.io.IOException caught;
 public void PumpStreamHandler();
 public void PumpStreamHandler(java.io.OutputStream);
 public void PumpStreamHandler(java.io.OutputStream, java.io.OutputStream);
 public void PumpStreamHandler(java.io.OutputStream, java.io.OutputStream, java.io.InputStream);
 public void setStopTimeout(long);
 public void setProcessOutputStream(java.io.InputStream);
 public void setProcessErrorStream(java.io.InputStream);
 public void setProcessInputStream(java.io.OutputStream);
 public void start();
 public void stop() throws java.io.IOException;
 protected java.io.OutputStream getErr();
 protected java.io.OutputStream getOut();
 protected void createProcessOutputPump(java.io.InputStream, java.io.OutputStream);
 protected void createProcessErrorPump(java.io.InputStream,
java.io.OutputStream);
 protected Thread createPump(java.io.InputStream, java.io.OutputStream);
 protected Thread createPump(java.io.InputStream, java.io.OutputStream, boolean);
 protected void stopThread(Thread, long);
 private Thread createSystemInPump(java.io.InputStream, java.io.OutputStream);
}
org/apache/commons/exec/ShutdownHookProcessDestroyer$ProcessDestroyerImpl.class
package org.apache.commons.exec;
synchronized class ShutdownHookProcessDestroyer$ProcessDestroyerImpl extends Thread {
 private boolean shouldDestroy;
 public void ShutdownHookProcessDestroyer$ProcessDestroyerImpl(ShutdownHookProcessDestroyer);
 public void run();
 public void setShouldDestroy(boolean);
}
org/apache/commons/exec/ShutdownHookProcessDestroyer.class
package org.apache.commons.exec;
public synchronized class ShutdownHookProcessDestroyer implements ProcessDestroyer, Runnable {
 private final java.util.Vector processes;
 private ShutdownHookProcessDestroyer$ProcessDestroyerImpl destroyProcessThread;
 private boolean added;
 private volatile boolean running;
 public void ShutdownHookProcessDestroyer();
 private void addShutdownHook();
 private void removeShutdownHook();
 public boolean isAddedAsShutdownHook();
 public boolean add(Process);
 public boolean remove(Process);
 public int size();
 public void run();
}
org/apache/commons/exec/StreamPumper.class
package org.apache.commons.exec;
public synchronized class StreamPumper implements Runnable {
 private static final int DEFAULT_SIZE = 1024;
 private final java.io.InputStream is;
 private final java.io.OutputStream os;
 private final int size;
 private boolean finished;
 private final boolean closeWhenExhausted;
 public void StreamPumper(java.io.InputStream, java.io.OutputStream, boolean);
 public void StreamPumper(java.io.InputStream, java.io.OutputStream, boolean, int);
 public void StreamPumper(java.io.InputStream, java.io.OutputStream);
 public void run();
 public synchronized boolean isFinished();
 public synchronized void waitFor() throws InterruptedException;
}
org/apache/commons/exec/TimeoutObserver.class
package org.apache.commons.exec;
public abstract interface TimeoutObserver {
 public abstract void timeoutOccured(Watchdog);
}
org/apache/commons/exec/util/DebugUtils.class
package org.apache.commons.exec.util;
public synchronized class DebugUtils {
 public static final String COMMONS_EXEC_LENIENT = org.apache.commons.exec.lenient;
 public static final String COMMONS_EXEC_DEBUG = org.apache.commons.exec.debug;
 public void DebugUtils();
 public static void handleException(String, Exception);
 public static boolean isDebugEnabled();
 public static boolean isLenientEnabled();
}
org/apache/commons/exec/util/MapUtils.class
package org.apache.commons.exec.util;
public synchronized class MapUtils {
 public void MapUtils();
 public static java.util.Map copy(java.util.Map);
 public static java.util.Map prefix(java.util.Map, String);
 public static java.util.Map merge(java.util.Map, java.util.Map);
}
org/apache/commons/exec/util/StringUtils.class
package org.apache.commons.exec.util;
public synchronized class StringUtils {
 private static final String SINGLE_QUOTE = ';
 private static final String DOUBLE_QUOTE = ";
 private static final char SLASH_CHAR = 47;
 private static final char BACKSLASH_CHAR = 92;
 public void StringUtils();
 public static StringBuffer stringSubstitution(String, java.util.Map, boolean);
 public static String[] split(String, String);
 public static String fixFileSeparatorChar(String);
 public static String toString(String[], String);
 public static String quoteArgument(String);
 public static boolean isQuoted(String);
}
org/apache/commons/exec/Watchdog.class
package org.apache.commons.exec;
public synchronized class Watchdog implements Runnable {
 private final java.util.Vector observers;
 private final long timeout;
 private boolean stopped;
 public void Watchdog(long);
 public void addTimeoutObserver(TimeoutObserver);
 public void removeTimeoutObserver(TimeoutObserver);
 protected final void fireTimeoutOccured();
 public synchronized void start();
 public synchronized void stop();
 public void run();
}
META-INF/maven/org.apache.commons/commons-exec/pom.xml
 
 
 org.apache.commons
 commons-parent
 35
 
 4.0.0
 Apache Commons Exec
 org.apache.commons
 commons-exec
 1.3
 Apache Commons Exec is a library to reliably execute external processes from within the JVM.
 
 2.2.1
 
 http://commons.apache.org/proper/commons-exec/
 
 jira
 http://issues.apache.org/jira/browse/EXEC
 
 
 scm:svn:http://svn.apache.org/repos/asf/commons/proper/exec/trunk
 scm:svn:https://svn.apache.org/repos/asf/commons/proper/exec/trunk
 http://svn.apache.org/viewvc/commons/proper/exec/trunk
 
 
 
 junit
 junit
 
 4.11
 test
 
 
 
 
 brett
 Brett Porter
 Apache
 +10
 
 
 trygvis
 Trygve Laugstøl
 Apache
 +1
 
 
 sgoeschl
 Siegfried Goeschl
 Apache
 +1
 
 
 sebb
 Sebastian Bazley
 Apache
 +1
 
 
 Gary Gregory
 ggregory
 Apache
 ggregory@apache.org
 http://www.garygregory.com
 -5
 
 
 
 
 Niklas Gustavsson
 
 
 Benjamin Bentmann
 
 
 Marco Ferrante
 
 
 Jerome Lacoste
 
 
 Milos Kleint
 
 
 Pablo Hoertner
 
 
 Niall Pemberton
 
 
 
 
 
 org.apache.maven.plugins
 maven-surefire-plugin
 
 
 **/TestUtil.java
 
 
 
 
 maven-assembly-plugin
 
 
 src/main/assembly/bin.xml
 src/main/assembly/src.xml
 
 gnu
 
 
 
 org.apache.maven.plugins
 maven-jar-plugin
 
 
 
 true
 true
 
 
 
 
 
 org.apache.maven.plugins
 maven-release-plugin
 2.0
 
 forked-path
 
 
 
 
 
 
 stagingSite
 Apache Staging Website
 ${commons.deployment.protocol}://people.apache.org/www/commons.apache.org/${commons.componentid}/
 
 
 
 
 
 org.apache.maven.plugins
 maven-pmd-plugin
 3.2
 
 ${maven.compiler.target}
 true
 
 ${basedir}/pmd.xml
org.codehaus.mojo
 findbugs-maven-plugin
 2.5.5
 
 Normal
 Default
 ${basedir}/findbugs-exclude-filter.xml
 
 
 
 org.codehaus.sonar-plugins
 maven-report
 0.1
 
 
 
 
 
 
 coverage
 
 
 
 
 org.codehaus.mojo
 cobertura-maven-plugin
 2.6
 
 
 
 
 
 setup-checkout
 
 
 site-content
 
 
 
 
 
 org.apache.maven.plugins
 maven-antrun-plugin
 1.7
 
 
 prepare-checkout
 pre-site
 
 run
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 1.5
 1.5
 *Test
 exec
 EXEC
 12310814
 1.3
 
 RC1
 
 UTF-8
 UTF-8
 site-content
 
META-INF/maven/org.apache.commons/commons-exec/pom.properties
#Generated by Maven
#Sun Nov 02 18:54:14 EST 2014
version=1.3
groupId=org.apache.commons
artifactId=commons-exec
jna-4.1.0.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.9.2
Created-By: 1.7.0_40-b43 (Oracle Corporation)
Main-Class: com.sun.jna.Native
Implementation-Title: com.sun.jna
Implementation-Vendor: JNA Development Team
Implementation-Version: 4.1.0 (b4)
Specification-Title: Java Native Access (JNA)
Specification-Vendor: JNA Development Team
Specification-Version: 4
Bundle-Category: jni
Bundle-ManifestVersion: 2
Bundle-Name: jna
Bundle-Description: JNA Library
Bundle-SymbolicName: com.sun.jna
Bundle-Version: 4.1.0
Bundle-RequiredExecutionEnvironment: J2SE-1.4
Bundle-Vendor: JNA Development Team
Bundle-ActivationPolicy: lazy
Export-Package: com.sun.jna,com.sun.jna.ptr,com.sun.jna.win32
Bundle-NativeCode: com/sun/jna/win32-x86/jnidispatch.dll; processor=x
 86;osname=win32, com/sun/jna/win32-x86-64/jnidispatch.dll; processor=
 x86-64;osname=win32, com/sun/jna/w32ce-arm/jnidispatch.dll; processor
 =arm;osname=wince, com/sun/jna/sunos-x86/libjnidispatch.so; processo
 r=x86;osname=sunos, com/sun/jna/sunos-x86-64/libjnidispatch.so; proce
 ssor=x86-64;osname=sunos, com/sun/jna/sunos-sparc/libjnidispatch.so; 
 processor=sparc;osname=sunos, com/sun/jna/sunos-sparcv9/libjnidispatc
 h.so; processor=sparcv9;osname=sunos, com/sun/jna/aix-ppc/libjnidisp
 atch.a; processor=ppc;osname=aix, com/sun/jna/aix-ppc64/libjnidispatc
 h.a; processor=ppc64;osname=aix, com/sun/jna/linux-ppc/libjnidispatc
 h.so; processor=ppc;osname=linux, com/sun/jna/linux-ppc64/libjnidispa
 tch.so; processor=ppc64;osname=linux, com/sun/jna/linux-x86/libjnidis
 patch.so; processor=x86;osname=linux, com/sun/jna/linux-x86-64/libjni
 dispatch.so; processor=x86-64;osname=linux, com/sun/jna/linux-arm/lib
 jnidispatch.so; processor=arm;osname=linux, com/sun/jna/linux-ia64/li
 bjnidispatch.so; processor=ia64;osname=linux, com/sun/jna/freebsd-x8
 6/libjnidispatch.so; processor=x86;osname=freebsd, com/sun/jna/freebs
 d-x86-64/libjnidispatch.so; processor=x86-64;osname=freebsd, com/sun/
 jna/openbsd-x86/libjnidispatch.so; processor=x86;osname=openbsd, com/
 sun/jna/openbsd-x86-64/libjnidispatch.so; processor=x86-64;osname=ope
 nbsd, com/sun/jna/darwin/libjnidispatch.jnilib; osname=macosx;proces
 sor=x86;processor=x86-64;processor=ppc 
com/sun/jna/AltCallingConvention.class
package com.sun.jna;
public abstract interface AltCallingConvention {
}
com/sun/jna/Callback$UncaughtExceptionHandler.class
package com.sun.jna;
public abstract interface Callback$UncaughtExceptionHandler {
 public abstract void uncaughtException(Callback, Throwable);
}
com/sun/jna/Callback.class
package com.sun.jna;
public abstract interface Callback {
 public static final String METHOD_NAME = callback;
 public static final java.util.Collection FORBIDDEN_NAMES;
 static void <clinit>();
}
com/sun/jna/CallbackParameterContext.class
package com.sun.jna;
public synchronized class CallbackParameterContext extends FromNativeContext {
 private reflect.Method method;
 private Object[] args;
 private int index;
 void CallbackParameterContext(Class, reflect.Method, Object[], int);
 public reflect.Method getMethod();
 public Object[] getArguments();
 public int getIndex();
}
com/sun/jna/CallbackProxy.class
package com.sun.jna;
public abstract interface CallbackProxy extends Callback {
 public abstract Object callback(Object[]);
 public abstract Class[] getParameterTypes();
 public abstract Class getReturnType();
}
com/sun/jna/CallbackReference$AttachOptions.class
package com.sun.jna;
synchronized class CallbackReference$AttachOptions extends Structure {
 public boolean daemon;
 public boolean detach;
 public String name;
 void CallbackReference$AttachOptions();
 protected java.util.List getFieldOrder();
}
com/sun/jna/CallbackReference$DefaultCallbackProxy.class
package com.sun.jna;
synchronized class CallbackReference$DefaultCallbackProxy implements CallbackProxy {
 private final reflect.Method callbackMethod;
 private ToNativeConverter toNative;
 private final FromNativeConverter[] fromNative;
 private final String encoding;
 public void CallbackReference$DefaultCallbackProxy(CallbackReference, reflect.Method, TypeMapper, String);
 public Callback getCallback();
 private Object invokeCallback(Object[]);
 public Object callback(Object[]);
 private Object convertArgument(Object, Class);
 private Object convertResult(Object);
 public Class[] getParameterTypes();
 public Class getReturnType();
}
com/sun/jna/CallbackReference$NativeFunctionHandler.class
package com.sun.jna;
synchronized class CallbackReference$NativeFunctionHandler implements reflect.InvocationHandler {
 private final Function function;
 private final java.util.Map options;
 public void CallbackReference$NativeFunctionHandler(Pointer, int, java.util.Map);
 public Object invoke(Object, reflect.Method, Object[]) throws Throwable;
 public Pointer getPointer();
}
com/sun/jna/CallbackReference.class
package com.sun.jna;
synchronized class CallbackReference extends ref.WeakReference {
 static final java.util.Map callbackMap;
 static final java.util.Map directCallbackMap;
 static final java.util.Map pointerCallbackMap;
 static final java.util.Map allocations;
 private static final reflect.Method PROXY_CALLBACK_METHOD;
 private static final java.util.Map initializers;
 Pointer cbstruct;
 Pointer trampoline;
 CallbackProxy proxy;
 reflect.Method method;
 static void setCallbackThreadInitializer(Callback, CallbackThreadInitializer);
 private static ThreadGroup initializeThread(Callback, CallbackReference$AttachOptions);
public static Callback getCallback(Class, Pointer);
 private static Callback getCallback(Class, Pointer, boolean);
 private void CallbackReference(Callback, int, boolean);
 private Class getNativeType(Class);
 private static reflect.Method checkMethod(reflect.Method);
 static Class findCallbackClass(Class);
 private static reflect.Method getCallbackMethod(Callback);
 private static reflect.Method getCallbackMethod(Class);
 private void setCallbackOptions(int);
 public Pointer getTrampoline();
 protected void finalize();
 protected synchronized void dispose();
 private Callback getCallback();
 private static Pointer getNativeFunctionPointer(Callback);
 public static Pointer getFunctionPointer(Callback);
 private static Pointer getFunctionPointer(Callback, boolean);
 private static boolean isAllowableNativeType(Class);
 private static Pointer getNativeString(Object, boolean);
 static void <clinit>();
}
com/sun/jna/CallbackResultContext.class
package com.sun.jna;
public synchronized class CallbackResultContext extends ToNativeContext {
 private reflect.Method method;
 void CallbackResultContext(reflect.Method);
 public reflect.Method getMethod();
}
com/sun/jna/CallbackThreadInitializer.class
package com.sun.jna;
public synchronized class CallbackThreadInitializer {
 private boolean daemon;
 private boolean detach;
 private String name;
 private ThreadGroup group;
 public void CallbackThreadInitializer();
 public void CallbackThreadInitializer(boolean);
 public void CallbackThreadInitializer(boolean, boolean);
 public void CallbackThreadInitializer(boolean, boolean, String);
 public void CallbackThreadInitializer(boolean, boolean, String, ThreadGroup);
 public String getName(Callback);
 public ThreadGroup getThreadGroup(Callback);
 public boolean isDaemon(Callback);
 public boolean detach(Callback);
}
com/sun/jna/DefaultTypeMapper$Entry.class
package com.sun.jna;
synchronized class DefaultTypeMapper$Entry {
 public Class type;
 public Object converter;
 public void DefaultTypeMapper$Entry(Class, Object);
}
com/sun/jna/DefaultTypeMapper.class
package com.sun.jna;
public synchronized class DefaultTypeMapper implements TypeMapper {
 private java.util.List toNativeConverters;
 private java.util.List fromNativeConverters;
 public void DefaultTypeMapper();
 private Class getAltClass(Class);
 public void addToNativeConverter(Class, ToNativeConverter);
 public void addFromNativeConverter(Class, FromNativeConverter);
 protected void addTypeConverter(Class, TypeConverter);
 private Object lookupConverter(Class, java.util.List);
 public FromNativeConverter getFromNativeConverter(Class);
 public ToNativeConverter getToNativeConverter(Class);
}
com/sun/jna/FromNativeContext.class
package com.sun.jna;
public synchronized class FromNativeContext {
 private Class type;
 void FromNativeContext(Class);
 public Class getTargetType();
}
com/sun/jna/FromNativeConverter.class
package com.sun.jna;
public abstract interface FromNativeConverter {
 public abstract Object fromNative(Object, FromNativeContext);
 public abstract Class nativeType();
}
com/sun/jna/Function$NativeMappedArray.class
package com.sun.jna;
synchronized class Function$NativeMappedArray extends Memory implements Function$PostCallRead {
 private final NativeMapped[] original;
 public void Function$NativeMappedArray(NativeMapped[]);
 public void read();
}
com/sun/jna/Function$PointerArray.class
package com.sun.jna;
synchronized class Function$PointerArray extends Memory implements Function$PostCallRead {
 private final Pointer[] original;
 public void Function$PointerArray(Pointer[]);
 public void read();
}
com/sun/jna/Function$PostCallRead.class
package com.sun.jna;
public abstract interface Function$PostCallRead {
 public abstract void read();
}
com/sun/jna/Function.class
package com.sun.jna;
public synchronized class Function extends Pointer {
 public static final int MAX_NARGS = 256;
 public static final int C_CONVENTION = 0;
 public static final int ALT_CONVENTION = 1;
 private static final int MASK_CC = 3;
 public static final int THROW_LAST_ERROR = 4;
 static final Integer INTEGER_TRUE;
 static final Integer INTEGER_FALSE;
 private NativeLibrary library;
 private final String functionName;
 final String encoding;
 final int callFlags;
 final java.util.Map options;
 static final String OPTION_INVOKING_METHOD = invoking-method;
 public static Function getFunction(String, String);
 public static Function getFunction(String, String, int);
 public static Function getFunction(String, String, int, String);
 public static Function getFunction(Pointer);
 public static Function getFunction(Pointer, int);
 void Function(NativeLibrary, String, int, String);
 void Function(Pointer, int, String);
 private void checkCallingConvention(int) throws IllegalArgumentException;
 public String getName();
 public int getCallingConvention();
 public Object invoke(Class, Object[]);
 public Object invoke(Class, Object[], java.util.Map);
 Object invoke(Object[], Class, boolean);
 private Pointer invokePointer(int, Object[]);
 private Object convertArgument(Object[], int, reflect.Method, TypeMapper, boolean, Class);
 private boolean isPrimitiveArray(Class);
 public void invoke(Object[]);
 private String invokeString(int, Object[], boolean);
 public String toString();
 public Object invokeObject(Object[]);
 public Pointer invokePointer(Object[]);
 public String invokeString(Object[], boolean);
 public int invokeInt(Object[]);
 public long invokeLong(Object[]);
 public float invokeFloat(Object[]);
 public double invokeDouble(Object[]);
 public void invokeVoid(Object[]);
 public boolean equals(Object);
 public int hashCode();
 static Object[] concatenateVarArgs(Object[]);
 static boolean isVarArgs(reflect.Method);
 static Boolean valueOf(boolean);
 static void <clinit>();
}
com/sun/jna/FunctionMapper.class
package com.sun.jna;
public abstract interface FunctionMapper {
 public abstract String getFunctionName(NativeLibrary, reflect.Method);
}
com/sun/jna/FunctionParameterContext.class
package com.sun.jna;
public synchronized class FunctionParameterContext extends ToNativeContext {
 private Function function;
 private Object[] args;
 private int index;
 void FunctionParameterContext(Function, Object[], int);
 public Function getFunction();
 public Object[] getParameters();
 public int getParameterIndex();
}
com/sun/jna/FunctionResultContext.class
package com.sun.jna;
public synchronized class FunctionResultContext extends FromNativeContext {
 private Function function;
 private Object[] args;
 void FunctionResultContext(Class, Function, Object[]);
 public Function getFunction();
 public Object[] getArguments();
}
com/sun/jna/IntegerType.class
package com.sun.jna;
public abstract synchronized class IntegerType extends Number implements NativeMapped {
 private int size;
 private Number number;
 private boolean unsigned;
 private long value;
 public void IntegerType(int);
 public void IntegerType(int, boolean);
 public void IntegerType(int, long);
 public void IntegerType(int, long, boolean);
 public void setValue(long);
 public Object toNative();
 public Object fromNative(Object, FromNativeContext);
 public Class nativeType();
 public int intValue();
 public long longValue();
 public float
floatValue();
 public double doubleValue();
 public boolean equals(Object);
 public String toString();
 public int hashCode();
}
com/sun/jna/InvocationMapper.class
package com.sun.jna;
public abstract interface InvocationMapper {
 public abstract reflect.InvocationHandler getInvocationHandler(NativeLibrary, reflect.Method);
}
com/sun/jna/LastErrorException.class
package com.sun.jna;
public synchronized class LastErrorException extends RuntimeException {
 private int errorCode;
 private static String formatMessage(int);
 private static String parseMessage(String);
 public void LastErrorException(String);
 public int getErrorCode();
 public void LastErrorException(int);
}
com/sun/jna/Library$1.class
package com.sun.jna;
synchronized class Library$1 {
}
com/sun/jna/Library$Handler$FunctionInfo.class
package com.sun.jna;
synchronized class Library$Handler$FunctionInfo {
 reflect.InvocationHandler handler;
 Function function;
 boolean isVarArgs;
 java.util.Map options;
 private void Library$Handler$FunctionInfo();
}
com/sun/jna/Library$Handler.class
package com.sun.jna;
public synchronized class Library$Handler implements reflect.InvocationHandler {
 static final reflect.Method OBJECT_TOSTRING;
 static final reflect.Method OBJECT_HASHCODE;
 static final reflect.Method OBJECT_EQUALS;
 private final NativeLibrary nativeLibrary;
 private final Class interfaceClass;
 private final java.util.Map options;
 private final InvocationMapper invocationMapper;
 private final java.util.Map functions;
 public void Library$Handler(String, Class, java.util.Map);
 public NativeLibrary getNativeLibrary();
 public String getLibraryName();
 public Class getInterfaceClass();
 public Object invoke(Object, reflect.Method, Object[]) throws Throwable;
 static void <clinit>();
}
com/sun/jna/Library.class
package com.sun.jna;
public abstract interface Library {
 public static final String OPTION_TYPE_MAPPER = type-mapper;
 public static final String OPTION_FUNCTION_MAPPER = function-mapper;
 public static final String OPTION_INVOCATION_MAPPER = invocation-mapper;
 public static final String OPTION_STRUCTURE_ALIGNMENT = structure-alignment;
 public static final String OPTION_STRING_ENCODING = string-encoding;
 public static final String OPTION_ALLOW_OBJECTS = allow-objects;
 public static final String OPTION_CALLING_CONVENTION = calling-convention;
 public static final String OPTION_OPEN_FLAGS = open-flags;
 public static final String OPTION_CLASSLOADER = classloader;
}
com/sun/jna/Memory$SharedMemory.class
package com.sun.jna;
synchronized class Memory$SharedMemory extends Memory {
 public void Memory$SharedMemory(Memory, long, long);
 protected void dispose();
 protected void boundsCheck(long, long);
 public String toString();
}
com/sun/jna/Memory.class
package com.sun.jna;
public synchronized class Memory extends Pointer {
 private static final java.util.Map buffers;
 protected long size;
 public static void purge();
 public void Memory(long);
 protected void Memory();
 public Pointer share(long);
 public Pointer share(long, long);
 public Memory align(int);
 protected void finalize();
 protected void dispose();
 public void clear();
 public boolean valid();
 public long size();
 protected void boundsCheck(long, long);
 public void read(long, byte[], int, int);
 public void read(long, short[], int, int);
 public void read(long, char[], int, int);
 public void read(long, int[], int, int);
 public void read(long, long[], int, int);
 public void read(long, float[], int, int);
 public void read(long, double[], int, int);
 public void write(long, byte[], int, int);
 public void write(long, short[], int, int);
 public void write(long, char[], int, int);
 public void write(long, int[], int, int);
 public void write(long, long[], int, int);
 public void write(long, float[], int, int);
 public void write(long, double[], int, int);
 public byte getByte(long);
 public char getChar(long);
 public short getShort(long);
 public int getInt(long);
 public long getLong(long);
 public float getFloat(long);
 public double getDouble(long);
 public Pointer getPointer(long);
 public java.nio.ByteBuffer getByteBuffer(long, long);
 public String getString(long, String);
 public String getWideString(long);
 public void setByte(long, byte);
 public void setChar(long, char);
 public void setShort(long, short);
 public void setInt(long, int);
 public void setLong(long, long);
 public void setFloat(long, float);
 public void setDouble(long, double);
 public void setPointer(long, Pointer);
 public void setString(long, String, String);
 public void setWideString(long, String);
 public String toString();
 protected static void free(long);
 protected static long malloc(long);
 public String dump();
 static void <clinit>();
}
com/sun/jna/MethodParameterContext.class
package com.sun.jna;
public synchronized class MethodParameterContext extends FunctionParameterContext {
 private reflect.Method method;
 void MethodParameterContext(Function, Object[], int, reflect.Method);
 public reflect.Method getMethod();
}
com/sun/jna/MethodResultContext.class
package com.sun.jna;
public synchronized class MethodResultContext extends FunctionResultContext {
 private final reflect.Method method;
 void MethodResultContext(Class, Function, Object[], reflect.Method);
 public reflect.Method getMethod();
}
com/sun/jna/Native$1.class
package com.sun.jna;
final synchronized class Native$1 implements Callback$UncaughtExceptionHandler {
 void Native$1();
 public void uncaughtException(Callback, Throwable);
}
com/sun/jna/Native$2.class
package com.sun.jna;
final synchronized class Native$2 {
 void Native$2();
 protected void finalize();
}
com/sun/jna/Native$3.class
package com.sun.jna;
final synchronized class Native$3 implements reflect.InvocationHandler {
 void Native$3(Library$Handler, Library);
 public Object invoke(Object, reflect.Method, Object[]) throws Throwable;
}
com/sun/jna/Native$4.class
package com.sun.jna;
final synchronized class Native$4 implements java.security.PrivilegedAction {
 void Native$4();
 public Object run();
}
com/sun/jna/Native$5.class
package com.sun.jna;
final synchronized class Native$5 implements java.io.FilenameFilter {
 void Native$5();
 public boolean accept(java.io.File, String);
}
com/sun/jna/Native$6.class
package com.sun.jna;
final synchronized class Native$6 extends SecurityManager {
 void Native$6();
 public Class[] getClassContext();
}
com/sun/jna/Native$7.class
package com.sun.jna;
final synchronized class Native$7 {
 void Native$7();
 protected void finalize();
}
com/sun/jna/Native$8.class
package com.sun.jna;
final synchronized class Native$8 extends ThreadLocal {
 void Native$8();
 protected Object initialValue();
}
com/sun/jna/Native$AWT.class
package com.sun.jna;
synchronized class Native$AWT {
 private void Native$AWT();
 static long getWindowID(java.awt.Window) throws java.awt.HeadlessException;
 static long getComponentID(Object) throws java.awt.HeadlessException;
}
com/sun/jna/Native$Buffers.class
package com.sun.jna;
synchronized class Native$Buffers {
 private void Native$Buffers();
 static boolean isBuffer(Class);
}
com/sun/jna/Native$ffi_callback.class
package com.sun.jna;
public abstract interface Native$ffi_callback {
 public abstract void invoke(long, long, long);
}
com/sun/jna/Native.class
package com.sun.jna;
public final synchronized class Native implements Version {
 public static final String DEFAULT_ENCODING = utf8;
 static final boolean DEBUG_LOAD;
 static final boolean DEBUG_JNA_LOAD;
 static String jnidispatchPath;
 private static java.util.Map options;
 private static java.util.Map libraries;
 private static final Callback$UncaughtExceptionHandler DEFAULT_HANDLER;
 private static Callback$UncaughtExceptionHandler callbackExceptionHandler;
 public static final int POINTER_SIZE;
 public static final int LONG_SIZE;
 public static final int WCHAR_SIZE;
 public static final int SIZE_T_SIZE;
 private static final int TYPE_VOIDP = 0;
 private static final int TYPE_LONG = 1;
 private static final int TYPE_WCHAR_T = 2;
 private static final int TYPE_SIZE_T = 3;
 static final int MAX_ALIGNMENT;
 static final int MAX_PADDING;
 private static final Object finalizer;
 static final String JNA_TMPLIB_PREFIX = jna;
 private static java.util.Map registeredClasses;
 private static java.util.Map registeredLibraries;
 private static Object unloader;
 static final int CB_HAS_INITIALIZER = 1;
 private static final int CVT_UNSUPPORTED = -1;
 private static final int CVT_DEFAULT = 0;
 private static final int CVT_POINTER = 1;
 private static final int CVT_STRING = 2;
 private static final int CVT_STRUCTURE = 3;
 private static final int CVT_STRUCTURE_BYVAL = 4;
 private static final int CVT_BUFFER = 5;
 private static final int CVT_ARRAY_BYTE = 6;
 private static final int CVT_ARRAY_SHORT = 7;
 private static final int CVT_ARRAY_CHAR = 8;
 private static final int CVT_ARRAY_INT = 9;
 private static final int CVT_ARRAY_LONG = 10;
 private static final int CVT_ARRAY_FLOAT = 11;
 private static final int CVT_ARRAY_DOUBLE = 12;
 private static final int CVT_ARRAY_BOOLEAN = 13;
 private static final int CVT_BOOLEAN = 14;
 private static final int CVT_CALLBACK = 15;
 private static final int CVT_FLOAT = 16;
 private static final int CVT_NATIVE_MAPPED = 17;
 private static final int CVT_WSTRING = 18;
 private static final int CVT_INTEGER_TYPE = 19;
 private static final int CVT_POINTER_TYPE = 20;
 private static final int CVT_TYPE_MAPPER = 21;
 static final int CB_OPTION_DIRECT = 1;
 static final int CB_OPTION_IN_DLL = 2;
 private static java.util.Map nativeThreads;
 private static ThreadLocal nativeThreadTerminationFlag;
 private static void dispose();
 static boolean deleteLibrary(java.io.File);
 private void Native();
 private static native void initIDs();
 public static synchronized native void setProtected(boolean);
 public static synchronized native boolean isProtected();
 public static void setPreserveLastError(boolean);
 public static boolean getPreserveLastError();
 public static long getWindowID(java.awt.Window) throws java.awt.HeadlessException;
 public static long getComponentID(java.awt.Component) throws java.awt.HeadlessException;
 public static Pointer getWindowPointer(java.awt.Window) throws java.awt.HeadlessException;
 public static Pointer getComponentPointer(java.awt.Component) throws java.awt.HeadlessException;
 static native long getWindowHandle0(java.awt.Component);
 public static Pointer getDirectBufferPointer(java.nio.Buffer);
 private static native long _getDirectBufferPointer(java.nio.Buffer);
 public static String toString(byte[]);
 public static String toString(byte[], String);
 public static String toString(char[]);
 public static Object loadLibrary(Class);
 public static Object loadLibrary(Class, java.util.Map);
 public static Object loadLibrary(String, Class);
 public static Object loadLibrary(String, Class, java.util.Map);
 private static void loadLibraryInstance(Class);
 static Class findEnclosingLibraryClass(Class);
 public static java.util.Map getLibraryOptions(Class);
 private static Object lookupField(Class, String, Class);
 public static TypeMapper getTypeMapper(Class);
 public static String getStringEncoding(Class);
 public static String getDefaultStringEncoding();
 public static int getStructureAlignment(Class);
 static byte[] getBytes(String);
 static byte[] getBytes(String, String);
 public static byte[] toByteArray(String);
 public static byte[] toByteArray(String, String);
 public static char[] toCharArray(String);
 private static void loadNativeDispatchLibrary();
 private static void loadNativeDispatchLibraryFromClasspath();
 static boolean isUnpacked(java.io.File);
 public static java.io.File extractFromResourcePath(String) throws java.io.IOException;
 public static java.io.File extractFromResourcePath(String, ClassLoader) throws java.io.IOException;
 private static native int sizeof(int);
 private static native String getNativeVersion();
 private static native String getAPIChecksum();
 public static native int getLastError();
 public static native void setLastError(int);
 public static Library synchronizedLibrary(Library);
 public static String getWebStartLibraryPath(String);
 static void markTemporaryFile(java.io.File);
 static java.io.File getTempDir() throws java.io.IOException;
 static void removeTemporaryFiles() throws java.io.IOException;
 public static int getNativeSize(Class, Object);
 public static int getNativeSize(Class);
 public static boolean isSupportedNativeType(Class);
 public static void setCallbackExceptionHandler(Callback$UncaughtExceptionHandler);
 public static Callback$UncaughtExceptionHandler getCallbackExceptionHandler();
 public static void register(String);
 public static void register(NativeLibrary);
 static Class findDirectMappedClass(Class);
 static Class getCallingClass();
 public static void setCallbackThreadInitializer(Callback, CallbackThreadInitializer);
 public static void unregister();
 public static void unregister(Class);
 private static native void unregister(Class, long[]);
 private static String getSignature(Class);
 static String replace(String, String, String);
 private static int getConversion(Class, TypeMapper);
 public static void register(Class, String);
 public static void register(Class, NativeLibrary);
 private static void cacheOptions(Class, java.util.Map, Object);
 private static native long registerMethod(Class, String, String, int[], long[], long[], int, long, long, Class, long, int, boolean, ToNativeConverter[], FromNativeConverter, String);
 private static NativeMapped fromNative(Class, Object);
 private static Class nativeType(Class);
 private static Object toNative(ToNativeConverter, Object);
 private static Object fromNative(FromNativeConverter, Object, Class);
 public static native long ffi_prep_cif(int, int, long, long);
 public static native void ffi_call(long, long, long, long);
 public static native long ffi_prep_closure(long, Native$ffi_callback);
 public static native void ffi_free_closure(long);
 static native int initialize_ffi_type(long);
 public static void main(String[]);
 static synchronized native void freeNativeCallback(long);
 static synchronized native long createNativeCallback(Callback, reflect.Method, Class[], Class, int, int, String);
 static native int invokeInt(long, int, Object[]);
 static native long invokeLong(long, int, Object[]);
 static native void invokeVoid(long, int, Object[]);
 static native float invokeFloat(long, int, Object[]);
 static native double invokeDouble(long, int, Object[]);
 static native long invokePointer(long, int, Object[]);
 private
static native void invokeStructure(long, int, Object[], long, long);
 static Structure invokeStructure(long, int, Object[], Structure);
 static native Object invokeObject(long, int, Object[]);
 static long open(String);
 static native long open(String, int);
 static native void close(long);
 static native long findSymbol(long, String);
 static native long indexOf(long, byte);
 static native void read(long, byte[], int, int);
 static native void read(long, short[], int, int);
 static native void read(long, char[], int, int);
 static native void read(long, int[], int, int);
 static native void read(long, long[], int, int);
 static native void read(long, float[], int, int);
 static native void read(long, double[], int, int);
 static native void write(long, byte[], int, int);
 static native void write(long, short[], int, int);
 static native void write(long, char[], int, int);
 static native void write(long, int[], int, int);
 static native void write(long, long[], int, int);
 static native void write(long, float[], int, int);
 static native void write(long, double[], int, int);
 static native byte getByte(long);
 static native char getChar(long);
 static native short getShort(long);
 static native int getInt(long);
 static native long getLong(long);
 static native float getFloat(long);
 static native double getDouble(long);
 static Pointer getPointer(long);
 private static native long _getPointer(long);
 static native String getWideString(long);
 static String getString(long);
 static String getString(long, String);
 static native byte[] getStringBytes(long);
 static native void setMemory(long, long, byte);
 static native void setByte(long, byte);
 static native void setShort(long, short);
 static native void setChar(long, char);
 static native void setInt(long, int);
 static native void setLong(long, long);
 static native void setFloat(long, float);
 static native void setDouble(long, double);
 static native void setPointer(long, long);
 static native void setWideString(long, String);
 public static native long malloc(long);
 public static native void free(long);
 public static native java.nio.ByteBuffer getDirectByteBuffer(long, long);
 public static void detach(boolean);
 static Pointer getTerminationFlag(Thread);
 private static native void setDetachState(boolean, long);
 static void <clinit>();
}
com/sun/jna/NativeLibrary$1.class
package com.sun.jna;
synchronized class NativeLibrary$1 extends Function {
 void NativeLibrary$1(NativeLibrary, NativeLibrary, String, int, String);
 Object invoke(Object[], Class, boolean);
}
com/sun/jna/NativeLibrary$2.class
package com.sun.jna;
final synchronized class NativeLibrary$2 implements java.io.FilenameFilter {
 void NativeLibrary$2(String);
 public boolean accept(java.io.File, String);
}
com/sun/jna/NativeLibrary.class
package com.sun.jna;
public synchronized class NativeLibrary {
 private long handle;
 private final String libraryName;
 private final String libraryPath;
 private final java.util.Map functions;
 final int callFlags;
 private String encoding;
 final java.util.Map options;
 private static final java.util.Map libraries;
 private static final java.util.Map searchPaths;
 private static final java.util.List librarySearchPath;
 private static final int DEFAULT_OPEN_OPTIONS = -1;
 private static String functionKey(String, int, String);
 private void NativeLibrary(String, String, long, java.util.Map);
 private static int openFlags(java.util.Map);
 private static NativeLibrary loadLibrary(String, java.util.Map);
 static String matchFramework(String);
 private String getLibraryName(String);
 public static final NativeLibrary getInstance(String);
 public static final NativeLibrary getInstance(String, ClassLoader);
 public static final NativeLibrary getInstance(String, java.util.Map);
 public static final synchronized NativeLibrary getProcess();
 public static final synchronized NativeLibrary getProcess(java.util.Map);
 public static final void addSearchPath(String, String);
 public Function getFunction(String);
 Function getFunction(String, reflect.Method);
 public Function getFunction(String, int);
 public Function getFunction(String, int, String);
 public java.util.Map getOptions();
 public Pointer getGlobalVariableAddress(String);
 long getSymbolAddress(String);
 public String toString();
 public String getName();
 public java.io.File getFile();
 protected void finalize();
 static void disposeAll();
 public void dispose();
 private static java.util.List initPaths(String);
 private static String findLibraryPath(String, java.util.List);
 static String mapSharedLibraryName(String);
 private static boolean isVersionedName(String);
 static String matchLibrary(String, java.util.List);
 static double parseVersion(String);
 private static String getMultiArchPath();
 static void <clinit>();
}
com/sun/jna/NativeLong.class
package com.sun.jna;
public synchronized class NativeLong extends IntegerType {
 public static final int SIZE;
 public void NativeLong();
 public void NativeLong(long);
 static void <clinit>();
}
com/sun/jna/NativeMapped.class
package com.sun.jna;
public abstract interface NativeMapped {
 public abstract Object fromNative(Object, FromNativeContext);
 public abstract Object toNative();
 public abstract Class nativeType();
}
com/sun/jna/NativeMappedConverter.class
package com.sun.jna;
public synchronized class NativeMappedConverter implements TypeConverter {
 private static final java.util.Map converters;
 private final Class type;
 private final Class nativeType;
 private final NativeMapped instance;
 public static NativeMappedConverter getInstance(Class);
 public void NativeMappedConverter(Class);
 public NativeMapped defaultValue();
 public Object fromNative(Object, FromNativeContext);
 public Class nativeType();
 public Object toNative(Object, ToNativeContext);
 static void <clinit>();
}
com/sun/jna/NativeString.class
package com.sun.jna;
synchronized class NativeString implements CharSequence, Comparable {
 static final String WIDE_STRING = --WIDE-STRING--;
 private Pointer pointer;
 private String encoding;
 public void NativeString(String);
 public void NativeString(String, boolean);
 public void NativeString(WString);
 public void NativeString(String, String);
 public int hashCode();
 public boolean equals(Object);
 public String toString();
 public Pointer getPointer();
 public char charAt(int);
 public int length();
 public CharSequence subSequence(int, int);
 public int compareTo(Object);
}
com/sun/jna/Platform.class
package com.sun.jna;
public final synchronized class Platform {
 public static final int UNSPECIFIED = -1;
 public static final int MAC = 0;
 public static final int LINUX = 1;
 public static final int WINDOWS = 2;
 public static final int SOLARIS = 3;
 public static final int FREEBSD = 4;
 public static final int OPENBSD = 5;
 public static final int WINDOWSCE = 6;
 public static final int AIX = 7;
 public static final int ANDROID = 8;
 public static final int GNU = 9;
 public static final int KFREEBSD = 10;
 public static final int NETBSD = 11;
 public static final boolean RO_FIELDS;
 public static final boolean HAS_BUFFERS;
 public static final boolean HAS_AWT;
 public static final String MATH_LIBRARY_NAME;
 public static final String C_LIBRARY_NAME;
 public static