ng on here, so here's the problem report output from
my program:

A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'Crypto.calculateProbableKeyLength (Ljava/lang/StringBuffer;)I': Interpreting
method.
  Please report this error in detail to http://java.sun.com/cgi-
bin/bugreport.cgi


And here is the code that reproduces the error, in two classes. Sorry it's
long, but I don't know why the error occurs.



/**
 * The class containing a main method which cracks the
 * polyalphabetic Vigniere cipher fed in as the standard input.
 * @author Ian Howlett - ###@###.###.
 */
 
class Crack {
    public static void main(String[] parameter){
Test tester = new Test ();
tester.doItAll ();
    }
}


class Test {
public void doItAll () {

// Introduction
System.out.println ("Cryptography Assessment 1 - Ian Howlett -
###@###.###");
System.out.println ();

// Step 1 - Read in the ciphertext
System.out.print ("Step 1...");
StringBuffer cipherText = Crypto.readStandardInput();
System.out.println ("COMPLETE");
System.out.println ("cipherText: " + cipherText.toString());
System.out.println ();
System.out.println ();

//Step 2 - Remove non-alphabetic characters
System.out.print ("Step 2...");
cipherText = Crypto.removeNonAlphabeticChars (cipherText);
System.out.println ("COMPLETE");
System.out.println ("cipherText: " + cipherText.toString());
System.out.println ();
System.out.println ();

// Step 3 - Compute Average Index of Coincidence
System.out.print ("Step 3...");
int keyLength = Crypto.calculateProbableKeyLength (cipherText);
System.out.println ("COMPLETE");
System.out.println ("Keylength = " + keyLength);
System.out.println ();
System.out.println ();

// Step 4 - Generate actual keyword
System.out.print ("Step 4...");
StringBuffer keyword = Crypto.generateActualKeyword
(cipherText, keyLength);
System.out.println ("COMPLETE");
System.out.println ("keyword = " + keyword.toString());
System.out.println ();
System.out.println ();

// Step 5 - Unscramble the message
System.out.print ("Step 5...");
String message = Crypto.unscrambleMessage (cipherText, keyword);
System.out.println ("COMPLETE");
System.out.println ("The plaintext is as follows:");
System.out.println (message);
}
}






import java.io.*;
class Crypto {

/**
* p: The probability of a letter occuring in English text.
*/
public static double[] p = { 0.078, // A
0.014,
// B
0.031,
// C
0.040,
// D
0.128,
// E
0.024,
// F
0.017,
// G
0.052,
// H
0.071,
// I
0.002,
// J
0.005,
// K
0.038,
// L
0.027,
// M
0.072,
// N
0.077,
// O
0.023,
// P
0.002,
// Q
0.066,
// R
0.065,
// S
0.091,
// T
0.028,
// U
0.010,
// V
0.017,
// W
0.003,
// X
0.018,
// Y
0.001,
// Z
};


/**
* Reads the input from the standard input.
*/
public static StringBuffer readStandardInput () {
BufferedReader br = new BufferedReader(new FileReader
(FileDescriptor.in));
try {
// The StringBuffer sb holds the entire string read
from the standard input
StringBuffer sb = new StringBuffer();
// The String s holds a single line of text temporarily
String s = br.readLine();
// Loop and read all the text into the StringBuffer sb
while (s != null) {
sb.append (s);
s = br.readLine();
}
return sb;
}
catch (IOException e) {
// If there was a problem then inform the user
System.out.println("Exception reading String: " + e
+ "\n");
return null;
}
}

/**
* Removes non-alphabetic characters from the String
* held in the StringBuffer object passed in.
*/
public static StringBuffer removeNonAlphabeticChars (StringBuffer sb) {
for (int i = 0; i < sb.length(); i++) {
if (!Character.isLetter (sb.charAt(i))) sb.deleteCharAt
(i);
}
return sb;
}

/**
* Calculates the probable key length by computing the
* average index of coincidence.
*/
public static int calculateProbableKeyLength (StringBuffer cipherText) {
// Define variables
String Sk;
int[] FSk = new int[26];
int N;
double ICk = 0;
double aic = 0;
double cumulativeTotalofICk = 0;
int sumOfFrequencies = 0;
double AIC_ENGLISH = 0.0661;
double step3_5 = 0;

// Begin main processing
for (int keylen = 1; keylen <= cipherText.length(); keylen++) {
for (int k = 1; k <= keylen; k++) {
// STEP 3.1
Sk = generateSK (cipherText, k, keylen);

// Step 3.2
char currentLetter = 'A';
for (int i = 0; i < 26; i++) {
FSk[i] = Crypto.letterFrequency (Sk,
currentLetter);
currentLetter++;
}

// STEP 3.3
N = Sk.length();
// Calculate the first part of the formula
if (N>1) { // If N <= 1 then it causes a divide
by zero error
// Use the value 1.0 instead of 1 to
force floating point arithmetic
ICk = (1.0 / (N*(N-1)));
// Iterate over A-Z for the Xi part of
the formula
sumOfFrequencies = 0;
for (int i=0; i < 26; i++) {
sumOfFrequencies += (FSk[i]-1)
* FSk[i];
}
// Finish calculating the formula
ICk = ICk * sumOfFrequencies;
cumulativeTotalofICk += ICk;
}
} // End of loop for k

// STEP 3.4
aic = (1.0 / keylen) * cumulativeTotalofICk;
// Clear cumulativeTotalofICk ready for next inner loop
cumulativeTotalofICk = 0;
step3_5 = Math.abs(aic - AIC_ENGLISH);
if (step3_5 <= 0.01) return keylen;
}
// If execution gets to here then the method has
// failed to find a solution, so just return 0.
return 0;
}

/**
* Calculates how many times a character occurs in a StringBuffer
string.
* Used in step 3.2 and 4.3.
*/
public static int letterFrequency (String sb, char c) {
int total = 0;
for (int i = 0; i < sb.length(); i++) {
if (sb.charAt(i) == c) total++;
}
return total;
}

/**
* Performs step 3.1 to find Sk.
* The string wraps around to produce Sk of the same length as the
message.
*/
public static String generateSK (StringBuffer sb, int k, int keylen) {
StringBuffer result = new StringBuffer();
for (int i = k-1; i < sb.length(); i += keylen) {
if (i < sb.length()) result.append (sb.charAt(i));
}
return result.toString();
}

/**
* Generates the actual keyword for the ciphertext.
*/
public static StringBuffer generateActualKeyword (StringBuffer
cipherText, int keylen) {
StringBuffer keyword = new StringBuffer (keylen);
// Prepare a buffer for the modified ciphertext, since the
// original text will need to be re-used and so cannot be over-
written
String shiftedSK;
String Sk;
for (int k = 1; k <= keylen; k++){
// Initialise to an obviously false value to allow for
error-checking
char charLargestValueOfCCch = '*';
double largestValueOfCCch = Double.NEGATIVE_INFINITY;
// STEP 4.1
Sk = generateSK (cipherText, k, keylen);
// STEP 4.2
for (char ch = 'A'; ch <= 'Z'; ch++) {
shiftedSK = shiftSK (new StringBuffer(Sk), ch);
// STEP 4.3
double cc = calculateCrossCorrelation
(shiftedSK.toString());
// STEP 4.4
if (cc > largestValueOfCCch) {
charLargestValueOfCCch = ch;
largestValueOfCCch = cc;
}
} // End for ch
keyword.append(charLargestValueOfCCch);
} // End for k
return keyword;
}


/**
* Forms Sk(ch), the character-shifted string.
*/
public static String shiftSK (StringBuffer Sk, char shiftChar) {
StringBuffer shiftedSK = new StringBuffer (Sk.length());
Character replacementChar;
for (int i=0; i<Sk.length(); i++) {
replacementChar = new Character (Crypto.shiftChar
(Sk.charAt(i), shiftChar));
shiftedSK.append(replacementChar.toString());
}
return shiftedSK.toString();
}

/**
* Calculates the cross correlation value in step 4.3
*/
public static double calculateCrossCorrelation (String shiftedSK) {
double cc = 0;
char currentLetter='A';
for (int i=0; i<26; i++) {
//System.out.println ("cc="+cc);
double letterFreq = letterFrequency (shiftedSK,
currentLetter);
double logValue = Math.log (p[i]);
//System.out.println ("letterFreq="+letterFreq);
//System.out.println ("logValue="+logValue);
cc += letterFreq * logValue;
currentLetter++;
}
return cc;
}

/**
* Shifts a character according to step 4.2.
*/
public static char shiftChar (char originalChar, char shiftByChar) {
//int shiftAmount = (Character.getNumericValue(shiftByChar)) -
 'A');
int shiftAmount = (byte) shiftByChar - 'A';
char result = (char) (originalChar - shiftAmount);
if (result < 'A') result += 26;
return (char) result;
}


/**
* Unscrambles the message.
*/
public static String unscrambleMessage (StringBuffer cipherText,
StringBuffer keyword) {
int keylen = keyword.length();
StringBuffer[] subseq = new StringBuffer[keylen];
StringBuffer result = new StringBuffer(cipherText.length());

// STEP 5.1
// Split the message into chunks representing those characters
encoding
// using each of the letters in the keyword.
StringBuffer Sk;
StringBuffer shiftedSk;
for (int k=1; k <= keylen; k++) {
Sk = new StringBuffer (generateSK (cipherText, k,
keylen));
shiftedSk = new StringBuffer ( shiftSK (Sk,
keyword.charAt(k-1)) );
subseq[k-1] = shiftedSk;
}

// STEP 5.2
// Put the characters back together again, taking all the first
// characters, then all the second ones, etc.
for (int charPos = 0; charPos < subseq[0].length(); charPos++) {
for (int arrayPos = 0; arrayPos < keylen; arrayPos++) {
if (charPos < subseq[arrayPos].length()) {
result.append (subseq[arrayPos].charAt
(charPos));
}
}
}
return result.toString();
}
}





