org.eclipse.ant.core_3.2.401.v20121204-162022

 pop
    //   147: invokestatic 221	org/eclipse/core/variables/VariablesPlugin:getDefault	()Lorg/eclipse/core/variables/VariablesPlugin;
    //   150: invokevirtual 220	org/eclipse/core/variables/VariablesPlugin:getStringVariableManager	()Lorg/eclipse/core/variables/IStringVariableManager;
    //   153: astore 12
    //   155: aload 12
    //   157: aload 10
    //   159: invokeinterface 239 2 0
    //   164: astore 10
    //   166: aload 12
    //   168: aload 11
    //   170: invokeinterface 239 2 0
    //   175: astore 11
    //   177: goto +4 -> 181
    //   180: pop
    //   181: aload 7
    //   183: aload 10
    //   185: aload 11
    //   187: invokevirtual 217	java/util/Properties:setProperty	(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
    //   190: pop
    //   191: aload 9
    //   193: invokeinterface 222 1 0
    //   198: ifne -80 -> 118
    //   201: aload_3
    //   202: aload 7
    //   204: invokeinterface 231 2 0
    //   209: pop
    //   210: iinc 4 1
    //   213: iload 4
    //   215: aload_0
    //   216: invokeinterface 227 1 0
    //   221: if_icmplt -201 -> 20
    //   224: aload_3
    //   225: areturn
    // Line number table:
    //   Java source line #137	-> byte code offset #0
    //   Java source line #138	-> byte code offset #14
    //   Java source line #139	-> byte code offset #20
    //   Java source line #140	-> byte code offset #33
    //   Java source line #141	-> byte code offset #42
    //   Java source line #142	-> byte code offset #51
    //   Java source line #144	-> byte code offset #54
    //   Java source line #145	-> byte code offset #65
    //   Java source line #146	-> byte code offset #72
    //   Java source line #147	-> byte code offset #77
    //   Java source line #149	-> byte code offset #82
    //   Java source line #150	-> byte code offset #87
    //   Java source line #153	-> byte code offset #91
    //   Java source line #147	-> byte code offset #94
    //   Java source line #149	-> byte code offset #99
    //   Java source line #150	-> byte code offset #104
    //   Java source line #154	-> byte code offset #108
    //   Java source line #155	-> byte code offset #115
    //   Java source line #156	-> byte code offset #118
    //   Java source line #158	-> byte code offset #130
    //   Java source line #159	-> byte code offset #139
    //   Java source line #160	-> byte code offset #147
    //   Java source line #162	-> byte code offset #155
    //   Java source line #163	-> byte code offset #166
    //   Java source line #164	-> byte code offset #177
    //   Java source line #166	-> byte code offset #181
    //   Java source line #155	-> byte code offset #191
    //   Java source line #168	-> byte code offset #201
    //   Java source line #138	-> byte code offset #210
    //   Java source line #170	-> byte code offset #224
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	226	0	fileNames	List
    //   0	226	1	base	String
    //   0	226	2	buildFileLocation	String
    //   13	212	3	allProperties	List
    //   15	199	4	i	int
    //   31	3	5	filename	String
    //   40	19	6	file	File
    //   49	154	7	props	java.util.Properties
    //   52	48	8	fis	java.io.FileInputStream
    //   75	17	9	localObject	Object
    //   113	79	9	propertyNames	java.util.Enumeration
    //   128	56	10	name	String
    //   137	49	11	value	String
    //   153	14	12	stringVariableManager	org.eclipse.core.variables.IStringVariableManager
    //   90	1	14	localIOException1	java.io.IOException
    //   107	1	15	localIOException2	java.io.IOException
    //   180	1	16	localCoreException	org.eclipse.core.runtime.CoreException
    // Exception table:
    //   from	to	target	type
    //   54	75	75	finally
    //   82	87	90	java/io/IOException
    //   99	104	107	java/io/IOException
    //   155	177	180	org/eclipse/core/runtime/CoreException
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.AntCoreUtil
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core;

import java.net.URL;
import org.eclipse.ant.core.IAntClasspathEntry;

