package abbot;

 import java.io.*;

 import java.lang.reflect.InvocationTargetException;

 import java.util.*;

 import javax.swing.SwingUtilities;

 /**

    Various logging, assertion, and debug routines.  Typical usage is to

    include the following code

    <blockquote><code><pre>

    public static void main(String[] args) {

   args = Log.init(args)

   ...

    }

    </pre></code></blockquote>

    at an application's main entry point.  This way the Log class can remove its

    options from the full set passed into the application.  See the

    {@link #init(String[]) Log.init} method for initialization

    options. <p>

    General usage notes on public functions:<p>

    <ul>

    <li><b>warn</b><br>

    Programmer warnings; things that you think shouldn't be happening or

    indicate something might be wrong.  Warnings typically mean "Something

    happened that I didn't expect would happen".<p>

    <li><b>log</b><br>

    Important information that might be needed for later reference; things the

    user or debugger might be interested in.  By default, all messages go

    here.  Logs are made available so that the customer may provide us with an 

    accurate record of software activity.<br>

    All warnings and failed assertions are written to the log.  Debug

    statements are also written to log in non-release code.<p>

    <li><b>debug</b><br> 

    Any messages which might be useful for debugging (non-release code

    only).<p> 

    <li><b>assertTrue</b><br> 

    Assumed preconditions for proper execution, also referred to as

    invariants.<p>

    </ul>

    <p>

    Per-class stack trace depth can be specified when adding a class, e.g.

    classname[:stack-depth].<p>

    @author      twall

    @version     $Revision: 1.26 $

 */

     /** No instantiations. */

     /** Global final to determine whether debugging code is generated.  This

         should be changed to false to build production code. */ 

     public static final boolean DEBUG_BUILD = true;

     /** Mnemonic to print all lines of a stack trace. */

     public static final int FULL_STACK = 0;

     /** Mnemonic to print the default number of lines of stack trace. */

     private static final int CLASS_STACK_DEPTH = -1;

     /** Basic warning categories.  FIXME use these. 

     public static final int ERROR   = 0x0001;

     public static final int WARNING = 0x0002;

     public static final int DEBUG   = 0x0004;

     public static final int INFO    = 0x0008;*/

     /** Synchronize message output. */

     private static LogSynchronizer synchronizer = new LogSynchronizer();

     /** Whether any debugging output is enabled. */

     public static boolean expectDebugOutput;

     /** Enable assert checks. */

     private static boolean assertChecks = DEBUG_BUILD;

     /** Whether to terminate on assertion failures. */

     private static boolean exitOnAssertionFailure = false;

     /** Whether to log messages. Default on so that we capture output until

      * the log file has been set or not set in {@link #init(String[])}.

      */

     private static boolean logMessages = true;

     /** Whether to print programmer warnings. */

     private static boolean printConsoleWarnings = DEBUG_BUILD;

     /** Whether to show threads in debug output. */

     private static boolean showThreads;

     /** Default number of lines of stack trace to print. */

     private static int debugStackDepth = 1;

     /** Default number of lines of exception stack trace to print. */

     private static int excStackDepth = FULL_STACK;

     /** Show timestamps in the log? */

     private static boolean showTimestamp = true;

     private static java.text.DateFormat timestampFormat =

         new java.text.SimpleDateFormat("yyMMdd HH:mm:ss:SSS ");

     /** Strip this out of output, since it doesn't add information to see it

         repeatedly.  Some projects have <i>really</i> long prefixes. */

     private static final String COMMON_PREFIX = null;

     /** Store which classes we want to see debug info for.  FIXME make it a

         map and make the value the debug level. */

     private static HashMap debugged = new HashMap();

     /** Store which classes we don't want to see debug info for */

     private static HashSet notdebugged = new HashSet();

     /** Debug all classes? */

     private static boolean debugAll;

     /** Treat inner/anonymous classes as outer class? */

     private static boolean debugInner = true;

     private static final String DEFAULT_LOGFILE_NAME = "abbot.log";

     private static ByteArrayOutputStream preInitLog =

         new ByteArrayOutputStream();

     private static PrintStream log = new PrintStream(preInitLog);

     // Save these for future use

     static PrintStream systemOut = System.out;

     static PrintStream systemErr = System.err;

     /** Debug/log initialization, presumably from the command line. 

         <br>Recognized options:

         <pre>

         --debug all | className[:depth] | *.partialClassName[:depth]

         --no-debug className | *.partialClassName

         --log <log file name>

         --no-timestamp

         --enable-warnings

         --show-threads

         --stack-depth <depth>

         --exception-depth <depth>

         </pre>

      */

         // Redirect System.err & System.out

         }

         });

     }

             }

             }

             }

                     }

                     catch(Exception exc) {

                     }

                 }

                 else {

                 }

             }

                     }

                     catch(Exception exc) {

                     }

                 }

                 else {

                 }

             }

                      || args[i].equals("--no-debug")) {

                 // since we're enabling some debugging, set the other settings

                 // to debug defaults...

                 // Re-enable stdout/stderr if they were removed

                 }

                     else

                 }

                 else {

                                  + " with no argument");

                 }

             }

             }

             else {

             }

         }

         }

     }

     /** Is log output enabled? */

     }

     /** Enable log output to the given file.  If the filename given is "-",

      * stdout is used instead of a file.

      */

             else

                                       true);

                     getLocalHost().getHostName(); 

             }

             catch(java.net.UnknownHostException uhe) { 

             }

                 // Prefer output to go to the log on a release build, since

                 // there may not be any console.

                                       + "file for debug output.");

                 }

             }

             // Make sure the log gets closed on System.exit

             });

         }

         catch (FileNotFoundException exc){

         }

     }

     /** Sets the debug stack depth to the given amount */

     }

     /** Indicate the class name to exclude from debug output. */

     }

     /** Indicate that the given class should NOT be debugged 

         (assuming --debug all) */

     }

     /** Indicate the class name[:depth] to add to debug output. */

     }

     /** Indicate the class to add to debug output. */

     }

     /** Indicate that debug messages should be output for the given class. */

     }

     /** Parse the given string, which may should be of the format

         "class[:depth]" */

             }

             else {

             }

         }

         else {

                         ? debugStackDepth 

                         : Integer.parseInt(id.substring(colon+1));

                     else

                 }

                 catch (NumberFormatException nfe) {

                     else 

                 }

             }

             catch (ClassNotFoundException exc){

             }

         }

     }

     /** Returns class from given name/descriptor.  Descriptor can be either a

         fully qualified classname, or a classname beginning with *. with

         client-specific package and classname following.

     */

         throws ClassNotFoundException {

         }

     }

     /** Return the requested number of levels of stack trace, not including

         this call.   Returns the full stack trace if LINES is FULL_STACK.

         Skip the first POP frames of the trace, which is for excluding the

         innermost stack frames when debug functions make nested calls.

         The outermost call of getStackTrace itself is always removed from the

         trace.  */ 

     }

     /** Return the requested number of levels of stack trace, not including

         this call.   Returns the full stack trace if LINES is FULL_STACK.

         Skip the first POP frames of the trace, which is for excluding the

         innermost stack frames when debug functions make nested calls.

         The outermost call of getStackTrace itself is always removed from the

         trace.   Provide an exception to use for the stack trace,

         rather than using the current program location.

     */

     }

     /** Return the stack trace contained in the given Throwable.

         Skip the first POP frames of the trace, which is for excluding the

         innermost stack frames when debug functions make nested calls.

         The outermost call of getStackTrace itself is always removed from the

         trace.   

     */