Compile and execute Crack.java.
It takes standard input from a file, these are the two files I used:


OOBQB PQAIU NEUSR TEKAS RUMNA RRMNR ROPYO DEEAD ERUNR QLJUG CZCCU NRTEU ARJPT
MPAWU TNDOB GCCEM SOHKA RCMNB YUATM MDERD UQFWM DTFKI LROPY ARUOL FHYZS NUEQM
NBFHG EILFE JXIEQ NAQEV QRREG PQARU NDXUC ZCCGP MZTFQ PMXIA UEQAF EAVCD NKQNR
EYCFI RTAQZ ETQRF MDYOH PANGO LCD




UYSZN URSJP SPDPV PEGPN OUONQ TYOHY DFBOV TKCBG IVTKY MFKEA HUOPN FEQNL QKWKA
BCUKE JKVIG PSSEZ QCSIR OKSZV OJDAP JRZLH SGCOR FCSYG SFBEP EVJEP FJHDR TVRAI
JTSOF IRZHO FUSOV HESZV OJIYU BNOUG IRHPU FPAWL CVIOR EZBWP PDDQG FIGUF UVAKE
OVHSB SBHKC SFJEQ FTFUC UFUNN QYWYC SFHAP UZCJG PSWJN SPQKQ FURWG BKVAZ FKVKQ
PWWIC MVAAA URHEB ONWHY EVDAA EFBPU FRDLY JTOPV PEOJQ FEJEE PEAAA U
(Review ID: 99647)
======================================================================

Name: skT88420 Date: 01/21/2000


java version "1.2"
Classic VM (build JDK-1.2-V, native threads)


I do not know if I can supply you with any source code, if would like it please
contact me and I will find out.


A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'nncyber/util/general/Rnd.get ()I': Interpreting method.
  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cg
i
(Review ID: 100220)
======================================================================


Name: diC59631 Date: 11/13/98


The following code generates the message:

A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'com/blah/test/JITTest.getBallCount ()I': Interpreting method.

---

/*
 * JITTest.java
 */

package com.blah.test;

class Element {
}

final class Ball extends Element {
}

public final class JITTest {
  static final int X_SQUARE_COUNT = 19;
  static final int Y_SQUARE_COUNT = 13;
    
  Element[][] sqElem = new Element[X_SQUARE_COUNT][Y_SQUARE_COUNT];
  
  JITTest() {
    System.out.println(getBallCount());
  }
  
  int getBallCount() {
    int ballCount = 0;
    
    for (int x = 0; x < X_SQUARE_COUNT; x++) {
      for (int y = 0; y < Y_SQUARE_COUNT; y++) {
        if (sqElem[x][y] instanceof Ball) {
          ballCount++;
        }
      }
    }
    
    return ballCount;
  }
  
  public static void main(String args[]) {
    new JITTest();
  }
}

---

JDK1.2RC1, Win98
(Review ID: 41640)
======================================================================

Name: skT88420 Date: 05/17/99


A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'NetStat.run ()V': Interpreting method.
  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cgi

Pretty complex code ....
(Review ID: 83160)
======================================================================

Name: skT88420 Date: 06/10/99


I see a JIT error while executing the following method:

    /**
     * Create an ID which represents a baseID and a crossID combined
     * into a single long. The baseID will be held in the low order
     * bytes (1-32), and crossID will be the high order bytes. Both
     * ids must be less than Integer.MAX_VALUE.
     */
    public static long createFXSymbolID ( long baseID,
                                          long crossID )
    {
        if (baseID > Integer.MAX_VALUE)
            throw new IllegalArgumentException("baseID of "+
                baseID+" too large");
        
        if (crossID > Integer.MAX_VALUE)
            throw new IllegalArgumentException("crossID of "+
                baseID+" too large");

        return baseID | (crossID << 32);
    }


The full error as it appears in the stderr is:
A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'worldstreet/rtq/Util.createFXSymbolID (JJ)J': Interpreting method.
(Review ID: 84197)
======================================================================

Name: skT88420 Date: 06/10/99


My System is a PII 504 running win98, ATI Rage Pro type video card, 128megs of ram,
latest Java runtime. Ran one of the sample JAva3d programs and it said this:

C:\jdk1.2.1\demo\java3d\FourByFour>appletviewer fbf.html
A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'Cylinder.<init> (FFFFILjavax/media/j3d/Appearance;)V': Interpreting method.

  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cg
i
(Review ID: 84182)
======================================================================

Name: skT88420 Date: 06/25/99


Compiler message:
A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'ViewTextura.paint (Ljava/awt/Graphics;)V': Interpreting method.
  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cgi


At first it seem to be a random problem, but after I
 spent many hours making hundred of tests to try to isolate
the suspected source lines, I got the smallest source code that
can generate the error. This fragment of code is part of the
original code of the paint method of my view texture class. The
instructions were reduced to the simplest case (that's the reason
they don't do anything ) that try to best show the problem.
I was running the program in a Pentium 166 MMX, but in
a Pentium II 266, the problem didn't occur.

This error occurs only (at least) if the following statements were true:

1) All the four commands (labeled by "//command x" ) were
   present in the compiled code;
2) The order in which the comands appear can be changed, except
   command 4, wich must be placed after command 1.
3) Command 2 must use an array
4) Command 3 must be a graphical instruction
5) Command 4 must have at least two for's loop instructions
6) In command 1, the values attributed to the array must have
   been generated by a random function


public void paint(Graphics g)
{

double T1, U1;
int Texture[ ][ ]=new int[100][100];
int x,y;

//command 1
for(x=0;x<100;x++)
{
for(y=0;y<100;y++)
{
Texture[x][y] = (int)Math.random();
}
}
//command 2
T1 = Texture[1][2];
//command 3
g.drawLine(1,1,1,1);
//command 4
for(x=0; x<100; x++)
{
for(U1=0; U1<1; U1+=0.05)
{
}
}
}
(Review ID: 84842)
======================================================================

Name: krT82822 Date: 07/05/99


When I execute the following code, the execution goes through but I get the following message

A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'Bits.getState ([I)[B': Interpreting method.
  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cgi

The code is as follows:
import java.io.*;

public class Bits{

    private final static int ADDRESS_BITS_PER_UNIT = 6;
    private final static int BITS_PER_UNIT = 1 << ADDRESS_BITS_PER_UNIT;
    private final static int BIT_INDEX_MASK = BITS_PER_UNIT - 1;

    private long highBits[];
private long lowBits[];

public static void main(String[] args){
Bits bits = new Bits(800);
int arr[] = new int[800];
for(int i=0; i<800; arr[i]=i, i++);
bits.getState(arr);
}

    public Bits(int nProducts) {
int size = ((nProducts-1) >> ADDRESS_BITS_PER_UNIT) + 1;
highBits = new long[size];
lowBits = new long[size];
    }

public byte[] getState(int prodSeq[]){
byte[] prodState = new byte[prodSeq.length];
int unitIndex;
long bitMask;
for(int i=0; i<prodSeq.length; i++){
unitIndex = prodSeq[i]>>ADDRESS_BITS_PER_UNIT;
bitMask = (1L << (prodSeq[i]& BIT_INDEX_MASK));
if((lowBits[unitIndex] & bitMask) != 0)
if((highBits[unitIndex] & bitMask) != 0)
prodState[i] = 2;
else
prodState[i] = 1;
}
return prodState;
}
}


And the version of JDK I am using is
C:\>java -version
java version "1.2"
Classic VM (build JDK-1.2-V, native threads)