public abstract class AntObject
{
  protected String fClassName;
  protected URL fLibrary;
  protected IAntClasspathEntry fLibraryEntry;
  protected String fName;
  private String fPluginLabel;
  private boolean eclipseRuntime = true;
  private String fURI = null;
  
  public String getClassName()
  {
    return fClassName;
  }
  
  public void setClassName(String className)
  {
    fClassName = className;
  }
  
  /**
   * @deprecated
   */
  public URL getLibrary()
  {
    if (fLibrary != null) {
      return fLibrary;
    }
    return fLibraryEntry.getEntryURL();
  }
  
  /**
   * @deprecated
   */
  public void setLibrary(URL library)
  {
    fLibrary = library;
  }
  
  public IAntClasspathEntry getLibraryEntry()
  {
    if (fLibraryEntry != null) {
      return fLibraryEntry;
    }
    fLibraryEntry = new AntClasspathEntry(fLibrary);
    return fLibraryEntry;
  }
  
  public void setLibraryEntry(IAntClasspathEntry libraryEntry)
  {
    fLibraryEntry = libraryEntry;
  }
  
  public String toString()
  {
    if ((fURI == null) || (fURI.equals("")) || (fURI.equals("antlib:org.apache.tools.ant"))) {
      return fName;
    }
    return fURI + ':' + fName;
  }
  
  public boolean isDefault()
  {
    return fPluginLabel != null;
  }
  
  /**
   * @deprecated
   */
  public void setIsDefault(boolean isDefault)
  {
    if (!isDefault) {
      fPluginLabel = null;
    }
  }
  
  public void setPluginLabel(String pluginLabel)
  {
    fPluginLabel = pluginLabel;
  }
  
  public String getPluginLabel()
  {
    return fPluginLabel;
  }
  
  public boolean isEclipseRuntimeRequired()
  {
    return eclipseRuntime;
  }
  
  public void setEclipseRuntimeRequired(boolean eclipseRuntime)
  {
    this.eclipseRuntime = eclipseRuntime;
  }
  
  public String getURI()
  {
    return fURI;
  }
  
  public void setURI(String uri)
  {
    fURI = uri;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.AntObject
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core;

import java.io.File;
import java.net.URL;
import org.eclipse.ant.core.AntCorePlugin;
import org.eclipse.ant.core.IAntPropertyValueProvider;
import org.eclipse.core.runtime.FileLocator;

public class AntPropertyValueProvider
  implements IAntPropertyValueProvider
{
  public String getAntPropertyValue(String propertyName)
  {
    String value = null;
    if ("eclipse.running".equals(propertyName)) {
      return "true";
    }
    if ("eclipse.home".equals(propertyName)) {
      try
      {
        value = new File(FileLocator.resolve(new URL("platform:/base/")).getPath()).getAbsolutePath();
        if (value.endsWith("/")) {
          value = value.substring(0, value.length() - 1);
        }
      }
      catch (Exception e)
      {
        AntCorePlugin.log(e);
      }
    }
    return value;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.AntPropertyValueProvider
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core;

import java.io.FileDescriptor;
import java.net.InetAddress;
import java.net.SocketPermission;
import java.security.Permission;
import java.util.PropertyPermission;
import org.eclipse.ant.core.AntSecurityException;

public class AntSecurityManager
  extends SecurityManager
{
  private SecurityManager fSecurityManager = null;
  private Thread fRestrictedThread = null;
  private static final PropertyPermission fgPropertyPermission = new PropertyPermission("*", "write");
  private boolean fAllowSettingSystemProperties = true;
  
  public AntSecurityManager(SecurityManager securityManager, Thread restrictedThread, boolean allowSettingProperties)
  {
    fSecurityManager = securityManager;
    fRestrictedThread = restrictedThread;
    fAllowSettingSystemProperties = allowSettingProperties;
  }
  
  public AntSecurityManager(SecurityManager securityManager, Thread restrictedThread)
  {
    this(securityManager, restrictedThread, true);
  }
  
  public void checkExit(int status)
  {
    if (Thread.currentThread() == fRestrictedThread) {
      throw new AntSecurityException();
    }
    if (fSecurityManager != null) {
      fSecurityManager.checkExit(status);
    }
  }
  
  public void checkAccept(String host, int port)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkAccept(host, port);
    }
  }
  
  public void checkAccess(Thread t)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkAccess(t);
    }
  }
  
