--- /home/cpdev/src/classpath/gnu/java/security/x509/X509Certificate.java	2005-07-11 05:32:31.000000000 +0000
+++ gnu/java/security/x509/X509Certificate.java	2005-06-30 05:34:12.000000000 +0000
@@ -38,9 +38,6 @@
 
 package gnu.java.security.x509;
 
-import gnu.classpath.debug.Component;
-import gnu.classpath.debug.SystemLogger;
-
 import gnu.java.security.OID;
 import gnu.java.security.der.BitString;
 import gnu.java.security.der.DER;
@@ -89,9 +86,6 @@
 import java.util.Map;
 import java.util.Set;
 
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
 import javax.security.auth.x500.X500Principal;
 
 /**
@@ -106,7 +100,23 @@
   // Constants and fields.
   // ------------------------------------------------------------------------
 
-  private static final Logger logger = SystemLogger.SYSTEM;
+  private static final boolean DEBUG = false;
+  private static void debug(String msg)
+  {
+    if (DEBUG)
+      {
+        System.err.print(">> X509Certificate: ");
+        System.err.println(msg);
+      }
+  }
+  private static void debug(Throwable t)
+  {
+    if (DEBUG)
+      {
+        System.err.print(">> X509Certificate: ");
+        t.printStackTrace();
+      }
+  }
 
   protected static final OID ID_DSA = new OID ("1.2.840.10040.4.1");
   protected static final OID ID_DSA_WITH_SHA1 = new OID ("1.2.840.10040.4.3");
@@ -167,12 +177,12 @@
       }
     catch (IOException ioe)
       {
-        logger.log (Component.X509, "", ioe);
+        debug(ioe);
         throw ioe;
       }
     catch (Exception e)
       {
-        logger.log (Component.X509, "", e);
+        debug(e);
         CertificateException ce = new CertificateException(e.getMessage());
         ce.initCause (e);
         throw ce;
@@ -533,8 +543,7 @@
   private void doVerify(Signature sig, PublicKey key)
     throws CertificateException, InvalidKeyException, SignatureException
   {
-    logger.log (Component.X509, "verifying sig={0} key={1}",
-                new Object[] { sig, key });
+    debug("verifying sig=" + sig + " key=" + key);
     sig.initVerify(key);
     sig.update(tbsCertBytes);
     if (!sig.verify(signature))
@@ -554,8 +563,7 @@
 
     // Certificate ::= SEQUENCE {
     DERValue cert = der.read();
-    logger.log (Component.X509, "start Certificate  len == {0}",
-                new Integer (cert.getLength()));
+    debug("start Certificate  len == " + cert.getLength());
 
     this.encoded = cert.getEncoded();
     if (!cert.isConstructed())
@@ -570,8 +578,7 @@
         throw new IOException("malformed TBSCertificate");
       }
     tbsCertBytes = tbsCert.getEncoded();
-    logger.log (Component.X509, "start TBSCertificate  len == {0}",
-                new Integer (tbsCert.getLength()));
+    debug("start TBSCertificate  len == " + tbsCert.getLength());
 
     // Version ::= INTEGER [0] { v1(0), v2(1), v3(2) }
     DERValue val = der.read();
@@ -584,12 +591,11 @@
       {
         version = 1;
       }
-    logger.log (Component.X509, "read version == {0}",
-                new Integer (version));
+    debug("read version == " + version);
 
     // SerialNumber ::= INTEGER
     serialNo = (BigInteger) val.getValue();
-    logger.log (Component.X509, "read serial number == {0}", serialNo);
+    debug("read serial number == " + serialNo);
 
     // AlgorithmIdentifier ::= SEQUENCE {
     val = der.read();
@@ -598,13 +604,12 @@
         throw new IOException("malformed AlgorithmIdentifier");
       }
     int certAlgLen = val.getLength();
-    logger.log (Component.X509, "start AlgorithmIdentifier  len == {0}",
-                new Integer (certAlgLen));
+    debug("start AlgorithmIdentifier  len == " + certAlgLen);
     val = der.read();
 
     //   algorithm    OBJECT IDENTIFIER,
     algId = (OID) val.getValue();
-    logger.log (Component.X509, "read algorithm ID == {0}", algId);
+    debug("read algorithm ID == " + algId);
 
     //   parameters   ANY DEFINED BY algorithm OPTIONAL }
     if (certAlgLen > val.getEncodedLength())
@@ -617,18 +622,18 @@
         else
           {
             algVal = val.getEncoded();
-
-            if (val.isConstructed())
-              encoded.skip(val.getLength());
+	    
+	    if (val.isConstructed())
+	      encoded.skip(val.getLength());
           }
-        logger.log (Component.X509, "read algorithm parameters == {0}", algVal);
+        debug("read algorithm parameters == " + algVal);
       }
 
     // issuer   Name,
     val = der.read();
     issuer = new X500DistinguishedName(val.getEncoded());
     der.skip(val.getLength());
-    logger.log (Component.X509, "read issuer == {0}", issuer);
+    debug("read issuer == " + issuer);
 
     // Validity ::= SEQUENCE {
     //   notBefore   Time,
@@ -638,15 +643,15 @@
         throw new IOException("malformed Validity");
       }
     notBefore = (Date) der.read().getValue();
-    logger.log (Component.X509, "read notBefore == {0}", notBefore);
     notAfter  = (Date) der.read().getValue();
-    logger.log (Component.X509, "read notAfter == {0}", notAfter);
+    debug("read notBefore == " + notBefore);
+    debug("read notAfter == " + notAfter);
 
     // subject   Name,
     val = der.read();
     subject = new X500DistinguishedName(val.getEncoded());
     der.skip(val.getLength());
-    logger.log (Component.X509, "read subject == {0}", subject);
+    debug("read subject == " + subject);
 
     // SubjectPublicKeyInfo ::= SEQUENCE {
     //   algorithm         AlgorithmIdentifier,
@@ -659,7 +664,7 @@
     KeyFactory spkFac = KeyFactory.getInstance("X.509");
     subjectKey = spkFac.generatePublic(new X509EncodedKeySpec(spki.getEncoded()));
     der.skip(spki.getLength());
-    logger.log (Component.X509, "read subjectPublicKey == {0}", subjectKey);
+    debug("read subjectPublicKey == " + subjectKey);
 
     if (version > 1)
       {
@@ -669,50 +674,43 @@
       {
         byte[] b = (byte[]) val.getValue();
         issuerUniqueId = new BitString(b, 1, b.length-1, b[0] & 0xFF);
-        logger.log (Component.X509, "read issuerUniqueId == {0}", issuerUniqueId);
+        debug("read issuerUniqueId == " + issuerUniqueId);
         val = der.read();
       }
     if (version >= 2 && val.getTagClass() != DER.UNIVERSAL && val.getTag() == 2)
       {
         byte[] b = (byte[]) val.getValue();
         subjectUniqueId = new BitString(b, 1, b.length-1, b[0] & 0xFF);
-        logger.log (Component.X509, "read subjectUniqueId == {0}", subjectUniqueId);
+        debug("read subjectUniqueId == " + subjectUniqueId);
         val = der.read();
       }
     if (version >= 3 && val.getTagClass() != DER.UNIVERSAL && val.getTag() == 3)
       {
         val = der.read();
-        logger.log (Component.X509, "start Extensions  len == {0}",
-                    new Integer (val.getLength()));
+        debug("start Extensions  len == " + val.getLength());
         int len = 0;
         while (len < val.getLength())
           {
             DERValue ext = der.read();
-            logger.log (Component.X509, "start extension  len == {0}",
-                        new Integer (ext.getLength()));
+            debug("start extension  len == " + ext.getLength());
             Extension e = new Extension(ext.getEncoded());
             extensions.put(e.getOid(), e);
             der.skip(ext.getLength());
             len += ext.getEncodedLength();
-            logger.log (Component.X509, "read extension {0} == {1}",
-                        new Object[] { e.getOid (), e });
-            logger.log (Component.X509, "count == {0}", new Integer (len));
+            debug("count == " + len);
           }
-
-        val = der.read ();
       }
 
-    logger.log (Component.X509, "read value {0}", val);
+    val = der.read();
     if (!val.isConstructed())
       {
-        throw new CertificateException ("malformed AlgorithmIdentifier");
+        throw new IOException("malformed AlgorithmIdentifier");
       }
     int sigAlgLen = val.getLength();
-    logger.log (Component.X509, "start AlgorithmIdentifier  len == {0}",
-                new Integer (sigAlgLen));
+    debug("start AlgorithmIdentifier  len == " + sigAlgLen);
     val = der.read();
     sigAlgId = (OID) val.getValue();
-    logger.log (Component.X509, "read algorithm id == {0}", sigAlgId);
+    debug("read algorithm id == " + sigAlgId);
     if (sigAlgLen > val.getEncodedLength())
       {
         val = der.read();
@@ -737,9 +735,9 @@
           {
             encoded.skip(val.getLength());
           }
-        logger.log (Component.X509, "read parameters == {0}", sigAlgVal);
+        debug("read parameters == " + sigAlgVal);
       }
     signature = ((BitString) der.read().getValue()).toByteArray();
-    logger.log (Component.X509, "read signature ==\n{0}", Util.hexDump(signature, ">>>> "));
+    debug("read signature ==\n" + Util.hexDump(signature, ">>>> "));
   }
 }