C:\>java -fullversion
java full version "JDK-1.2-V"
(Review ID: 85182)
======================================================================

Name: skT88420 Date: 08/24/99


I am testing the java3d-directx-beta.
When executing the java3d demo provided by Sun called "FourbyFour"
with the following command "appletviewer fbf.html", a message is diplayed :

"A nonfatal internal JIT (3.00.078(a)) error 'GetRegisterA' has
occurred in : 'Cylinder.<init> (FFFFILjavax/media/j3d/Appearance;)':
Interpreting method"
(Review ID: 94293)
======================================================================

Name: krT82822 Date: 10/23/99


I downloaded MiUML, a UML modeling tool, from http://www.swfm.com/miuml.htm (executable: MiUML.zip & source: MiUML_dev.zip) and installed in D:\Internet\MiUML. When I tried to start it, I got this error msg:

MICA: com.swfm.uml.MiUMLClassController@f4d97ab8<Object:null>: Unsupported element type detected: com.swfm.mica.MiModelEntity.237.Name=null,Type=classifier,Location=null[Properties: Mi_ElementType=classifier]

A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in : 'com/swfm/mica/MiPieChart.render (Lcom/swfm.mica/MiRenderer;) V': Interpreting method.

Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cgi

java -version: java version "1.2.1"
Classic VM (build JDK-1.2.1-A, native threads)

java -fullversion: Java.EXE full version "JDK-1.2.1-A"
(Review ID: 96943)
======================================================================

Name: skT88420 Date: 10/27/99


java version "1.2"
Classic VM (build JDK-1.2-V, native threads)
1. java BigInt
2. source >

public class BigInt {

  Int head;

  public BigInt(long num)
  {
    boolean negative = false;

    if (num < 0) {
      negative = true;
      num *= -1;
    }
    else if (num == 0) {
      head = new Int(0, null);
    }
    else {
      long mod = 10;
      long cur = 0;

      // get length of 'num'
      long copy = num;
      int length = 0;
      int div = 10;

      while (copy > 0) {
        cur = copy % mod;
        copy -= cur;
        copy /= div;
        length++;
      }
      
      // holds reverse order of 'num'
      long[] reverse = new long[length];

      // get ints in 'num'
      mod = 10;
      cur = 0;
      
      while (num > 0) {
        cur = num % mod;
        reverse[length - 1] = cur;

        num -= cur;
        num /= div;
        length--;
      }
      // create BigInt
      Int next = null;

      for (int i = 0; i < reverse.length; i++) {
        next = new Int(reverse[i], next);
      }
      head = next;

      if (negative) {
        toNegative();
      }
    }
  }
  public static BigInt addNum(BigInt first, BigInt second)
  {
    Int cur1 = first.head;
    Int cur2 = second.head;
    int carry = 0;

    long sum = cur1.val + cur2.val;
    
    if (sum > 9) {
      carry = 1;
      sum -= 10;
    }
    BigInt sumOfTwo = new BigInt(sum);

    Int next = sumOfTwo.head;
    cur1 = cur1.next;
    cur2 = cur2.next;

    while ((cur1 != null) || (cur2 != null)) {
      if (cur1 == null) {
        sum = cur2.val + carry;
        if (sum > 9) {
          carry = 1;
          sum -= 10;
        }
        else {
          carry = 0;
        }
        next = new Int(sum, next);
        cur2 = cur2.next;
      }
      else if (cur2 == null) {
        
        sum = (cur1.val + carry);
        if (sum > 9) {
          carry = 1;
          sum -= 10;
        }
        else {
          carry = 0;
        }
        next = new Int(sum, next);
        cur1 = cur1.next;
      }
      else {
        
        sum = (cur1.val + cur2.val + carry);
        if (sum > 9) {
          carry = 1;
          sum -= 10;
        }
        else {
          carry = 0;
        }
        next = new Int(sum, next);
        cur1 = cur1.next;
        cur2 = cur2.next;
      }
    }
    if (carry > 0) {
      next = new Int(carry, next);
    }
    sumOfTwo.head = next;

    
    // reverse order to maintain consistancy
    long[] reverse = new long[sumOfTwo.size()];

    Int cur = sumOfTwo.head;
    int index = (reverse.length - 1);
    while (cur != null) {
      reverse[index] = cur.val;
      index--;
      cur = cur.next;
    }

    // place 'reverse' back into 'sumOfTwo'

    cur = sumOfTwo.head;
    for (int i = 0; i < reverse.length; i++) {
      cur.val = reverse[i];
      cur = cur.next;
    }
    return sumOfTwo;
  }
  public void printNum()
  {
    Int cur = head;
    while (cur != null) {
      System.out.print(cur.val);
      cur = cur.next;
    }
    System.out.println();

    //int[] reverse = new int[size()];

    //int index = reverse.length - 1;

    //while (cur != null) {
     // reverse[index] = (int)cur.val;
     // cur = cur.next;
     // index++;
    //}
    //for (int i = 0; i < reverse.length; i++) {
     // System.out.print(reverse[i]);
    //}
    //System.out.println();
  }
  private void toNegative()
  {
    Int cur = head;

    while (cur != null) {
      cur.setNegative();
      cur = cur.next;
    }
  }
  private int size()
  {
    int size = 1;
    Int cur = head;

    while (cur.next != null) {
      size++;
      cur = cur.next;
    }
    return size;
  }
  public static BigInt fibonacci(int num)
  {
    BigInt first, second;

    if (num == 93) {
      return addNum(fibonacci(92),fibonacci(91));
    }
    else if (num == 0 || num == 1) {
      first = new BigInt(0);
      second = new BigInt(num);
      return addNum(first, second);
    }
    else {
      long sum = 0;
      long prev = 0;
      long cur = 1;

      for (int i = num; i > 2; i--) {
        sum = prev + cur;
        prev = cur;
        cur = sum;
      }
      first = new BigInt(prev);
      second = new BigInt(cur);
      return addNum(first, second);
    }
  }
  public static void main(String[] args)
  {
    BigInt temp;

    for (int i = 0; i <= 10; i++) {
      temp = fibonacci(i);
      System.out.print("Fib(" + i + ") = ");
      temp.printNum();
    }
    //BigInt temp1 = fibonacci(91);
    //BigInt temp2 = fibonacci(92);

    //temp = addNum(temp1, temp2);
    //temp.printNum();
  }
}