  public void checkAccess(ThreadGroup g)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkAccess(g);
    }
  }
  
  public void checkAwtEventQueueAccess()
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkAwtEventQueueAccess();
    }
  }
  
  public void checkConnect(String host, int port, Object context)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkConnect(host, port, context);
    }
  }
  
  public void checkConnect(String host, int port)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkConnect(host, port);
    }
  }
  
  public void checkCreateClassLoader()
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkCreateClassLoader();
    }
  }
  
  public void checkDelete(String file)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkDelete(file);
    }
  }
  
  public void checkExec(String cmd)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkExec(cmd);
    }
  }
  
  public void checkLink(String lib)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkLink(lib);
    }
  }
  
  public void checkListen(int port)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkListen(port);
    }
  }
  
  public void checkMemberAccess(Class clazz, int which)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkMemberAccess(clazz, which);
    }
  }
  
  /**
   * @deprecated
   */
  public void checkMulticast(InetAddress maddr, byte ttl)
  {
    if (fSecurityManager != null)
    {
      String host = maddr.getHostAddress();
      if ((!host.startsWith("[")) && (host.indexOf(':') != -1)) {
        host = "[" + host + "]";
      }
      checkPermission(new SocketPermission(host, "accept,connect"));
    }
  }
  
  public void checkMulticast(InetAddress maddr)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkMulticast(maddr);
    }
  }
  
  public void checkPackageAccess(String pkg)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkPackageAccess(pkg);
    }
  }
  
  public void checkPackageDefinition(String pkg)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkPackageDefinition(pkg);
    }
  }
  
  public void checkPermission(Permission perm, Object context)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkPermission(perm, context);
    }
  }
  
  public void checkPermission(Permission perm)
  {
    if ((!fAllowSettingSystemProperties) && (fgPropertyPermission.implies(perm)) && (fRestrictedThread == Thread.currentThread())) {
      throw new AntSecurityException();
    }
    if (fSecurityManager != null) {
      fSecurityManager.checkPermission(perm);
    }
  }
  
  public void checkPrintJobAccess()
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkPrintJobAccess();
    }
  }
  
  public void checkPropertiesAccess()
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkPropertiesAccess();
    }
    super.checkPropertiesAccess();
  }
  
  public void checkPropertyAccess(String key)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkPropertyAccess(key);
    }
  }
  
  public void checkRead(FileDescriptor fd)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkRead(fd);
    }
  }
  
  public void checkRead(String file, Object context)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkRead(file, context);
    }
  }
  
  public void checkRead(String file)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkRead(file);
    }
  }
  
  public void checkSecurityAccess(String target)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkSecurityAccess(target);
    }
  }
  
  public void checkSetFactory()
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkSetFactory();
    }
  }
  
  public void checkSystemClipboardAccess()
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkSystemClipboardAccess();
    }
  }
  
  public boolean checkTopLevelWindow(Object window)
  {
    if (fSecurityManager != null) {
      return fSecurityManager.checkTopLevelWindow(window);
    }
    return super.checkTopLevelWindow(window);
  }
  
  public void checkWrite(FileDescriptor fd)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkWrite(fd);
    }
  }
  
  public void checkWrite(String file)
  {
    if (fSecurityManager != null) {
      fSecurityManager.checkWrite(file);
    }
  }
  
  /**
   * @deprecated
   */
  public boolean getInCheck()
  {
    if (fSecurityManager != null) {
      return fSecurityManager.getInCheck();
    }
    return super.getInCheck();
  }
  
  public Object getSecurityContext()
  {
    if (fSecurityManager != null) {
      return fSecurityManager.getSecurityContext();
    }
    return super.getSecurityContext();
  }
  
  public ThreadGroup getThreadGroup()
  {
    if (fSecurityManager != null) {
      fSecurityManager.getThreadGroup();
    }
    return super.getThreadGroup();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.AntSecurityManager
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core;

public abstract interface IAntCoreConstants
{
  public static final String DEFAULT_BUILD_FILENAME = "build.xml";
  public static final String PREFERENCE_TASKS = "tasks";
  public static final String PREFERENCE_TYPES = "types";
  public static final String PREFIX_TASK = "task.";
  public static final String PREFIX_TYPE = "type.";
  public static final String PREFERENCE_ANT_HOME_ENTRIES = "ant_home_entries";
  public static final String PREFERENCE_ADDITIONAL_ENTRIES = "additional_entries";
  public static final String PREFERENCE_CLASSPATH_CHANGED = "classpath_changed";
  public static final String PREFERENCE_ANT_HOME = "ant_home";
  public static final String PREFERENCE_PROPERTIES = "properties";
  public static final String PREFERENCE_PROPERTY_FILES = "propertyfiles";
  public static final String PREFIX_PROPERTY = "property.";
  public static final String ID = "id";
  public static final String AUGMENT = "augment";
  public static final String DEFAULT = "default";
  public static final String DIR = "dir";
  public static final String EMPTY_STRING = "";
  public static final String FILE = "file";
  public static final String FILE_PROTOCOL = "file:";
  public static final String NAME = "name";
  public static final String VALUE = "value";
  public static final String DESCRIPTION = "description";
  public static final String UTF_8 = "UTF-8";
  public static final String XML_EXTENSION = "xml";
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.IAntCoreConstants
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core;

import org.eclipse.osgi.util.NLS;

public class InternalCoreAntMessages
  extends NLS
{
  private static final String BUNDLE_NAME = "org.eclipse.ant.internal.core.InternalCoreAntMessages";
  public static String AntCorePreferences_Malformed_URL__1;
  public static String AntCorePreferences_Library_not_specified_for___0__4;
  public static String AntCorePreferences_No_library_for_task;
  public static String AntCorePreferences_No_library_for_type;
  public static String AntCorePreferences_8;
  public static String AntCorePreferences_6;
  public static String AntCorePreferences_0;
  public static String AntCorePreferences_1;
  public static String AntRunner_Could_not_find_one_or_more_classes__Please_check_the_Ant_classpath__1;
  public static String AntRunner_Could_not_find_one_or_more_classes__Please_check_the_Ant_classpath__2;
  public static String AntRunner_Build_Failed__3;
  public static String AntRunner_Already_in_progess;
  
  static
  {
    NLS.initializeMessages("org.eclipse.ant.internal.core.InternalCoreAntMessages", InternalCoreAntMessages.class);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.InternalCoreAntMessages
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core.contentDescriber;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import javax.xml.parsers.ParserConfigurationException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExecutableExtension;
import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.core.runtime.content.XMLContentDescriber;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

public final class AntBuildfileContentDescriber
  extends XMLContentDescriber
  implements IExecutableExtension
{
  private int checkCriteria(InputSource contents)
    throws IOException
  {
    AntHandler antHandler = new AntHandler();
    try
    {
      if (!antHandler.parseContents(contents)) {
        return 1;
      }
    }
    catch (SAXException localSAXException)
    {
      return 1;
    }
    catch (ParserConfigurationException localParserConfigurationException)
    {
      String message = "Internal Error: XML parser configuration error during content description for Ant buildfiles";
      throw new RuntimeException(message);
    }
    if (antHandler.hasRootProjectElement())
    {
      if ((antHandler.hasProjectDefaultAttribute()) || (antHandler.hasTargetElement()) || (antHandler.hasAntElement())) {
        return 2;
      }
      return 1;
    }
    return 1;
  }
  
  public int describe(InputStream contents, IContentDescription description)
    throws IOException
  {
    if (super.describe(contents, description) == 0) {
      return 0;
    }
    contents.reset();
    
    return checkCriteria(new InputSource(contents));
  }
  
  public int describe(Reader contents, IContentDescription description)
    throws IOException
  {
    if (super.describe(contents, description) == 0) {
      return 0;
    }
    contents.reset();
    
    return checkCriteria(new InputSource(contents));
  }
  
  public void setInitializationData(IConfigurationElement config, String propertyName, Object data)
    throws CoreException
  {}
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.contentDescriber.AntBuildfileContentDescriber
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core.contentDescriber;

import org.xml.sax.SAXException;

class AntHandler$StopParsingException
  extends SAXException
{
  private static final long serialVersionUID = 1L;
  final AntHandler this$0;
  
  public AntHandler$StopParsingException(AntHandler paramAntHandler)
  {
    super(null);
    this$0 = paramAntHandler;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.contentDescriber.AntHandler.StopParsingException
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ant.internal.core.contentDescriber;

import java.io.IOException;
import java.io.StringReader;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

public final class AntHandler
  extends DefaultHandler
{
  private static final String PROJECT = "project";
  private static final String TARGET = "target";
  private static final String MACRODEF = "macrodef";
  private static final String TASKDEF = "taskdef";
  private static final String TYPEDEF = "typedef";
  private static final String PROPERTY = "property";
  private static final String CLASSPATH = "classpath";
  private static final String PATH = "path";
  private static final String IMPORT = "import";
  
  private class StopParsingException
    extends SAXException
  {
    private static final long serialVersionUID = 1L;
    
    public StopParsingException()
    {
      super();
    }
  }
  
  private String fTopElementFound = null;
  private SAXParserFactory fFactory;
  private boolean fDefaultAttributeFound = false;
  private boolean fTargetFound = false;
  private boolean fAntElementFound = false;
  private int fLevel = -1;
  
  private final SAXParser createParser(SAXParserFactory parserFactory)
    throws ParserConfigurationException, SAXException, SAXNotRecognizedException, SAXNotSupportedException
  {
    SAXParser parser = parserFactory.newSAXParser();
    XMLReader reader = parser.getXMLReader();
    try
    {
      reader.setFeature("http://xml.org/sax/features/validation", false);
      reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
    }
    catch (SAXNotRecognizedException localSAXNotRecognizedException) {}catch (SAXNotSupportedException localSAXNotSupportedException) {}
    return parser;
  }
  
  private SAXParserFactory getFactory()
  {
    synchronized (this)
    {
      if (fFactory != null) {
        return fFactory;
      }
      fFactory = SAXParserFactory.newInstance();
      fFactory.setNamespaceAware(true);
    }
    return fFactory;
  }
  
  protected boolean parseContents(InputSource contents)
    throws IOException, ParserConfigurationException, SAXException
  {
    try
    {
      fFactory = getFactory();
      if (fFactory == null) {
        return false;
      }
      SAXParser parser = createParser(fFactory);
      
      contents.setSystemId("/");
      parser.parse(contents, this);
    }
    catch (StopParsingException localStopParsingException) {}
    return true;
  }
  
  public InputSource resolveEntity(String publicId, String systemId)
    throws SAXException
  {
    return new InputSource(new StringReader(""));
  }
  
  public final void startElement(String uri, String elementName, String qualifiedName, Attributes attributes)
    throws SAXException
  {
    fLevel += 1;
    if (fTopElementFound == null)
    {
      fTopElementFound = elementName;
      if (!hasRootProjectElement()) {
        throw new StopParsingException();
      }
      if (attributes != null)
      {
        fDefaultAttributeFound = (attributes.getValue("default") != null);
        if (fDefaultAttributeFound) {
          throw new StopParsingException();
        }
      }
    }
    if ((fLevel == 1) && ("target".equals(elementName)))
    {
      fTargetFound = true;
      throw new StopParsingException();
    }
    if ((fLevel == 1) && (("macrodef".equals(elementName)) || 
      ("taskdef".equals(elementName)) || ("typedef".equals(elementName)) || 
      ("property".equals(elementName)) || ("classpath".equals(elementName)) || 
      ("path".equals(elementName)) || ("import".equals(elementName))))
    {
      fAntElementFound = true;
      throw new StopParsingException();
    }
  }
  
  public void endElement(String uri, String localName, String qName)
    throws SAXException
  {
    super.endElement(uri, localName, qName);
    fLevel -= 1;
  }
  
  protected boolean hasProjectDefaultAttribute()
  {
    return fDefaultAttributeFound;
  }
  
  protected boolean hasRootProjectElement()
  {
    return "project".equals(fTopElementFound);
  }
  
  protected boolean hasTargetElement()
  {
    return fTargetFound;
  }
  
  protected boolean hasAntElement()
  {
    return fAntElementFound;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ant.internal.core.contentDescriber.AntHandler
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
1 2 3 4

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd