KopiSusu Beta Pages

Changes

Changes in 1.9b4a

Released april 11, 2001

• Thanks to a bug report from Ken Geis, a small problem was discovered in at.dms.kjc.CBinaryClass. It is quite difficult to handle member classes correctly when they come from a pre-compiled library, since to my knowledge there is no official standard on how to compile member classes to .class files. CBinaryClass contained an assertion that is clearly not valid in all cases; in this particular case, KopiSusu didn't correctly understand an inner class (java.lang.ref.Reference$1) in Sun's rt.jar, which is an empty inner class that is only used to implement access to a private constructor from a class that is allowed to access it according to the Java Language Specification, but not according to the Java Virtual Machine Specification.

Changes in 1.9b4

(versus 1.9b3)

Released april 10, 2001

• In at.dms.kjc.JClassDeclaration.constructDefaultContructor: access modifiers should be the same as the public/private/protected modifiers of the class for which the default constructor is generated.
• In at.dms.kjc.CSourceMethod method genCode() renamed to genBodyCode
• In at.dms.kjc.CMethod method genCode(CodeSequence,boolean) renamed genCallCode.
• In at.dms.kjc. JClassFieldExpression, JMethodCallExpression, JNewObjectExpression, CSourceMethod: changed calls to C[Source]Method.genCode when necessary because of above two changes.
• In at.dms.kjc.CSourceMethod: added property explicitlyInvokedConstructor
• In at.dms.kjc.CConstructorBlock: sets the CSourceMethod.explicitlyInvoikedConstructor property to the constructor method that is explicitly invoked in the block using a this() or super() expression, or an implicit explicit invocation inserted by the compiler.
• In at.dms.kjc.JClassDeclaration: added method checkCycicalConstructor and code to check whether constructors invoke other constructors in cycles, which would result in infinite recursion.
• In JClassDeclaration and JInterfaceDeclaration: when checking for cycles in extends or implements clauses, added checks for extending or implementing a class'es own member classes.
• In CClass: added descendsFromInside method that checks whether a class is declared inside the body of another class, or whether one of the super class or implemented interfaces of the member class or interface or implemented interfaces is declared inside the body of the other class. This is necessary to detect cycles in the inheritence of classes or interfaces.

• In CContext, CClassNameType, CClassContext, CBlockContext, CMethodContext, CCompilationUnitContext, CClass, CCompilationUnit, CTopLevel: added checking of access restrictions when when looking up classes and member classes inside classes. When refering to a member class with a simple name, and more than one member class matches the simple name, but only one member class is actually accessible from the context that refers to the member class, then this is ambiguous type name reference.

  Example:
  

  class SuperClass implements Interface {
      private static class Inner {}
  }
  interface Interface {
      class Inner {}
  }
  class SubClass extends SuperClass {
      Inner field;
  }
  

  In this case, the field field in subclass is of the type Interface.Inner, and compilation should not result in an error.

• In at.dms.classfile.ClassPath, at.dms.classfile.SourceDescription (new file), at.dms.classfile.ClassDirectory, at.dms.classfile.DirClassDirectory, at.dms.classfile.ZipClassDirectory, at.dms.kjc.CTopLevel, at.dms.kjc.Compiler, at.dms.kjc.Main: added support for loading source files from the classpath.
• In JPostFixExpression, JPrefixExpression: don't evaluate expression as 'left-side'; that violates the definite assignment rules.
• Changed order in genCode method in JExplicitConstructorInvocation to match the changed parameter order with respect to the outer-this parameter and synthethic parameters.
• In CSourceMethod, JNewObjectExpression, JExplicitConstructorInvocation: Fixed subclassing private member classes with private constructors by other private member classes in the same class.
• In Kjc.g: when creating JExplicitConstructorInvocation, don't pass it null as prefix, but the real prefix.
• In JExplicitConstructorInvocation: make prefixes to explicit constructor invocations work.
• In JNewAnonymousObjectExpression: correct subclassing of inner classes implemented when generating .class files. Anonymous subclasses have two outer-this synthetic fields; one for the class in which they are declared, and one for the member class that they subclass. This latter one does not exist if the superclass is not an inner class, or if it is a local class inside a static method: see the JLS2 15.9.5.1
• In JNewObjectExpression: refactored code generation.
• Build scripts changed slightly for easier compilation with other jar tools and virtual machines. (Thanks, Mark)

Changes in 1.9b3

(versus 1.9b3-pre1)

Released march 31, 2001

• Fixed bug when loading member classes from .class files. To determine the original modifiers of the member class, information from the InnerClassInfo attribute from another class file is needed. The other class file needs to have been compiled from source at the same time that the member class was compiled, and the other class must reference the member class. Usually, the other class is the class that contains the member class.

  Fixed in at/dms/kjc/CTopLevel.java, at/dms/kjc/CBinaryClass.java, at/dms/kjc/CClassType.java, at/dms/kjc/CClassNameType.java

• Fix in CArrayType: getCClass() should check whether the type was already checked, since if the type was the result of reading from a .class file, it isn't checked yet at that point. (See testjava/jacks-like/arrayclone)
• Refactored CType.java: moved MethodSignatureParser to seperate file
• Refactored CVariableInfo: create new ArrayOf2BitValues in at.dms.util and renamed constants to conform to the JLS2.
• Refactored checking of final fields, so they cannot be assigned twice in constructors (if field initializer already initialized field, for example)

• Found out why kjc-1.4F would compile try { String s; } catch (Blah i) { String s; } and Ksusu-1.9b2 wouldn't: KJC allowed shadowing of local vars in blocks, but the JLS doesn't.

• Rewrote checks in JTryCatchStatement completely, incorporating the reachability and definite assignment rules of the JLS 2nd edition.
• Added in CThrowableInfo, JExpression, JTryCatchSTatement and JThrowStatement support for check in whether only a specific exact exception can be thrown. Every exception, including RuntimeExceptions, are tracked. Only subclasses (including itself) of java.lang.Error are implicitly assumed to be throwable by any code; only a completely empty try clause (try {} catch ...) cannot throw any exceptions. This extension correctly analyses code reachability in cases such as:

  try {
     int i = 5;
     int j = 0;
     int k = i / j;
  } 
  catch (ClassCastException e) {
    // Unreachable
  }
  

  and

  class SubClassedException
      extends ArithmeticException
  {
      SubClassedException() { super(); }
  }
      
  try {
     int i = 5;
     int j = 0;
     int k = i / j;
  } 
  catch (SubClassedException e) {
      // Unreachable, only exact class ArithmeticException can be thrown
      // by integer division.
  }
  catch (ArithmeticException e) {
      // Reachable.
  }
  

  This does not change the rules of checked versus unchecked exceptions. A method does not have to declare unchecked exceptions, but it also not correct to catch unchecked exceptions that cannot be thrown.

• Instead of always labeling the target of a continue or break immediately when the break or continue statement is analyzed, this is now done using the at.dms.kjc.CContext mechanism.

  To implement this, code has been added to CAbstractBodyContext and subclasses to hold off marking the target of a break or continue until it is certain that the break or continue cannot be interrupted by a finally clause that does not complete normally.

  This detects unreachable code in more cases, in accordance with the JLS.

  Example of illegal java code:

  void test()
  {
      foo: try {
          break foo;
      }
      finally {
          return;
      }
      int i = 42; // Unreachable.
  }
  
  void test2()
  {
      do {
          try {
              continue;
          }
          finally {
              return;
          }
      } while (false);
      int i = 42; // Unreachable.
  }
  

• Fixed bug in JDoStatement: if the do statement is the target of a continue statement, then if the condition of the do statement is not constant and true, the do statement can complete normally, even if the body of the do loop cannot complete normally.

• Class-field expressions are considered constant expressions when the field is final, and the expression is of the form TypeName.field, and the initializer of the field is constant Simple class-field expressions of the form fieldname are constant when the field is final and the initializer is constant.

  Thanks to this fix, a few semantic bugs were discovered in the java.awt implementation of Kaffe 1.0.6.

• Fix to bug in at.dms.compiler.Scanner, in which a a character literal like '\V' or '\x05' would be interpreted as an octal constant with a bad value. Both examples are invalid character literals.

• Fix to bug in at.dms.compiler.Scanner and at.dms.kjc.JCharLiteral (the bug was introduced in version 1.9b2) in which a unicode escape sequence is being recognized and replaced by a unicode character value. This is double work, however, because at.dms.compiler.InputBuffer already does this; the JLS requires escapes like \u0020 to be interpreted at any point in the source code, not only in character or string literals.

  This is a valid java source file:

  public\u0020class\u0020B{}

• Upgraded supported version of ANTLR parser generator and support library to 2.7.1.

  Contributed by: Dalibor Topic <robilad@yahoo.com>

Changes in patch 1.9b3-pre1

Released march 17, 2001

• Don't check a catch clause with a checked exception in the body context of the try clause; the try and catch blocks are seperate; variable declarations in the try clause do not exist in the catch clause. This wasn't a problem in KJC-1.4F because it allowed local variables to be shadowed in nested blocks.

  Files:
  compiler/src/at/dms/kjc/JTryCatchStatement.java

• Anonymous subclasses are allowed to access protected constructors of super classes. This used to work in KJC1.4 because access modifiers weren't considered when selecting constructors. They are now and when the constructor method in the anonymous is generated, the superclass of the anonymous class is not yet set. The fix involves temporarily setting the superclass of the anonymous class before looking up the constructor in the superclass.

  Files:
  compiler/src/at/dms/kjc/JNewAnonymousClassExpression.java

• Just as a non-constant short expression is not assignable to a char lvalue expression, a non-constant byte isn't either. Supplied by Mark Wielaard

  Files:
  compiler/src/at/dms/compiler/CNumericType.java

Changes in 1.9b2

(versus 1.4F)

Released march 16, 2001

Source code layout

• Spaces instead of TABs
• Indenting with 4 space
• Opening braces of type and member declarations on a new line
• "catch" and "else" clauses start on a new line
• "if", "for", "while" and "do" statements always have blocks instead of simple statements, but braces go on the same line as the statement.
• "extends" and "implements" go on a new line.
• Import statements for java.* and javax.* packages go before other imports.
• Lines have 80 characters maximum. Breaking before they're 80 characters is lines is necessary. It's better to avoid it at all by factoring big sub-expressions out of the line and using a temporary local variable for the sub-expression.

That's my favorite style. You may have yours. This style is heavily influenced by the features and limitations of the JDE environment and Java mode for Emacs. I'd have been more conservative in the changes if I knew that KOPI wasn't dead. Someone offered to convert to the GNU style. If that makes people happy, I'm for it, as long as its a consistent and reasonably readable style.

Fixed javadoc comments

• Lotsa javadoc comments were copy-pasted and out of sync with the member or type they were supposed to be documenting. I haven't finished this task yet.
• Some very useful comments that weren't in Javadoc style are converted to javadoc, so they'll be picked up when generating Javadoc.
• The headline of a javadoc comment ends at the first dot in the line of a javadoc comment. (Newer versions of Javadoc appear to be a bit smarter with obvious acronyms that contains dots.) I've tried to bring all javadoc comments to look reasonable given this javadoc syntax rule.
• I'm still trying to find a consistent Javadoc style myself, I'm afraid. Sometimes its necessary to explain a lot for one single parameter, for example, so line breaking becomes an issue. So I prefer starting the explanation for a @param, @return and @exception on a new line.

Compilation features

• Improved handling of constants.
  1. Added constant folding of Strings, as required by the JLS.

     Files:
     compiler/src/at/dms/kjc/JAddExpression.java

  2. Classes that do calculations with floats and doubles are declared as 'strictfp' which should help if the JVM is compliant enough to implement this features; the JLS says that all constant folding arithmetic should be done with strict IEEE floating point rules.

     Files: all files that do float/double arithmetic in
     compiler/src/at/dms/kjc/*.java
     classfile/src/at/dms/classfile/*.java

  3. Underflow in floating point constants is now detected by comparing floats/doubles with the java.math.BigDecimal representation of themselves to see if they were really 0 or if there was an underflow.

     Files:
     compiler/src/at/dms/kjc/JRealLiteral.java

  4. stricter compliance on the range of ints/longs: for int/long constants, the values resp. 2^31 and 2^61 are only allowed when directly preceded by a unary negative expression. This does not apply to float/double constants.

     Files:
     compiler/src/at/dms/kjc/JOrdinalLiteral.java compiler/src/at/dms/kjc/JUnaryExpression.java

• Moved from old style data containers to Collections API, for aesthetic, maintainability, and hopefully speed reasons. The Collections API does, by default, not use monitors to be thread-safe, which makes it faster than Vector/Hashtable/Stack when thread-safety is not needed.
  1. Replaced use of java.util.Hashtable with java.util.Map and java.util.HashMap or java.util.Set / java.util.HashSet. The latter is used when the Hashtable was used as a set.
  2. Replaced use of java.util.Vector with java.util.List and java.util.ArrayList
  3. Replaced use of java.util.Stack with java.util.LinkedList
  4. Replaced use of java.util.Enumeration with java.util.Iterator

  Files:
  majority of source files.

• Fixed bug in && and || optimization that didn't take side effects into account. For example, the expression ( new File("foobar").mkdir() && false ) cannot be rewritten as ( false ) because of side effects; neither can ( new File("foobar").mkdir() || true ) be rewritten as ( true ). ( false && new File("foobar").mkdir()) can be rewritten as ( false ), though. But officially, only a && expression with two constant operands is a constant expression. So the optimized ( false ) must not be considered a constant. This is not fixed yet in KopiSusu 1.9b2.

  Files:
  compiler/src/at/dms/kjc/JConditionalAndExpression.java compiler/src/at/dms/kjc/JConditionalOrExpression.java

• Accessor methods are created when the JVM does not allow access to a method or field, but the JLS mandates access. This is the case with:
  1. access to private methods/fields in member classes from the outer class, or from the member class to private methods/fields in the outer class.
  2. access to private constructors in member classes. However, there's an error here, 1.9beta2 doesn't yet allow subclasses to access private superclass constructors in all cases where the JLS says they should be able to.
  Note that this was only a problem in KJC-1.4F if you turned code verification on in the JVM, by giving the command-line option -verify to the java executable or by using a ClassLoader other than the boot ClassLoader, so the fact that this didn't work correctly may not have been noticed by some users of KJC-1.4F.

  Files:
  compiler/src/at/dms/kjc/CSourceMethod.java compiler/src/at/dms/kjc/CSourceField.java compiler/src/at/dms/kjc/JClassFieldExpression.java compiler/src/at/dms/kjc/JMethodCallExpression.java

• In method-lookups: ignore private methods when they're not accessible to you. This resolves some ambiguities and is mandated by the JLS. This is implemented by passing the CClass object (of the class that is making the method call) to the lookup-method function, to allow the lookup function to determine accessibility by the calling class. The following (valid java) example shows the bug. Compiling it with KJC-1.4F results in:
  X.java:4: error:Cannot access method "t" [JLS 15.11.2.1]

  
      public class X
      {
          public void test()
          {
              A a = new A();
              a.t(new Integer(4));
          }
      }
  
      class A
      {
          private void t(Number n) {}
          public void t(Object o) {}
      }
  

  Files:
  compiler/src/at/dms/kjc/CClass.java compiler/src/at/dms/kjc/CClassContext.java compiler/src/at/dms/kjc/CContext.java compiler/src/at/dms/kjc/JExplicitConstructorInvocation.java compiler/src/at/dms/kjc/JMethodCallExpression.java compiler/src/at/dms/kjc/JNewAnonymousClassExpression.java compiler/src/at/dms/kjc/JNewObjectExpression.java

• In class-lookups: look up member classes corectly in superclass and all interfaces. Static member classes in interfaces or member classes of superclasses were not found before. The method lookupClass in CClass has been renamed to lookupMemberClass, and takes a parameter that does not have the name of an outer class mangled (like "Outer$Inner"), only the inner class name (like "Inner") because the outer class name is not known yet, the name of the inner could be "SuperOfOuter$Inner" or "InterfaceOfOuter$Inner".

  Files:
  compiler/src/at/dms/kjc/CClass.java compiler/src/at/dms/kjc/CClassContext.java compiler/src/at/dms/kjc/CClassNameType.java compiler/src/at/dms/kjc/JNewObjectExpression.java

• Implemented 'strictfp' modifier. The strictfp modifier signals to the JVM that strict floating points semantics are required in the declaration instead of faster, implementation-dependent floating point semantics.

  Files:
  compiler/src/at/dms/kjc/Kjc.g compiler/src/at/dms/kjc/Kjc.t .. and all files generated from those two .. compiler/src/at/dms/kjc/CModifier.java compiler/src/at/dms/kjc/JClassDeclaration.java compiler/src/at/dms/kjc/JInterfaceDeclaration.java compiler/src/at/dms/kjc/JMemberDeclaration.java compiler/src/at/dms/kjc/JMethodDeclaration.java classfile/src/at/dms/classfile/Constants.java

• Removed 'threadsafe' modifier (which does not exist in the JLS and should be a valid identifier for other purposes)

  Files:
  compiler/src/at/dms/kjc/Kjc.g compiler/src/at/dms/kjc/Kjc.t .. and all files generated from those two .. compiler/src/at/dms/kjc/Constants.java

• Fixed array initializers in the grammar: { , } { 1, 2, } and { 1, 2 } are all valid array initializers.

  Files:
  compiler/src/at/dms/kjc/Kjc.g

• Implemented ".new " construct. Improved on some not-yet-functional groundwork. Added a jQualifiedNewExpression rule in Kjc.g

  Files:
  compiler/src/at/dms/kjc/JNewAnonymousClassExpression.java compiler/src/at/dms/kjc/JNewObjectExpression.java compiler/src/at/dms/kjc/Kjc.g

• Implemented ".super." construct. method-calls to super-methods of methods in outer classes are made using a synthesized accessor method, as there is no JVM opcode to call a super-method outside of your own class directly.

  Files:
  compiler/src/at/dms/kjc/Kjc.g compiler/src/at/dms/kjc/CSourceMethod.java compiler/src/at/dms/kjc/JMethodClassExpression.java

• Explicitly mark members as synthetic instead of assuming that all members with a $ in their name are synthetic.

  Files:
  compiler/src/at/dms/kjc/CMember.java compiler/src/at/dms/kjc/CSourceClass.java compiler/src/at/dms/kjc/JInitializerDeclaration.java compiler/src/at/dms/kjc/JTypeDeclaration.java

• try/finally: finally block should only protect try block, not itself as well. Example that shows bug:

  
     public class B
     {
         public static void main(String[] args)
         {
             try { } finally { return; }
         }
     }
  

  Effect of bug (compiled with KCJ-1.4F):
  Exception in thread "main" java.lang.VerifyError: (class: B, method: main signature: ([Ljava/lang/String;)V) Recursive call to jsr entry

  Solution: move statement code.popContext(this); to just before generating the code for the finally clause.

  Files:
  compiler/src/at/dms/kjc/JTryFinallyStatement.java

• All inner classes now havean outer-this 1st argument, regardless of whether they use it. This improves compatibility with other popular compilers; but it is really Sun's problem of not specifying how to compile member classes. It was not possible to have a pre-compiled library with public inner classes compiled with KJC-1.4F and use it with jikes/javac or vice versa. With this fix, it is.

  Files:
  compiler/src/at/dms/kjc/CSourceClass.java compiler/src/at/dms/kjc/CClass.java compiler/src/at/dms/kjc/JConstructorDeclaration.java

• Local/anonymous classes have the local variables from their outer scope passed in the constructor of the class before the declared parameters. This is to be more compatible with javac and jikes, and decompilers that expect the javac/jikes way of handling anonymous inner classes.

  Files:
  compiler/src/at/dms/kjc/CSourceClass.java compiler/src/at/dms/kjc/CClass.java compiler/src/at/dms/kjc/JNewAnonymousClassExpression.java

• synchronized blocks inside the try of a try/finally now always work because they add their monitor reference as a local variable to the enclosing try block instead of their own enclosing block. The old behaviour would allow the local variable with the monitor reference to be reassigned in the finally of an enclosing try/finally block.
• String += char[] and "" + char[] ) now work according to the JLS, which is: converting a char[] to a String for concatenation has the same effect as first calling char[].toString() before concatenation. That means that converting a char[] to a String is done by String.valueOf(Object), NOT String.valueOf(char[]).

  Files:
  compiler/src/at/dms/kjc/JAddExpression.java compiler/src/at/dms/kjc/JCompountAssignmentExpression.java

• For some reason, it is not okay to use a JVM tableswitch opcode if the maximum value is creater than 0x7ffffff0. At least, it's not with Sun's JDK 1.3 for Linux, and there is a jacks test for it so presumably its also in other VM's. I suppose it has something to do with the 16-byte offset from the start of a tableswitch opcode to the jump table itself. The fix: a lookupswitch is generated even if a tableswitch would be more compact or faster there.

  Files:
  classfile/src/at/dms/classfile/SwitchInstruction.java

• When creating a new instance of an inner class, the chain of this$0 fields is followed from the inner class containing the expression to the containing toplevel class to find a type that can be given to the new inner class as the outer-this instance. This makes nested inner classes work.

  Files:
  compiler/src/at/dms/kjc/JNewObjectExpression.java

• Member classes in interfaces are always static and public, even if not explicitly declared as such. (JLS2 9.5)

  Files:
  compiler/src/at/dms/kjc/JClassDeclaration.java

• Improved handling of @listfile command-line arguments.

  Files:
  compiler/src/at/dms/compiler/Compiler.java

• Improved widening conversion handling: char is not widening-convertable to short and vice versa.

  Files:
  compiler/src/at/dms/compiler/CNumericType.java

• Improved type selection in ?: conditional expressions when one of the latter two operands is a constant (JLS2 15.25)

  Files:
  compiler/src/at/dms/kjc/JConditionalExpression.java

• Fixed local variable shadowing (JLS 14.2.2). It is not okay to redeclare a local variable in a nested block. Version 1.4F allowed this, but this may lead to confusion and is not in accordance with the JLS.