public class Int
{
  long val;
  Int next;

  public Int(long val, Int next)
  {
    this.val = val;
    this.next = next;
  }
  public void setNegative()
  {
    val *= -1;
  }
}

3. A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occured in:
'BigInt.addNum (LBigInt;LBigInt;)LBigInt;': Interpreting method.
Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cgi

4. none
5. n/a
(Review ID: 97098)
======================================================================

Name: skT88420 Date: 12/22/99


java version "1.2.1"
Classic VM (build JDK-1.2.1-A, native threads)


The following error appears (program still continues):

D:\LANG\JSL>java Bug
A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'Statistics.<init> ()V': Interpreting method.
  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cg
i


class Statistics {
  public static final int MAX_TERMINALS = 5000;
  public static final int MAX_THREADS = 100;

  class TerminalData {
    long minResponseTime;
  };
  class TerminalThreadData {
    int onQueue;
  };

  TerminalData terminalData[] = new TerminalData[MAX_TERMINALS];
  TerminalThreadData terminalThreadData[] = new TerminalThreadData[MAX_THREADS];

  public Statistics() {
    for (int i=0; i<MAX_THREADS; i++) // loop 1
      terminalThreadData[i] = new TerminalThreadData();
    for (int i=0; i<MAX_TERMINALS; i++) // loop 2
      terminalData[i] = new TerminalData();
    for (int i=0; i<MAX_TERMINALS; i++) // loop 3
      terminalData[i].minResponseTime = Integer.MAX_VALUE;
  }
}

public class Bug {
  static public void main(String args[]) {
    Statistics stats = new Statistics();
  }
}
(Review ID: 99275)
======================================================================

Name: skT88420 Date: 01/04/2000


java version "1.2"
Classic VM (build JDK-1.2-V, native threads)


A nonfatal internal JIT (3.00.078(x)) error 'GetRegisterA' has occurred in :
  'com/sun/corba/ee/internal/iiop/CDRInputStream.start_block ()V': Interpreting
method.
  Please report this error in detail to http://java.sun.com/cgi-bin/bugreport.cg
i
(Review ID: 99575)
======================================================================

Name: skT88420 Date: 01/05/2000


C:\WINDOWS\Desktop>java -version
java version "1.2"
Classic VM (build JDK-1.2-V, native threads)


This produces a JIT error, but still gives the right answer!
I have no idea what's goi