Attachment 30549 Details for Bug 117120 – patch for HEAD

[patch] patch for HEAD

117120-4.txt (text/plain), 67.75 KB, created by Philipe Mulet

on 2005-11-24 09:09:23 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Philipe Mulet

Created: 2005-11-24 09:09:23 EST

Size: 67.75 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core.tests.compiler
>Index: src/org/eclipse/jdt/core/tests/compiler/regression/BooleanTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BooleanTest.java,v
>retrieving revision 1.5
>diff -u -r1.5 BooleanTest.java
>--- src/org/eclipse/jdt/core/tests/compiler/regression/BooleanTest.java	23 Feb 2005 02:52:37 -0000	1.5
>+++ src/org/eclipse/jdt/core/tests/compiler/regression/BooleanTest.java	24 Nov 2005 14:04:01 -0000
>@@ -10,6 +10,13 @@
>  *******************************************************************************/
> package org.eclipse.jdt.core.tests.compiler.regression;
> 
>+import java.io.File;
>+import java.io.IOException;
>+
>+import org.eclipse.jdt.core.ToolFactory;
>+import org.eclipse.jdt.core.tests.util.Util;
>+import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
>+
> import junit.framework.Test;
> import junit.framework.TestSuite;
> 
>@@ -414,6 +421,802 @@
> 		},
> 		"SUCCESS");
> }
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120
>+public void test018() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0++) || true) != ((true && true) && (!(false || true)))));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"true");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 3, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  getstatic X.f0 : float [26]\n" + 
>+		"    10  fconst_1\n" + 
>+		"    11  fadd\n" + 
>+		"    12  putstatic X.f0 : float [26]\n" + 
>+		"    15  iconst_1\n" + 
>+		"    16  invokevirtual java.io.PrintStream.println(boolean) : void [28]\n" + 
>+		"    19  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 16, line: 8]\n" + 
>+		"        [pc: 19, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 20] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 20] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test019() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0++) || false) != true));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"false");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 5, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  lload_1 [l11]\n" + 
>+		"     8  l2f\n" + 
>+		"     9  getstatic X.f0 : float [26]\n" + 
>+		"    12  dup\n" + 
>+		"    13  fconst_1\n" + 
>+		"    14  fadd\n" + 
>+		"    15  putstatic X.f0 : float [26]\n" + 
>+		"    18  fcmpg\n" + 
>+		"    19  ifge 26\n" + 
>+		"    22  iconst_0\n" + 
>+		"    23  goto 27\n" + 
>+		"    26  iconst_1\n" + 
>+		"    27  invokevirtual java.io.PrintStream.println(boolean) : void [28]\n" + 
>+		"    30  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 27, line: 8]\n" + 
>+		"        [pc: 30, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 31] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 31] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test020() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) | true) != false));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"true");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_1\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test021() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) && false) != true));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"true");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_1\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test022() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) & false) != true));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"true");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_1\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120
>+public void test023() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0++) || true) == ((true && true) && (!(false || true)))));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"false");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 3, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  getstatic X.f0 : float [26]\n" + 
>+		"    10  fconst_1\n" + 
>+		"    11  fadd\n" + 
>+		"    12  putstatic X.f0 : float [26]\n" + 
>+		"    15  iconst_0\n" + 
>+		"    16  invokevirtual java.io.PrintStream.println(boolean) : void [28]\n" + 
>+		"    19  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 16, line: 8]\n" + 
>+		"        [pc: 19, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 20] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 20] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test024() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0++) || false) == true));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"true");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 5, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  lload_1 [l11]\n" + 
>+		"     8  l2f\n" + 
>+		"     9  getstatic X.f0 : float [26]\n" + 
>+		"    12  dup\n" + 
>+		"    13  fconst_1\n" + 
>+		"    14  fadd\n" + 
>+		"    15  putstatic X.f0 : float [26]\n" + 
>+		"    18  fcmpg\n" + 
>+		"    19  ifge 26\n" + 
>+		"    22  iconst_1\n" + 
>+		"    23  goto 27\n" + 
>+		"    26  iconst_0\n" + 
>+		"    27  invokevirtual java.io.PrintStream.println(boolean) : void [28]\n" + 
>+		"    30  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 27, line: 8]\n" + 
>+		"        [pc: 30, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 31] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 31] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test025() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) | true) == false));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"false");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_0\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test026() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) && false) == true));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"false");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_0\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n" + 
>+		"}";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test027() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) & false) == true));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"false");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_0\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test028() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0) || true) == false));\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"false");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  iconst_0\n" + 
>+		"     8  invokevirtual java.io.PrintStream.println(boolean) : void [26]\n" + 
>+		"    11  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 8, line: 8]\n" + 
>+		"        [pc: 11, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 12] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 12] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test029() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"   	System.out.println(\n" + 
>+			"   			((foo() || bar()) || true) && false); 		\n" + 
>+			"  }\n" + 
>+			"  static boolean foo(){ \n" + 
>+			"	  System.out.print(\"foo\");\n" + 
>+			"	  return false;\n" + 
>+			"  }\n" + 
>+			"  static boolean bar(){\n" + 
>+			"	  System.out.print(\"bar\");\n" + 
>+			"	  return true;\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"foobarfalse");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 2, Locals: 1\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  getstatic java.lang.System.out : java.io.PrintStream [18]\n" + 
>+		"     3  invokestatic X.foo() : boolean [24]\n" + 
>+		"     6  ifne 13\n" + 
>+		"     9  invokestatic X.bar() : boolean [28]\n" + 
>+		"    12  pop\n" + 
>+		"    13  iconst_0\n" + 
>+		"    14  invokevirtual java.io.PrintStream.println(boolean) : void [31]\n" + 
>+		"    17  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 3, line: 7]\n" + 
>+		"        [pc: 14, line: 6]\n" + 
>+		"        [pc: 17, line: 8]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 18] local: args index: 0 type: java.lang.String[]\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117120 - variation
>+public void test030() {
>+	this.runConformTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" + 
>+			"  public static float f0;\n" + 
>+			"  \n" + 
>+			"  public static void main(String[] args)\n" + 
>+			"  {\n" + 
>+			"    long l11 = -26;\n" + 
>+			"    \n" + 
>+			"    System.out.println(\n" + 
>+			"        (((l11 < f0++) || true) == ((foo() || bar()) || true)));\n" + 
>+			"  }\n" + 
>+			"  static boolean foo() {\n" + 
>+			"	  System.out.print(\"foo\");\n" + 
>+			"	  return false;\n" + 
>+			"  }\n" + 
>+			"  static boolean bar() {\n" + 
>+			"	  System.out.print(\"bar\");\n" + 
>+			"	  return true;\n" + 
>+			"  }\n" + 
>+			"}\n",
>+		},
>+		"foobartrue");
>+	// 	ensure optimized boolean codegen sequence
>+	String expectedOutput =
>+		"  // Method descriptor #17 ([Ljava/lang/String;)V\n" + 
>+		"  // Stack: 3, Locals: 3\n" + 
>+		"  public static void main(java.lang.String[] args);\n" + 
>+		"     0  ldc2_w <Long -26> [18]\n" + 
>+		"     3  lstore_1 [l11]\n" + 
>+		"     4  getstatic java.lang.System.out : java.io.PrintStream [20]\n" + 
>+		"     7  getstatic X.f0 : float [26]\n" + 
>+		"    10  fconst_1\n" + 
>+		"    11  fadd\n" + 
>+		"    12  putstatic X.f0 : float [26]\n" + 
>+		"    15  invokestatic X.foo() : boolean [28]\n" + 
>+		"    18  ifne 25\n" + 
>+		"    21  invokestatic X.bar() : boolean [32]\n" + 
>+		"    24  pop\n" + 
>+		"    25  iconst_1\n" + 
>+		"    26  invokevirtual java.io.PrintStream.println(boolean) : void [35]\n" + 
>+		"    29  return\n" + 
>+		"      Line numbers:\n" + 
>+		"        [pc: 0, line: 6]\n" + 
>+		"        [pc: 4, line: 8]\n" + 
>+		"        [pc: 7, line: 9]\n" + 
>+		"        [pc: 26, line: 8]\n" + 
>+		"        [pc: 29, line: 10]\n" + 
>+		"      Local variable table:\n" + 
>+		"        [pc: 0, pc: 30] local: args index: 0 type: java.lang.String[]\n" + 
>+		"        [pc: 4, pc: 30] local: l11 index: 1 type: long\n";
>+	
>+	try {
>+		File f = new File(OUTPUT_DIR + File.separator + "X.class");
>+		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
>+		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
>+		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
>+		int index = result.indexOf(expectedOutput);
>+		if (index == -1 || expectedOutput.length() == 0) {
>+			System.out.println(Util.displayString(result, 3));
>+		}
>+		if (index == -1) {
>+			assertEquals("Wrong contents", expectedOutput, result);
>+		}
>+	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
>+		assertTrue(false);
>+	} catch (IOException e) {
>+		assertTrue(false);
>+	}		
>+}
>+
> public static Class testClass() {
> 	return BooleanTest.class;
> }
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/BinaryExpression.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/BinaryExpression.java,v
>retrieving revision 1.52
>diff -u -r1.52 BinaryExpression.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/BinaryExpression.java	18 Nov 2005 16:46:21 -0000	1.52
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/BinaryExpression.java	24 Nov 2005 14:04:04 -0000
>@@ -86,14 +86,12 @@
> 		boolean valueRequired) {
> 
> 		int pc = codeStream.position;
>-		Label falseLabel, endLabel;
> 		if (constant != Constant.NotAConstant) {
> 			if (valueRequired)
> 				codeStream.generateConstant(constant, implicitConversion);
> 			codeStream.recordPositionsFrom(pc, this.sourceStart);
> 			return;
> 		}
>-		bits |= OnlyValueRequired;
> 		switch ((bits & OperatorMASK) >> OperatorSHIFT) {
> 			case PLUS :
> 				switch (bits & ReturnTypeIDMASK) {
>@@ -295,33 +293,8 @@
> 						}
> 						break;
> 					case T_boolean : // logical and
>-						generateOptimizedLogicalAnd(
>-							currentScope,
>-							codeStream,
>-							null,
>-							(falseLabel = new Label(codeStream)),
>-							valueRequired);
>-						/* improving code gen for such a case: boolean b = i < 0 && false;
>-						 * since the label has never been used, we have the inlined value on the stack. */
>-						if (falseLabel.hasForwardReferences()) {
>-							if (valueRequired) {
>-								codeStream.iconst_1();
>-								if ((bits & IsReturnedValue) != 0) {
>-									codeStream.generateImplicitConversion(this.implicitConversion);
>-									codeStream.generateReturnBytecode(this);
>-									falseLabel.place();
>-									codeStream.iconst_0();
>-								} else {
>-									codeStream.goto_(endLabel = new Label(codeStream));
>-									codeStream.decrStackSize(1);
>-									falseLabel.place();
>-									codeStream.iconst_0();
>-									endLabel.place();
>-								}
>-							} else {
>-								falseLabel.place();
>-							}
>-						}
>+						generateLogicalAnd(currentScope, codeStream, valueRequired);
>+						break;
> 				}
> 				break;
> 			case OR :
>@@ -367,33 +340,8 @@
> 						}
> 						break;
> 					case T_boolean : // logical or
>-						generateOptimizedLogicalOr(
>-							currentScope,
>-							codeStream,
>-							null,
>-							(falseLabel = new Label(codeStream)),
>-							valueRequired);
>-						/* improving code gen for such a case: boolean b = i < 0 || true;
>-						 * since the label has never been used, we have the inlined value on the stack. */
>-						if (falseLabel.hasForwardReferences()) {
>-							if (valueRequired) {
>-								codeStream.iconst_1();
>-								if ((bits & IsReturnedValue) != 0) {
>-									codeStream.generateImplicitConversion(this.implicitConversion);
>-									codeStream.generateReturnBytecode(this);
>-									falseLabel.place();
>-									codeStream.iconst_0();
>-								} else {
>-									codeStream.goto_(endLabel = new Label(codeStream));
>-									codeStream.decrStackSize(1);
>-									falseLabel.place();
>-									codeStream.iconst_0();
>-									endLabel.place();
>-								}
>-							} else {
>-								falseLabel.place();
>-							}
>-						}
>+						generateLogicalOr(currentScope, codeStream, valueRequired);
>+						break;
> 				}
> 				break;
> 			case XOR :
>@@ -439,33 +387,8 @@
> 						}
> 						break;
> 					case T_boolean :
>-						generateOptimizedLogicalXor(
>-							currentScope,
>-							codeStream,
>-							null,
>-							(falseLabel = new Label(codeStream)),
>-							valueRequired);
>-						/* improving code gen for such a case: boolean b = i < 0 ^ bool;
>-						 * since the label has never been used, we have the inlined value on the stack. */
>-						if (falseLabel.hasForwardReferences()) {
>-							if (valueRequired) {
>-								codeStream.iconst_1();
>-								if ((bits & IsReturnedValue) != 0) {
>-									codeStream.generateImplicitConversion(this.implicitConversion);
>-									codeStream.generateReturnBytecode(this);
>-									falseLabel.place();
>-									codeStream.iconst_0();
>-								} else {
>-									codeStream.goto_(endLabel = new Label(codeStream));
>-									codeStream.decrStackSize(1);
>-									falseLabel.place();
>-									codeStream.iconst_0();
>-									endLabel.place();
>-								}
>-							} else {
>-								falseLabel.place();
>-							}
>-						}
>+						generateLogicalXor(currentScope, 	codeStream, valueRequired);
>+						break;
> 				}
> 				break;
> 			case LEFT_SHIFT :
>@@ -514,6 +437,7 @@
> 				}
> 				break;
> 			case GREATER :
>+				Label falseLabel, endLabel;
> 				generateOptimizedGreaterThan(
> 					currentScope,
> 					codeStream,
>@@ -1152,6 +1076,167 @@
> 	/**
> 	 * Boolean generation for &
> 	 */
>+	public void generateLogicalAnd(
>+		BlockScope currentScope,
>+		CodeStream codeStream,
>+		boolean valueRequired) {
>+			
>+		Constant condConst;
>+		if ((left.implicitConversion & COMPILE_TYPE_MASK) == T_boolean) {
>+			if ((condConst = left.optimizedBooleanConstant()) != Constant.NotAConstant) {
>+				if (condConst.booleanValue() == true) {
>+					// <something equivalent to true> & x
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, valueRequired);
>+				} else {
>+					// <something equivalent to false> & x
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, false);
>+					if (valueRequired) {
>+						codeStream.iconst_0();
>+					}
>+					// reposition the endPC
>+					codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+				}
>+				return;
>+			} 
>+			if ((condConst = right.optimizedBooleanConstant()) != Constant.NotAConstant) {
>+				if (condConst.booleanValue() == true) {
>+					// x & <something equivalent to true>
>+					left.generateCode(currentScope, codeStream, valueRequired);
>+					right.generateCode(currentScope, codeStream, false);
>+				} else {
>+					// x & <something equivalent to false>
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, false);
>+					if (valueRequired) {
>+						codeStream.iconst_0();
>+					}
>+					// reposition the endPC
>+					codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+				}
>+				return;
>+			}
>+		}
>+		// default case
>+		left.generateCode(currentScope, codeStream, valueRequired);
>+		right.generateCode(currentScope, codeStream, valueRequired);
>+		if (valueRequired) {
>+			codeStream.iand();
>+		}
>+		// reposition the endPC
>+		codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+	}
>+	
>+	/**
>+	 * Boolean generation for |
>+	 */
>+	public void generateLogicalOr(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
>+			
>+		Constant condConst;
>+		if ((left.implicitConversion & COMPILE_TYPE_MASK) == T_boolean) {
>+			if ((condConst = left.optimizedBooleanConstant()) != Constant.NotAConstant) {
>+				if (condConst.booleanValue() == true) {
>+					// <something equivalent to true> | x
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, false);
>+					if (valueRequired) {
>+						codeStream.iconst_1();
>+					}
>+					// reposition the endPC
>+					codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+				} else {
>+					// <something equivalent to false> | x
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, valueRequired);
>+				}
>+				return;
>+			}
>+			if ((condConst = right.optimizedBooleanConstant()) != Constant.NotAConstant) {
>+				if (condConst.booleanValue() == true) {
>+					// x | <something equivalent to true>
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, false);
>+					if (valueRequired) {
>+						codeStream.iconst_1();
>+					}
>+					// reposition the endPC
>+					codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+				} else {
>+					// x | <something equivalent to false>
>+					left.generateCode(currentScope, codeStream, valueRequired);
>+					right.generateCode(currentScope, codeStream, false);
>+				}
>+				return;
>+			}
>+		}
>+		// default case
>+		left.generateCode(currentScope, codeStream, valueRequired);
>+		right.generateCode(currentScope, codeStream, valueRequired);
>+		if (valueRequired) {
>+			codeStream.ior();
>+		}
>+		// reposition the endPC
>+		codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+	}
>+	
>+	/**
>+	 * Boolean generation for ^
>+	 */
>+	public void generateLogicalXor(BlockScope currentScope,	CodeStream codeStream, boolean valueRequired) {
>+			
>+		Constant condConst;
>+		if ((left.implicitConversion & COMPILE_TYPE_MASK) == T_boolean) {
>+			if ((condConst = left.optimizedBooleanConstant()) != Constant.NotAConstant) {
>+				if (condConst.booleanValue() == true) {
>+					// <something equivalent to true> ^ x
>+					left.generateCode(currentScope, codeStream, false);
>+					if (valueRequired) {
>+						codeStream.iconst_1();
>+					}
>+					right.generateCode(currentScope, codeStream, valueRequired);
>+					if (valueRequired) {
>+						codeStream.ixor(); // negate
>+						codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+					}
>+				} else {
>+					// <something equivalent to false> ^ x
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, valueRequired);
>+				}
>+				return;
>+			}
>+			if ((condConst = right.optimizedBooleanConstant()) != Constant.NotAConstant) {
>+				if (condConst.booleanValue() == true) {
>+					// x ^ <something equivalent to true>
>+					left.generateCode(currentScope, codeStream, valueRequired);
>+					right.generateCode(currentScope, codeStream, false);
>+					if (valueRequired) {
>+						codeStream.iconst_1();
>+						codeStream.ixor(); // negate
>+						codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+					}
>+				} else {
>+					// x ^ <something equivalent to false>
>+					left.generateCode(currentScope, codeStream, valueRequired);
>+					right.generateCode(currentScope, codeStream, false);
>+				}
>+				return;
>+			}
>+		}
>+		// default case
>+		left.generateCode(currentScope, codeStream, valueRequired);
>+		right.generateCode(currentScope, codeStream, valueRequired);
>+		if (valueRequired) {
>+			codeStream.ixor();
>+		}
>+		// reposition the endPC
>+		codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
>+	}	
>+	
>+	/**
>+	 * Boolean generation for &
>+	 */
> 	public void generateOptimizedLogicalAnd(
> 		BlockScope currentScope,
> 		CodeStream codeStream,
>@@ -1170,16 +1255,12 @@
> 						trueLabel,
> 						falseLabel,
> 						false);
>-					if ((bits & OnlyValueRequired) != 0) {
>-						right.generateCode(currentScope, codeStream, valueRequired);
>-					} else {
>-						right.generateOptimizedBoolean(
>-							currentScope,
>-							codeStream,
>-							trueLabel,
>-							falseLabel,
>-							valueRequired);
>-					}
>+					right.generateOptimizedBoolean(
>+						currentScope,
>+						codeStream,
>+						trueLabel,
>+						falseLabel,
>+						valueRequired);
> 				} else {
> 					// <something equivalent to false> & x
> 					left.generateOptimizedBoolean(
>@@ -1188,22 +1269,16 @@
> 						trueLabel,
> 						falseLabel,
> 						false);
>-					Label internalTrueLabel = new Label(codeStream);
> 					right.generateOptimizedBoolean(
> 						currentScope,
> 						codeStream,
> 						trueLabel,
> 						falseLabel,
> 						false);
>-					internalTrueLabel.place();
> 					if (valueRequired) {
>-						if ((bits & OnlyValueRequired) != 0) {
>-							codeStream.iconst_0();
>-						} else {
>-							if (falseLabel != null) {
>-								// implicit falling through the TRUE case
>-								codeStream.goto_(falseLabel);
>-							}
>+						if (falseLabel != null) {
>+							// implicit falling through the TRUE case
>+							codeStream.goto_(falseLabel);
> 						}
> 					}
> 					// reposition the endPC
>@@ -1214,16 +1289,12 @@
> 			if ((condConst = right.optimizedBooleanConstant()) != Constant.NotAConstant) {
> 				if (condConst.booleanValue() == true) {
> 					// x & <something equivalent to true>
>-					if ((bits & OnlyValueRequired) != 0) {
>-						left.generateCode(currentScope, codeStream, valueRequired);
>-					} else {
>-						left.generateOptimizedBoolean(
>-							currentScope,
>-							codeStream,
>-							trueLabel,
>-							falseLabel,
>-							valueRequired);
>-					}
>+					left.generateOptimizedBoolean(
>+						currentScope,
>+						codeStream,
>+						trueLabel,
>+						falseLabel,
>+						valueRequired);
> 					right.generateOptimizedBoolean(
> 						currentScope,
> 						codeStream,
>@@ -1247,13 +1318,9 @@
> 						falseLabel,
> 						false);
> 					if (valueRequired) {
>-						if ((bits & OnlyValueRequired) != 0) {
>-							codeStream.iconst_0();
>-						} else {
>-							if (falseLabel != null) {
>-								// implicit falling through the TRUE case
>-								codeStream.goto_(falseLabel);
>-							}
>+						if (falseLabel != null) {
>+							// implicit falling through the TRUE case
>+							codeStream.goto_(falseLabel);
> 						}
> 					}
> 					// reposition the endPC
>@@ -1267,19 +1334,17 @@
> 		right.generateCode(currentScope, codeStream, valueRequired);
> 		if (valueRequired) {
> 			codeStream.iand();
>-			if ((bits & OnlyValueRequired) == 0) {
>-				if (falseLabel == null) {
>-					if (trueLabel != null) {
>-						// implicit falling through the FALSE case
>-						codeStream.ifne(trueLabel);
>-					}
>+			if (falseLabel == null) {
>+				if (trueLabel != null) {
>+					// implicit falling through the FALSE case
>+					codeStream.ifne(trueLabel);
>+				}
>+			} else {
>+				// implicit falling through the TRUE case
>+				if (trueLabel == null) {
>+					codeStream.ifeq(falseLabel);
> 				} else {
>-					// implicit falling through the TRUE case
>-					if (trueLabel == null) {
>-						codeStream.ifeq(falseLabel);
>-					} else {
>-						// no implicit fall through TRUE/FALSE --> should never occur
>-					}
>+					// no implicit fall through TRUE/FALSE --> should never occur
> 				}
> 			}
> 		}
>@@ -1317,12 +1382,8 @@
> 						false);
> 					internalFalseLabel.place();
> 					if (valueRequired) {
>-						if ((bits & OnlyValueRequired) != 0) {
>-							codeStream.iconst_1();
>-						} else {
>-							if (trueLabel != null) {
>-								codeStream.goto_(trueLabel);
>-							}
>+						if (trueLabel != null) {
>+							codeStream.goto_(trueLabel);
> 						}
> 					}
> 					// reposition the endPC
>@@ -1335,16 +1396,12 @@
> 						trueLabel,
> 						falseLabel,
> 						false);
>-					if ((bits & OnlyValueRequired) != 0) {
>-						right.generateCode(currentScope, codeStream, valueRequired);
>-					} else {
>-						right.generateOptimizedBoolean(
>-							currentScope,
>-							codeStream,
>-							trueLabel,
>-							falseLabel,
>-							valueRequired);
>-					}
>+					right.generateOptimizedBoolean(
>+						currentScope,
>+						codeStream,
>+						trueLabel,
>+						falseLabel,
>+						valueRequired);
> 				}
> 				return;
> 			}
>@@ -1366,28 +1423,20 @@
> 						falseLabel,
> 						false);
> 					if (valueRequired) {
>-						if ((bits & OnlyValueRequired) != 0) {
>-							codeStream.iconst_1();
>-						} else {
>-							if (trueLabel != null) {
>-								codeStream.goto_(trueLabel);
>-							}
>+						if (trueLabel != null) {
>+							codeStream.goto_(trueLabel);
> 						}
> 					}
> 					// reposition the endPC
> 					codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);					
> 				} else {
> 					// x | <something equivalent to false>
>-					if ((bits & OnlyValueRequired) != 0) {
>-						left.generateCode(currentScope, codeStream, valueRequired);
>-					} else {
>-						left.generateOptimizedBoolean(
>-							currentScope,
>-							codeStream,
>-							trueLabel,
>-							falseLabel,
>-							valueRequired);
>-					}
>+					left.generateOptimizedBoolean(
>+						currentScope,
>+						codeStream,
>+						trueLabel,
>+						falseLabel,
>+						valueRequired);
> 					right.generateOptimizedBoolean(
> 						currentScope,
> 						codeStream,
>@@ -1403,19 +1452,17 @@
> 		right.generateCode(currentScope, codeStream, valueRequired);
> 		if (valueRequired) {
> 			codeStream.ior();
>-			if ((bits & OnlyValueRequired) == 0) {
>-				if (falseLabel == null) {
>-					if (trueLabel != null) {
>-						// implicit falling through the FALSE case
>-						codeStream.ifne(trueLabel);
>-					}
>+			if (falseLabel == null) {
>+				if (trueLabel != null) {
>+					// implicit falling through the FALSE case
>+					codeStream.ifne(trueLabel);
>+				}
>+			} else {
>+				// implicit falling through the TRUE case
>+				if (trueLabel == null) {
>+					codeStream.ifeq(falseLabel);
> 				} else {
>-					// implicit falling through the TRUE case
>-					if (trueLabel == null) {
>-						codeStream.ifeq(falseLabel);
>-					} else {
>-						// no implicit fall through TRUE/FALSE --> should never occur
>-					}
>+					// no implicit fall through TRUE/FALSE --> should never occur
> 				}
> 			}
> 		}
>@@ -1447,7 +1494,7 @@
> 					right.generateOptimizedBoolean(
> 						currentScope,
> 						codeStream,
>-						falseLabel,
>+						falseLabel, // negating
> 						trueLabel,
> 						valueRequired);
> 				} else {
>@@ -1458,16 +1505,12 @@
> 						trueLabel,
> 						falseLabel,
> 						false);
>-					if ((bits & OnlyValueRequired) != 0) {
>-						right.generateCode(currentScope, codeStream, valueRequired);
>-					} else {
>-						right.generateOptimizedBoolean(
>-							currentScope,
>-							codeStream,
>-							trueLabel,
>-							falseLabel,
>-							valueRequired);
>-					}
>+					right.generateOptimizedBoolean(
>+						currentScope,
>+						codeStream,
>+						trueLabel,
>+						falseLabel,
>+						valueRequired);
> 				}
> 				return;
> 			}
>@@ -1477,7 +1520,7 @@
> 					left.generateOptimizedBoolean(
> 						currentScope,
> 						codeStream,
>-						falseLabel,
>+						falseLabel, // negating
> 						trueLabel,
> 						valueRequired);
> 					right.generateOptimizedBoolean(
>@@ -1488,16 +1531,12 @@
> 						false);
> 				} else {
> 					// x ^ <something equivalent to false>
>-					if ((bits & OnlyValueRequired) != 0) {
>-						left.generateCode(currentScope, codeStream, valueRequired);
>-					} else {
>-						left.generateOptimizedBoolean(
>-							currentScope,
>-							codeStream,
>-							trueLabel,
>-							falseLabel,
>-							valueRequired);
>-					}
>+					left.generateOptimizedBoolean(
>+						currentScope,
>+						codeStream,
>+						trueLabel,
>+						falseLabel,
>+						valueRequired);
> 					right.generateOptimizedBoolean(
> 						currentScope,
> 						codeStream,
>@@ -1513,19 +1552,17 @@
> 		right.generateCode(currentScope, codeStream, valueRequired);
> 		if (valueRequired) {
> 			codeStream.ixor();
>-			if ((bits & OnlyValueRequired) == 0) {
>-				if (falseLabel == null) {
>-					if (trueLabel != null) {
>-						// implicit falling through the FALSE case
>-						codeStream.ifne(trueLabel);
>-					}
>+			if (falseLabel == null) {
>+				if (trueLabel != null) {
>+					// implicit falling through the FALSE case
>+					codeStream.ifne(trueLabel);
>+				}
>+			} else {
>+				// implicit falling through the TRUE case
>+				if (trueLabel == null) {
>+					codeStream.ifeq(falseLabel);
> 				} else {
>-					// implicit falling through the TRUE case
>-					if (trueLabel == null) {
>-						codeStream.ifeq(falseLabel);
>-					} else {
>-						// no implicit fall through TRUE/FALSE --> should never occur
>-					}
>+					// no implicit fall through TRUE/FALSE --> should never occur
> 				}
> 			}
> 		}
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java,v
>retrieving revision 1.57
>diff -u -r1.57 EqualExpression.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java	18 Nov 2005 16:46:22 -0000	1.57
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java	24 Nov 2005 14:04:05 -0000
>@@ -126,45 +126,23 @@
> 	 */
> 	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
> 	
>+		int pc = codeStream.position;
> 		if (constant != Constant.NotAConstant) {
>-			int pc = codeStream.position;
> 			if (valueRequired) 
> 				codeStream.generateConstant(constant, implicitConversion);
> 			codeStream.recordPositionsFrom(pc, this.sourceStart);
> 			return;
> 		}
>-		Label falseLabel;
>-		bits |= OnlyValueRequired;
>-		generateOptimizedBoolean(
>-			currentScope, 
>-			codeStream, 
>-			null, 
>-			falseLabel = new Label(codeStream), 
>-			valueRequired);
>-		if (falseLabel.hasForwardReferences()) {
>-			if (valueRequired){
>-				// comparison is TRUE 
>-				codeStream.iconst_1();
>-				if ((bits & IsReturnedValue) != 0){
>-					codeStream.generateImplicitConversion(this.implicitConversion);
>-					codeStream.generateReturnBytecode(this);
>-					// comparison is FALSE
>-					falseLabel.place();
>-					codeStream.iconst_0();
>-				} else {
>-					Label endLabel = new Label(codeStream);
>-					codeStream.goto_(endLabel);
>-					codeStream.decrStackSize(1);
>-					// comparison is FALSE
>-					falseLabel.place();
>-					codeStream.iconst_0();
>-					endLabel.place();
>-				}
>-				codeStream.generateImplicitConversion(implicitConversion);
>-			} else {
>-				falseLabel.place();
>-			}	
>+		
>+		if ((left.implicitConversion & COMPILE_TYPE_MASK) /*compile-time*/ == T_boolean) {
>+			generateBooleanEqual(currentScope, codeStream, valueRequired);
>+		} else {
>+			generateNonBooleanEqual(currentScope, codeStream, valueRequired);
> 		}
>+		if (valueRequired) {
>+			codeStream.generateImplicitConversion(implicitConversion);
>+		}
>+		codeStream.recordPositionsFrom(pc, this.sourceStart);
> 	}
> 	/**
> 	 * Boolean operator code generation
>@@ -190,6 +168,150 @@
> 			}
> 		}
> 	}
>+
>+	/**
>+	 * Boolean generation for == with boolean operands
>+	 *
>+	 * Note this code does not optimize conditional constants !!!!
>+	 */
>+	public void generateBooleanEqual(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
>+	
>+		// optimized cases: <something equivalent to true> == x, <something equivalent to false> == x, 
>+		// optimized cases: <something equivalent to false> != x, <something equivalent to true> != x, 
>+		Constant cst = left.optimizedBooleanConstant();
>+		if (cst != Constant.NotAConstant) {
>+			Constant rightCst = right.optimizedBooleanConstant();
>+			if (rightCst != Constant.NotAConstant) {
>+				// <something equivalent to true> == <something equivalent to true>, <something equivalent to false> != <something equivalent to true>
>+				// <something equivalent to true> == <something equivalent to false>, <something equivalent to false> != <something equivalent to false>
>+				left.generateCode(currentScope, codeStream, false);
>+				right.generateCode(currentScope, codeStream, false);
>+				if (valueRequired) {
>+					boolean leftBool = cst.booleanValue();
>+					boolean rightBool = rightCst.booleanValue();
>+					if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>+						if (leftBool == rightBool) {
>+							codeStream.iconst_1();
>+						} else {
>+							codeStream.iconst_0();
>+						}
>+					} else {
>+						if (leftBool != rightBool) {
>+							codeStream.iconst_1();
>+						} else {
>+							codeStream.iconst_0();
>+						}
>+					}
>+				}
>+			} else if (cst.booleanValue() == (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL)) {
>+				// <something equivalent to true> == x, <something equivalent to false> != x
>+				left.generateCode(currentScope, codeStream, false);
>+				right.generateCode(currentScope, codeStream, valueRequired);
>+			} else {
>+				// <something equivalent to false> == x, <something equivalent to true> != x
>+				if (valueRequired) {
>+					Label falseLabel = new Label(codeStream);
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateOptimizedBoolean(currentScope, codeStream, null, falseLabel, valueRequired);
>+					// comparison is TRUE 
>+					codeStream.iconst_0();
>+					if ((bits & IsReturnedValue) != 0){
>+						codeStream.generateImplicitConversion(this.implicitConversion);
>+						codeStream.generateReturnBytecode(this);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_1();
>+					} else {
>+						Label endLabel = new Label(codeStream);
>+						codeStream.goto_(endLabel);
>+						codeStream.decrStackSize(1);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_1();
>+						endLabel.place();
>+					}
>+				} else {
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, false);
>+				}
>+//				left.generateCode(currentScope, codeStream, false);
>+//				right.generateCode(currentScope, codeStream, valueRequired);
>+//				if (valueRequired) {
>+//					codeStream.iconst_1();
>+//					codeStream.ixor(); // negate
>+//				}
>+			}
>+			return;
>+		} 
>+		cst = right.optimizedBooleanConstant();
>+		if (cst != Constant.NotAConstant) {
>+			if (cst.booleanValue() == (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL)) {
>+				// x == <something equivalent to true>, x != <something equivalent to false>
>+				left.generateCode(currentScope, codeStream, valueRequired);
>+				right.generateCode(currentScope, codeStream, false);
>+			} else {
>+				// x == <something equivalent to false>, x != <something equivalent to true>
>+				if (valueRequired) {
>+					Label falseLabel = new Label(codeStream);
>+					left.generateOptimizedBoolean(currentScope, codeStream, null, falseLabel, valueRequired);
>+					right.generateCode(currentScope, codeStream, false);
>+					// comparison is TRUE 
>+					codeStream.iconst_0();
>+					if ((bits & IsReturnedValue) != 0){
>+						codeStream.generateImplicitConversion(this.implicitConversion);
>+						codeStream.generateReturnBytecode(this);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_1();
>+					} else {
>+						Label endLabel = new Label(codeStream);
>+						codeStream.goto_(endLabel);
>+						codeStream.decrStackSize(1);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_1();
>+						endLabel.place();
>+					}
>+				} else {
>+					left.generateCode(currentScope, codeStream, false);
>+					right.generateCode(currentScope, codeStream, false);
>+				}
>+//				left.generateCode(currentScope, codeStream, valueRequired);
>+//				right.generateCode(currentScope, codeStream, false);
>+//				if (valueRequired) {
>+//					codeStream.iconst_1();
>+//					codeStream.ixor(); // negate
>+//				}
>+			}
>+			return;
>+		} 
>+		// default case
>+		left.generateCode(currentScope, codeStream, valueRequired);
>+		right.generateCode(currentScope, codeStream, valueRequired);
>+
>+		if (valueRequired) {
>+			Label falseLabel;
>+			codeStream.if_icmpne(falseLabel = new Label(codeStream));
>+			// comparison is TRUE 
>+			codeStream.iconst_1();
>+			if ((bits & IsReturnedValue) != 0){
>+				codeStream.generateImplicitConversion(this.implicitConversion);
>+				codeStream.generateReturnBytecode(this);
>+				// comparison is FALSE
>+				falseLabel.place();
>+				codeStream.iconst_0();
>+			} else {
>+				Label endLabel = new Label(codeStream);
>+				codeStream.goto_(endLabel);
>+				codeStream.decrStackSize(1);
>+				// comparison is FALSE
>+				falseLabel.place();
>+				codeStream.iconst_0();
>+				endLabel.place();
>+			}
>+		}
>+	}
>+	
> 	/**
> 	 * Boolean generation for == with boolean operands
> 	 *
>@@ -233,6 +355,192 @@
> 	 * Boolean generation for == with non-boolean operands
> 	 *
> 	 */
>+	public void generateNonBooleanEqual(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
>+	
>+		if (((left.implicitConversion & IMPLICIT_CONVERSION_MASK) >> 4) == T_int) {
>+			Constant cst;
>+			if ((cst = left.constant) != Constant.NotAConstant && cst.intValue() == 0) {
>+				// optimized case: 0 == x, 0 != x
>+				right.generateCode(currentScope, codeStream, valueRequired);
>+				if (valueRequired) {
>+					Label falseLabel = new Label(codeStream);
>+					if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>+						codeStream.ifne(falseLabel);
>+					} else {
>+						codeStream.ifeq(falseLabel);
>+					}
>+					// comparison is TRUE 
>+					codeStream.iconst_1();
>+					if ((bits & IsReturnedValue) != 0){
>+						codeStream.generateImplicitConversion(this.implicitConversion);
>+						codeStream.generateReturnBytecode(this);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_0();
>+					} else {
>+						Label endLabel = new Label(codeStream);
>+						codeStream.goto_(endLabel);
>+						codeStream.decrStackSize(1);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_0();
>+						endLabel.place();
>+					}
>+				}				
>+				return;
>+			}
>+			if ((cst = right.constant) != Constant.NotAConstant && cst.intValue() == 0) {
>+				// optimized case: x == 0, x != 0
>+				left.generateCode(currentScope, codeStream, valueRequired);
>+				if (valueRequired) {
>+					Label falseLabel = new Label(codeStream);
>+					if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>+						codeStream.ifne(falseLabel);
>+					} else {
>+						codeStream.ifeq(falseLabel);
>+					}
>+					// comparison is TRUE 
>+					codeStream.iconst_1();
>+					if ((bits & IsReturnedValue) != 0){
>+						codeStream.generateImplicitConversion(this.implicitConversion);
>+						codeStream.generateReturnBytecode(this);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_0();
>+					} else {
>+						Label endLabel = new Label(codeStream);
>+						codeStream.goto_(endLabel);
>+						codeStream.decrStackSize(1);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_0();
>+						endLabel.place();
>+					}
>+				}				
>+				return;
>+			}			
>+		}
>+
>+		// null cases
>+		if (right instanceof NullLiteral) {
>+			if (left instanceof NullLiteral) {
>+				// null == null, null != null
>+				if (valueRequired) {
>+					if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>+						codeStream.iconst_1();
>+					} else {
>+						codeStream.iconst_0();
>+					}
>+				}
>+			} else {
>+				// x == null, x != null
>+				left.generateCode(currentScope, codeStream, valueRequired);
>+				if (valueRequired) {
>+					Label falseLabel = new Label(codeStream);
>+					if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>+						codeStream.ifnonnull(falseLabel);
>+					} else {
>+						codeStream.ifnull(falseLabel);
>+					}
>+					// comparison is TRUE 
>+					codeStream.iconst_1();
>+					if ((bits & IsReturnedValue) != 0){
>+						codeStream.generateImplicitConversion(this.implicitConversion);
>+						codeStream.generateReturnBytecode(this);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_0();
>+					} else {
>+						Label endLabel = new Label(codeStream);
>+						codeStream.goto_(endLabel);
>+						codeStream.decrStackSize(1);
>+						// comparison is FALSE
>+						falseLabel.place();
>+						codeStream.iconst_0();
>+						endLabel.place();
>+					}
>+				}
>+			}
>+			return;
>+		} else if (left instanceof NullLiteral) {
>+			// null = x, null != x
>+			right.generateCode(currentScope, codeStream, valueRequired);
>+			if (valueRequired) {
>+				Label falseLabel = new Label(codeStream);
>+				if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>+					codeStream.ifnonnull(falseLabel);
>+				} else {
>+					codeStream.ifnull(falseLabel);
>+				}
>+				// comparison is TRUE 
>+				codeStream.iconst_1();
>+				if ((bits & IsReturnedValue) != 0){
>+					codeStream.generateImplicitConversion(this.implicitConversion);
>+					codeStream.generateReturnBytecode(this);
>+					// comparison is FALSE
>+					falseLabel.place();
>+					codeStream.iconst_0();
>+				} else {
>+					Label endLabel = new Label(codeStream);
>+					codeStream.goto_(endLabel);
>+					codeStream.decrStackSize(1);
>+					// comparison is FALSE
>+					falseLabel.place();
>+					codeStream.iconst_0();
>+					endLabel.place();
>+				}
>+			}				
>+			return;
>+		}
>+	
>+		// default case
>+		left.generateCode(currentScope, codeStream, valueRequired);
>+		right.generateCode(currentScope, codeStream, valueRequired);
>+		if (valueRequired) {
>+			Label falseLabel = new Label(codeStream);
>+			switch ((left.implicitConversion & IMPLICIT_CONVERSION_MASK) >> 4) { // operand runtime type
>+				case T_int :
>+					codeStream.if_icmpne(falseLabel);
>+					break;
>+				case T_float :
>+					codeStream.fcmpl();
>+					codeStream.ifne(falseLabel);
>+					break;
>+				case T_long :
>+					codeStream.lcmp();
>+					codeStream.ifne(falseLabel);
>+					break;
>+				case T_double :
>+					codeStream.dcmpl();
>+					codeStream.ifne(falseLabel);
>+					break;
>+				default :
>+					codeStream.if_acmpne(falseLabel);
>+			}
>+			// comparison is TRUE 
>+			codeStream.iconst_1();
>+			if ((bits & IsReturnedValue) != 0){
>+				codeStream.generateImplicitConversion(this.implicitConversion);
>+				codeStream.generateReturnBytecode(this);
>+				// comparison is FALSE
>+				falseLabel.place();
>+				codeStream.iconst_0();
>+			} else {
>+				Label endLabel = new Label(codeStream);
>+				codeStream.goto_(endLabel);
>+				codeStream.decrStackSize(1);
>+				// comparison is FALSE
>+				falseLabel.place();
>+				codeStream.iconst_0();
>+				endLabel.place();
>+			}			
>+		}
>+	}
>+	
>+	/**
>+	 * Boolean generation for == with non-boolean operands
>+	 *
>+	 */
> 	public void generateOptimizedNonBooleanEqual(BlockScope currentScope, CodeStream codeStream, Label trueLabel, Label falseLabel, boolean valueRequired) {
> 	
> 		int pc = codeStream.position;
>@@ -290,19 +598,11 @@
> 			if (left instanceof NullLiteral) {
> 				// null == null
> 				if (valueRequired) {
>-						if ((bits & OnlyValueRequired) != 0) {
>-							if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
>-								codeStream.iconst_1();
>-							} else {
>-								codeStream.iconst_0();
>-							}
>-						} else {
>-							if (falseLabel == null) {
>-								// implicit falling through the FALSE case
>-								if (trueLabel != null) {
>-									codeStream.goto_(trueLabel);
>-								}
>-							}
>+					if (falseLabel == null) {
>+						// implicit falling through the FALSE case
>+						if (trueLabel != null) {
>+							codeStream.goto_(trueLabel);
>+						}
> 					}
> 				}
> 			} else {
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java,v
>retrieving revision 1.53
>diff -u -r1.53 ASTNode.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java	18 Nov 2005 16:46:23 -0000	1.53
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java	24 Nov 2005 14:04:03 -0000
>@@ -25,7 +25,7 @@
> 	public final static int Bit3 = 0x4; 						// return type (operator) | name reference kind (name ref) | implicit this (this ref)
> 	public final static int Bit4 = 0x8; 						// return type (operator) | first assignment to local (local decl) | undocumented empty block (block, type and method decl)
> 	public final static int Bit5 = 0x10; 						// value for return (expression) | has all method bodies (unit) | supertype ref (type ref)
>-	public final static int Bit6 = 0x20; 						// depth (name ref, msg) | only value required (binary expression) | ignore need cast check (cast expression)
>+	public final static int Bit6 = 0x20; 						// depth (name ref, msg) | ignore need cast check (cast expression)
> 	public final static int Bit7 = 0x40; 						// depth (name ref, msg) | operator (operator) | need runtime checkcast (cast expression) | label used (labelStatement)
> 	public final static int Bit8 = 0x80; 						// depth (name ref, msg) | operator (operator) | unsafe cast (cast expression)
> 	public final static int Bit9 = 0x100; 					// depth (name ref, msg) | operator (operator) | is local type (type decl)
>@@ -88,7 +88,6 @@
> 
> 	// for binary expressions
> 	public static final int IsReturnedValue = Bit5; 
>-	public static final int OnlyValueRequired = Bit6; 
> 
> 	// for cast expressions
> 	public static final int UnnecessaryCast = Bit15;
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java,v
>retrieving revision 1.80
>diff -u -r1.80 SingleNameReference.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java	18 Nov 2005 16:46:21 -0000	1.80
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java	24 Nov 2005 14:04:05 -0000
>@@ -342,7 +342,7 @@
> 							codeStream.generateConstant(fieldConstant, implicitConversion);
> 						}
> 					} else {
>-						if (valueRequired || currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {
>+						if (valueRequired) {
> 							boolean isStatic = fieldBinding.isStatic();
> 							if (!isStatic) {
> 								if ((bits & DepthMASK) != 0) {

Actions: View | Diff

Attachments on bug 117120: 30549