dsstrace.java

derby database source code.good for you.

                                         String className,
                                         String methodName,
                                         int trcPt)
  {
    // why don't we synchronize the method!!!

    // Grab the lock to make sure another thread doesn't try to
    // write data or close the writer.
    synchronized (comBufferSync) {

      // Only take action if the trace is on.
      if (comBufferTraceOn) {

        // Obtain an instance of the Calendar so a timestamp can be written.
        // this call seems to slow things down a bit.
        java.util.Calendar time = java.util.Calendar.getInstance();

        // Print the timestamp, class name, method name, thread name, and tracepoint.
        comBufferWriter.println ("       (" +
                                 time.get (java.util.Calendar.YEAR) +
                                 "." +
                                 (time.get (java.util.Calendar.MONTH) + 1) +
                                 "." +
                                 time.get (java.util.Calendar.DAY_OF_MONTH) +
                                 " " +
                                 time.get (java.util.Calendar.HOUR_OF_DAY) +
                                 ":" +
                                 time.get (java.util.Calendar.MINUTE) +
                                 ":" +
                                 time.get (java.util.Calendar.SECOND) +
                                 ") " +
                                 className +
                                 " " +
                                 methodName +
                                 " " +
                                 Thread.currentThread().getName() +
                                 " " +
                                 trcPt);

        // A newline is added for formatting.
        comBufferWriter.println();

        // The data will only be written if there is a non-zero positive length.
        if (len != 0) {
          String codePointName = null;
          // If the length <= 10, lookup the first codepoint so it's name can be printed???
          if (len >= 10) {
            // Get the int value of the two byte unsigned codepoint.
            int codePoint = getCodePoint (buff, offset+8);
            codePointName = codePointNameTable.lookup (codePoint);
          }

          if (codePointName == null) {
            // codePointName was still null so either < 10 bytes were given or
            // the codepoint wasn't found in the table.  Just print the plain send header.
            comBufferWriter.println (getHeader (type));
          }
          else {
            // codePointName isn't null so the name of the codepoint will be printed.
            printHeaderWithCodePointName (codePointName, type);
          }

          // Print the col position header in the trace.
          comBufferWriter.println (colPosHeader);

          // A char array will be used to translate the bytes to their character
          // representations along with ascii and ebcdic representations.
          char trcDump[] = new char[77];

          // bCounter, aCounter, eCounter are offsets used to help position the characters
          short bCounter = 7;
          short aCounter = 43;
          short eCounter = 61;

          // The lines will be counted starting at zero.  This is hard coded since we are
          // at the beginning.
          trcDump[0] = DssTrace.zeroChar;
          trcDump[1] = DssTrace.zeroChar;
          trcDump[2] = DssTrace.zeroChar;
          trcDump[3] = DssTrace.zeroChar;

          // The 0's are already in the trace so bump the line counter up a row.
          int lineCounter = 0x10;

          // Make sure the character array has all blanks in it.
          // Some of these blanks will be replaced later with values.
          // The 0's were not wrote over.
          for (int j = 4; j < 77; j++) {
            trcDump[j] = DssTrace.spaceChar;
          }

          // i will maintain the position in the byte array to be traced.
          int i = 0;

          do {
            // Get the unsigned value of the byte.
            //                  int num = b[off++] & 0xff;
            int num = (buff[offset] < 0)? buff[offset] + 256 : buff[offset]; // jev
            offset++;
            i++;
            // Place the characters representing the bytes in the array.
            trcDump[bCounter++] = DssTrace.hexDigit[((num >>> 4) & 0xf)];
            trcDump[bCounter++] = DssTrace.hexDigit[(num & 0xf)];

            // Place the ascii and ebcdc representations in the array.
            trcDump[aCounter++] = DssTrace.asciiChar[num];
            trcDump[eCounter++] = DssTrace.ebcdicChar[num];

            if (((i%8) == 0)) {
              if (((i%16) == 0)) {
                // Print the array each time 16 bytes are processed.
                comBufferWriter.println (trcDump);
                if (i != len) {
                  // Not yet at the end of the byte array.
                  if ((len - i) < 16) {
                    // This is the last line so blank it all out.
                    // This keeps the last line looking pretty in case
                    // < 16 bytes remain.
                    for (int j = 0; j < trcDump.length; j++) {
                      trcDump[j] = DssTrace.spaceChar;
                    }
                  }
                  // Reset the counters.
                  bCounter = 0;
                  aCounter = 43;
                  eCounter = 61;
                  // Reset the lineCounter if it starts to get too large.
                  if (lineCounter == 0xfff0) {
                    lineCounter = 0;
                  }
                  // Place the characters representing the line counter in the array.
                  trcDump[bCounter++] = DssTrace.hexDigit[((lineCounter >>> 12) & 0xf)];
                  trcDump[bCounter++] = DssTrace.hexDigit[((lineCounter >>> 8) & 0xf)];
                  trcDump[bCounter++] = DssTrace.hexDigit[((lineCounter >>> 4) & 0xf)];
                  trcDump[bCounter++] = DssTrace.hexDigit[(lineCounter & 0xf)];
                  bCounter += 3;
                  // Bump up the line counter.
                  lineCounter += 0x10;
                }
              }
              else {
                // 8 bytes were processed so move the counter to adjust for
                // spaces between the columns of bytes.
                bCounter += 2;
              }
            }
            // do this until we all the data has been traced.
          } while (i < len);

          // print the last line and add some blank lines to make it easier to read.
          if (len % 16 != 0) {
            comBufferWriter.println (trcDump);
          }
          comBufferWriter.println();
          comBufferWriter.println();
        }
        // Flush the writer.
        comBufferWriter.flush();
      }
    }
  }

  // Gets the int value of the two byte unsigned codepoint.
  private static int getCodePoint (byte[] buff, int offset)
  {
    return ((buff[offset++] & 0xff) << 8) +
      ((buff[offset] & 0xff) << 0);
  }

  private static String getHeader (int type)
  {
    switch (type) {
    case DssTrace.TYPE_TRACE_SEND:
      return DssTrace.sendHeader;
    case DssTrace.TYPE_TRACE_RECEIVE:
      return DssTrace.receiveHeader;
    default:
      //  throw new !!!
      return null;
    }
  }

  private static int getStartPosition (int type)
  {
    switch (type) {
    case DssTrace.TYPE_TRACE_SEND:
      return 20; // This is right after 'SEND BUFFER: '.
    case DssTrace.TYPE_TRACE_RECEIVE:
      return 23; // This is right after 'RECEIVE BUFFER: '.
    default:
      //  throw new !!!
      return 0;
    }
  }

  private void printHeaderWithCodePointName (String codePointName, int type)
  {
    // Create a char array so some of the characters
    // can be replaced with the name of the codepoint.
    char headerArray[] = DssTrace.getHeader(type).toCharArray();

    // At most, 16 character name will be used.  This is so
    // the headers on top of the ascii and ebcdic rows aren't shifted.
    int replaceLen = (codePointName.length() < 17) ? codePointName.length() : 16;

    int offset = getStartPosition (type);
    for (int i = 0; i < replaceLen; i++) {
      headerArray[offset++] = codePointName.charAt (i); // make sure charAt() starts at 0!!!
    }
    comBufferWriter.println (headerArray);
  }

}