Merge branch 'master' of ssh://git.kenai.com/gluegen~gluegen-git

4 files changed, 237 insertions, 131 deletions

diff --git a/src/java/com/sun/gluegen/JavaEmitter.java b/src/java/com/sun/gluegen/JavaEmitter.java
index 1667ed6..c9a54e3 100644
--- a/src/java/com/sun/gluegen/JavaEmitter.java
+++ b/src/java/com/sun/gluegen/JavaEmitter.java
@@ -133,14 +133,10 @@ public class JavaEmitter implements GlueEmitter {
     }
   }
 
-  public void beginEmission(GlueEmitterControls controls) throws IOException
-  {
-    try
-    {
+  public void beginEmission(GlueEmitterControls controls) throws IOException  {
+    try {
       openWriters();
-    }
-    catch (Exception e)
-    {
+    } catch (Exception e)  {
       throw new RuntimeException(
         "Unable to open files for writing", e);
     }
@@ -156,30 +152,24 @@ public class JavaEmitter implements GlueEmitter {
     controls.runSymbolFilter(new ConstantRenamer());
   }
 
-  public void endEmission()
-  {
+  public void endEmission()  {
     emitAllFileFooters();
 
-    try
-    {
+    try  {
       closeWriters();
-    }
-    catch (Exception e)
-    {
+    } catch (Exception e)  {
       throw new RuntimeException(
         "Unable to close open files", e);
     }
   }
 
-  public void beginDefines() throws Exception
-  {
+  public void beginDefines() throws Exception {
     if (cfg.allStatic() || cfg.emitInterface()) {
       javaWriter().println();
     }
   }
 
-  protected static int getJavaRadix(String name, String value) 
-  {
+  protected static int getJavaRadix(String name, String value)  {
     // FIXME: need to handle when type specifier is in last char (e.g.,
     // "1.0d or 2759L", because parseXXX() methods don't allow the type
     // specifier character in the string.
@@ -222,14 +212,59 @@ public class JavaEmitter implements GlueEmitter {
     }
   }
 
-  protected static Object getJavaValue(String name, String value) 
-  {
+  protected static Object getJavaValue(String name, String value) {
+
+    // "calculates" the result type of a simple expression
+    // example: (2+3)-(2.0f-3.0) -> Double
+    // example: (1 << 2) -> Integer
+
+    Scanner scanner = new Scanner(value).useDelimiter("[+-/*/></(/)]");
+
+    Object resultType = null;
+
+    while (scanner.hasNext()) {
+
+        String t = scanner.next().trim();
+
+        if(!t.isEmpty()) {
+            Object type = getJavaValue2(name, t);
+
+            //fast path
+            if(type instanceof Double)
+                return type;
+
+            if(resultType != null) {
+
+                if(resultType instanceof Integer) {
+                    if(type instanceof Long || type instanceof Float || type instanceof Double)
+                        resultType = type;
+                }else if(resultType instanceof Long) {
+                    if(type instanceof Float || type instanceof Double)
+                        resultType = type;
+                }else if(resultType instanceof Float) {
+                    if(type instanceof Float)
+                        resultType = type;
+                }
+            }else{
+                resultType = type;
+            }
+
+            //fast path
+            if(resultType instanceof Double)
+                return type;
+        }
+    }
+
+    return resultType;
+  }
+
+  private static Object getJavaValue2(String name, String value) {
     // FIXME: need to handle when type specifier is in last char (e.g.,
     // "1.0d or 2759L", because parseXXX() methods don't allow the type
     // specifier character in the string.
     //
     //char lastChar = value.charAt(value.length()-1);
-    
+
     try {
       // see if it's a long or int
       int radix;
@@ -243,7 +278,7 @@ public class JavaEmitter implements GlueEmitter {
       }
       else if (value.startsWith("0") && value.length() > 1) {
         // TODO: is "0" the prefix in C to indicate octal???
-        radix = 8; 
+        radix = 8;
         parseValue = value.substring(1);
       }
       else {
@@ -257,7 +292,7 @@ public class JavaEmitter implements GlueEmitter {
         return new Integer((int)longVal);
       }
       return new Long(longVal);
-      
+
     } catch (NumberFormatException e) {
       try {
         // see if it's a double or float
@@ -268,7 +303,7 @@ public class JavaEmitter implements GlueEmitter {
             return new Double(dVal);
         }
         return new Float((float) dVal);
-      } catch (NumberFormatException e2) {            
+      } catch (NumberFormatException e2) {
         throw new RuntimeException(
           "Cannot emit define \""+name+"\": value \""+value+
           "\" cannot be assigned to a int, long, float, or double", e2);
@@ -276,6 +311,7 @@ public class JavaEmitter implements GlueEmitter {
     }
   }
 
+
   protected static String getJavaType(String name, String value) {
     Object oval = getJavaValue(name, value);
     return getJavaType(name, oval);
@@ -297,8 +333,8 @@ public class JavaEmitter implements GlueEmitter {
       "\" cannot be assigned to a int, long, float, or double");
   }
 
-  public void emitDefine(ConstantDefinition def, String optionalComment) throws Exception
-  {
+  public void emitDefine(ConstantDefinition def, String optionalComment) throws Exception  {
+
     if (cfg.allStatic() || cfg.emitInterface()) {
       // TODO: Some defines (e.g., GL_DOUBLE_EXT in gl.h) are defined in terms
       // of other defines -- should we emit them as references to the original
@@ -325,8 +361,7 @@ public class JavaEmitter implements GlueEmitter {
     }
   }
 
-  public void endDefines() throws Exception
-  {
+  public void endDefines() throws Exception {
   }
 
   public void beginFunctions(TypeDictionary typedefDictionary,
diff --git a/src/java/com/sun/gluegen/cgram/StdCParser.g b/src/java/com/sun/gluegen/cgram/StdCParser.g
index e84fbfd..65e7936 100644
--- a/src/java/com/sun/gluegen/cgram/StdCParser.g
+++ b/src/java/com/sun/gluegen/cgram/StdCParser.g
@@ -1112,22 +1112,33 @@ options {
         :
         '#'
         ( ( "line" || (( ' ' | '\t' | '\014')+ '0'..'9')) => LineDirective      
-        | ( (Space)* "define" (Space)* i:ID (Space)* (n:Number)?
+        | ( (Space)* "define" (Space)* i:ID (Space)* (n:DefineExpr)?
             nw:NonWhitespace
-            ("\r\n" | "\r" | "\n") )               { if (n != null) {
+            ("\r\n" | "\r" | "\n") )               {
+                                                     if (n != null) {
+                                                       //System.out.println("addDefine: #define " + i.getText() + " " +  n.getText());
                                                        addDefine(i.getText(), n.getText());
                                                      } else {
-                                                       setPreprocessingDirective("#define " + i.getText() + " " + 
-                                                                                 nw.getText());
+                                                       setPreprocessingDirective("#define " + i.getText() + " " + nw.getText());
                                                      }
                                                    }
         | (~'\n')*                                 { setPreprocessingDirective(getText()); }
         )
-                {  
+                {
                     _ttype = Token.SKIP;
                 }
         ;
 
+DefineExpr:
+    ((LPAREN) (Space)* (DefineExpr2) (Space)* (RPAREN)) | (DefineExpr2)
+;
+
+DefineExpr2:
+    (Number)
+    ((Space)* (LSHIFT | RSHIFT | PLUS | MINUS | STAR | DIV | MOD) (Space)* (DefineExpr))?
+;
+
+
 protected  Space:
         ( ' ' | '\t' | '\014')
         ;
diff --git a/src/java/com/sun/gluegen/pcpp/ConcatenatingReader.java b/src/java/com/sun/gluegen/pcpp/ConcatenatingReader.java
index 11249f7..6da77be 100755
--- a/src/java/com/sun/gluegen/pcpp/ConcatenatingReader.java
+++ b/src/java/com/sun/gluegen/pcpp/ConcatenatingReader.java
@@ -48,16 +48,17 @@ public class ConcatenatingReader extends FilterReader {
     // Any leftover characters go here
     private char[] curBuf;
     private int    curPos;
-    private BufferedReader in;
+    private BufferedReader reader;
     private static String newline = System.getProperty("line.separator");
 
     /** This class requires that the input reader be a BufferedReader so
         it can do line-oriented operations. */
     public ConcatenatingReader(BufferedReader in) {
         super(in);
-        this.in = in;
+        this.reader = in;
     }
 
+    @Override
     public int read() throws IOException {
         char[] tmp = new char[1];
         int num = read(tmp, 0, 1);
@@ -67,24 +68,29 @@ public class ConcatenatingReader extends FilterReader {
     }
 
     // It's easier not to support mark/reset since we don't need it
+    @Override
     public boolean markSupported() {
         return false;
     }
 
+    @Override
     public void mark(int readAheadLimit) throws IOException {
         throw new IOException("mark/reset not supported");
     }
 
+    @Override
     public void reset() throws IOException {
         throw new IOException("mark/reset not supported");
     }
 
+    @Override
     public boolean ready() throws IOException {
-        if (curBuf != null || in.ready())
+        if (curBuf != null || reader.ready())
             return true;
         return false;
     }
 
+    @Override
     public int read(char[] cbuf, int off, int len) throws IOException {
         if (curBuf == null) {
             nextLine();
@@ -110,6 +116,7 @@ public class ConcatenatingReader extends FilterReader {
         return numRead;
     }
 
+    @Override
     public long skip(long n) throws IOException {
         long numSkipped = 0;
 
@@ -126,7 +133,7 @@ public class ConcatenatingReader extends FilterReader {
     }
 
     private void nextLine() throws IOException {
-        String cur = in.readLine();
+        String cur = reader.readLine();
         if (cur == null) {
             curBuf = null;
             return;
diff --git a/src/java/com/sun/gluegen/pcpp/PCPP.java b/src/java/com/sun/gluegen/pcpp/PCPP.java
index 7303c04..05580a8 100644
--- a/src/java/com/sun/gluegen/pcpp/PCPP.java
+++ b/src/java/com/sun/gluegen/pcpp/PCPP.java
@@ -1,21 +1,21 @@
 /*
  * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
- * 
+ *
  * - Redistribution of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * 
+ *
  * - Redistribution in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
- * 
+ *
  * Neither the name of Sun Microsystems, Inc. or the names of
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
- * 
+ *
  * This software is provided "AS IS," without a warranty of any kind. ALL
  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
  * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
@@ -28,11 +28,11 @@
  * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
  * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
  * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
+ *
  * You acknowledge that this software is not designed or intended for use
  * in the design, construction, operation or maintenance of any nuclear
  * facility.
- * 
+ *
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
@@ -49,7 +49,7 @@ import java.util.*;
 public class PCPP {
     private static final boolean disableDebugPrint = true;
 
-    public PCPP(List/*<String>*/ includePaths) {
+    public PCPP(List<String> includePaths) {
         this.includePaths = includePaths;
         setOut(System.out);
     }
@@ -99,7 +99,7 @@ public class PCPP {
                 usage();
             }
 
-            List includePaths = new ArrayList();
+            List<String> includePaths = new ArrayList<String>();
             for (int i = 0; i < args.length; i++) {
                 if (i < args.length - 1) {
                     String arg = args[i];
@@ -134,8 +134,7 @@ public class PCPP {
 
     public String findFile(String filename) {
         String sep = File.separator;
-        for (Iterator iter = includePaths.iterator(); iter.hasNext(); ) {
-            String inclPath = (String) iter.next();
+        for (String inclPath : includePaths) {
             String fullPath = inclPath + sep + filename;
             File file = new File(fullPath);
             if (file.exists()) {
@@ -163,24 +162,22 @@ public class PCPP {
         to constants.  Macros and multi-line defines (which typically
         contain either macro definitions or expressions) are currently
         not handled. */
-    private Map/*<String, String>*/ defineMap          = new HashMap();
-    private Set/*<String>*/         nonConstantDefines = new HashSet();
+    private Map<String, String> defineMap          = new HashMap<String, String>(128);
+    private Set<String>         nonConstantDefines = new HashSet<String>(128);
 
     /** List containing the #include paths as Strings */
-    private List/*<String>*/ includePaths;
+    private List<String> includePaths;
 
     // State
     static class ParseState {
         private StreamTokenizer tok;
         private String          filename;
-        private int             lineNumber;
         private boolean         startOfLine;
         private boolean         startOfFile;
 
         ParseState(StreamTokenizer tok, String filename) {
             this.tok = tok;
             this.filename = filename;
-            lineNumber = 1;
             startOfLine = true;
             startOfFile = true;
         }
@@ -235,7 +232,7 @@ public class PCPP {
         }
         return val;
     }
-  
+
     /**
      * Reads the next token and throws an IOException if it is not the specified
      * token character.
@@ -246,8 +243,8 @@ public class PCPP {
             String msg = "Expected token '" + requiredToken + "' but got ";
             switch (nextTok) {
                 case StreamTokenizer.TT_EOF: msg += "<EOF>"; break;
-                case StreamTokenizer.TT_EOL: msg += "<EOL>"; break;    
-                default: msg += "'" + curTokenAsString() + "'"; break;    
+                case StreamTokenizer.TT_EOL: msg += "<EOL>"; break;
+                default: msg += "'" + curTokenAsString() + "'"; break;
             }
             msg += " at file " + filename() + ", line " + lineNumber();
             throw new IOException(msg);
@@ -268,11 +265,11 @@ public class PCPP {
         }
         char c = (char) t;
         if (c == '"' || c == '\'') {
-            StringBuffer buf = new StringBuffer();
-            buf.append(c);
-            buf.append(state.tok().sval);
-            buf.append(c);
-            return buf.toString();
+            StringBuilder sb = new StringBuilder();
+            sb.append(c);
+            sb.append(state.tok().sval);
+            sb.append(c);
+            return sb.toString();
         }
         return new String(new char[] { c });
     }
@@ -315,14 +312,14 @@ public class PCPP {
             } else {
                 // Output white space plus current token, handling #defines
                 // (though not properly -- only handling #defines to constants and the empty string)
-                
+
                 // !!HACK!! - print space only for word tokens. This way multicharacter
-                // operators such as ==, != etc. are property printed. 
+                // operators such as ==, != etc. are property printed.
                 if (tok == StreamTokenizer.TT_WORD) {
                     print(" ");
                 }
                 String s = curTokenAsString();
-                String newS = (String) defineMap.get(s);
+                String newS = defineMap.get(s);
                 if (newS == null) {
                     newS = s;
                 }
@@ -372,35 +369,35 @@ public class PCPP {
     private void handleUndefine() throws IOException {
         // Next token is the name of the #undef
         String name = nextWord();
-    
+
         debugPrint(true, "#undef " + name);
 
         // there shouldn't be any extra symbols after the name, but just in case...
-        List values = new ArrayList();
+        List<String> values = new ArrayList<String>();
         while (nextToken(true) != StreamTokenizer.TT_EOL) {
             values.add(curTokenAsString());
         }
 
         if (enabled()) {
-            String oldDef = (String)defineMap.remove(name);
+            String oldDef = defineMap.remove(name);
             if (oldDef == null) {
                 System.err.println("WARNING: ignoring redundant \"#undef " +
                                    name + "\", at \"" + filename() + "\" line " + lineNumber() +
                                    ": \"" + name + "\" was not previously defined");
             } else {
-                // System.err.println("UNDEFINED: '" + name + "'  (line " + lineNumber() + " file " + filename() + ")");        
-            }      
+                // System.err.println("UNDEFINED: '" + name + "'  (line " + lineNumber() + " file " + filename() + ")");
+            }
             nonConstantDefines.remove(name);
         }
-        else System.err.println("FAILED TO UNDEFINE: '" + name + "'  (line " + lineNumber() + " file " + filename() + ")"); 
+        else System.err.println("FAILED TO UNDEFINE: '" + name + "'  (line " + lineNumber() + " file " + filename() + ")");
     }
-  
+
     private void handleDefine() throws IOException {
         // Next token is the name of the #define
         String name = nextWord();
         //System.err.println("IN HANDLE_DEFINE: '" + name + "'  (line " + lineNumber() + " file " + filename() + ")");
         // (Note that this is not actually proper handling for multi-line #defines)
-        List values = new ArrayList();
+        List<String> values = new ArrayList<String>();
         while (nextToken(true) != StreamTokenizer.TT_EOL) {
             values.add(curTokenAsString());
         }
@@ -410,13 +407,13 @@ public class PCPP {
         debugPrint(true, "#define " + name);
         if (enabled()) {
             boolean emitDefine = true;
-     
+
             // Handle #definitions to nothing or to a constant value
             int sz = values.size();
             if (sz == 0) {
                 // definition to nothing, like "#define FOO"
                 String value = "";
-                String oldDef = (String) defineMap.put(name, value);
+                String oldDef = defineMap.put(name, value);
                 if (oldDef != null && !oldDef.equals(value)) {
                     System.err.println("WARNING: \"" + name + "\" redefined from \"" +
                                        oldDef + "\" to \"\"");
@@ -425,13 +422,14 @@ public class PCPP {
                 // and cause GlueGen errors (confuse the GnuCParser)
                 emitDefine = false;
                 //System.out.println("//---DEFINED: " + name + "to \"\"");
-            } else if (sz == 1) {        
+            } else if (sz == 1) {
                 // See whether the value is a constant
-                String value = (String) values.get(0);
-                if (isConstant(value)) {           
+                String value = values.get(0);
+
+                if (isConstant(value)) {
                     // Value is numeric constant like "#define FOO 5".
                     // Put it in the #define map
-                    String oldDef = (String)defineMap.put(name, value);
+                    String oldDef = defineMap.put(name, value);
                     if (oldDef != null && !oldDef.equals(value)) {
                         System.err.println("WARNING: \"" + name + "\" redefined from \"" +
                                            oldDef + "\" to \"" + value + "\"");
@@ -458,42 +456,98 @@ public class PCPP {
                     }
                 }
             } else {
-                // Non-constant define; try to do reasonable textual substitution anyway
-                // (FIXME: should identify some of these, like (-1), as constants)
-                emitDefine = false;
-                StringBuffer val = new StringBuffer();
-                for (int i = 0; i < sz; i++) {
-                    if (i != 0) {
-                        val.append(" ");
+
+                // find constant expressions like (1 << 3)
+                // if found just pass them through, they will most likely work in java too
+                // expressions containing identifiers are currently ignored (casts too)
+
+                boolean containsIdentifier = false;
+                for (String value : values) {
+                    if(isIdentifier(value)) {
+                        containsIdentifier = true;
+                        break;
                     }
-                    val.append(resolveDefine((String) values.get(i), false));
                 }
-                if (defineMap.get(name) != null) {
-                    // This is probably something the user should investigate.
-                    throw new RuntimeException("Cannot redefine symbol \"" + name +
-                                               " from \"" + defineMap.get(name) + "\" to non-constant " +
-                                               " definition \"" + val.toString() + "\"");
+
+                //TODO more work here e.g casts are currently not handled
+                if(containsIdentifier) { //skip
+
+                    // Non-constant define; try to do reasonable textual substitution anyway
+                    // (FIXME: should identify some of these, like (-1), as constants)
+                    emitDefine = false;
+                    StringBuffer val = new StringBuffer();
+                    for (int i = 0; i < sz; i++) {
+                        if (i != 0) {
+                            val.append(" ");
+                        }
+                        val.append(resolveDefine(values.get(i), false));
+                    }
+                    if (defineMap.get(name) != null) {
+                        // This is probably something the user should investigate.
+                        throw new RuntimeException("Cannot redefine symbol \"" + name +
+                                                   " from \"" + defineMap.get(name) + "\" to non-constant " +
+                                                   " definition \"" + val.toString() + "\"");
+                    }
+                    defineMap.put(name, val.toString());
+                    nonConstantDefines.add(name);
+
+                }else{ // constant expression -> pass through
+
+                    StringBuilder sb = new StringBuilder();
+                    for (String v : values) {
+                        sb.append(v);
+                    }
+                    String value = sb.toString();
+
+                    String oldDef = defineMap.put(name, value);
+                    if (oldDef != null && !oldDef.equals(value)) {
+                        System.err.println("WARNING: \"" + name + "\" redefined from \"" +
+                                           oldDef + "\" to \"" + value + "\"");
+                    }
+                    debugPrint(true, "#define " + name + " ["+oldDef+" ] -> "+value + " CONST");
+//                    System.out.println("#define " + name +" "+value + " CONST EXPRESSION");
                 }
-                defineMap.put(name, val.toString());
-                nonConstantDefines.add(name);
-            }        
-      
+
+            }
+
             if (emitDefine) {
                 // Print name and value
                 print("# define ");
                 print(name);
-                for (Iterator iter = values.iterator(); iter.hasNext(); ) {
-                    print(" ");
-                    print((String) iter.next());
+                print(" ");
+                for (String v : values) {
+                    print(v);
                 }
                 println();
             }
 
         } // end if (enabled())
-    
+
         //System.err.println("OUT HANDLE_DEFINE: " + name);
     }
 
+    private boolean isIdentifier(String value) {
+
+        boolean identifier = false;
+
+        char[] chars = value.toCharArray();
+
+        for (int i = 0; i < chars.length; i++) {
+            char c = chars[i];
+            if (i == 0) {
+                if (Character.isJavaIdentifierStart(c)) {
+                    identifier = true;
+                }
+            } else {
+                if (!Character.isJavaIdentifierPart(c)) {
+                    identifier = false;
+                    break;
+                }
+            }
+        }
+        return identifier;
+    }
+
     private boolean isConstant(String s) {
         if (s.startsWith("0x") || s.startsWith("0X")) {
             return checkHex(s);
@@ -517,7 +571,7 @@ public class PCPP {
             return true;
         } else if(i==s.length()-1) {
             // Const qualifier ..
-            return c == 'l' || c == 'L' || 
+            return c == 'l' || c == 'L' ||
                    c == 'f' || c == 'F' ||
                    c == 'u' || c == 'U' ;
         }
@@ -535,7 +589,7 @@ public class PCPP {
     }
 
     private String resolveDefine(String word, boolean returnNullIfNotFound) {
-        String lastWord = (String) defineMap.get(word);
+        String lastWord = defineMap.get(word);
         if (lastWord == null) {
             if (returnNullIfNotFound) {
                 return null;
@@ -544,7 +598,7 @@ public class PCPP {
         }
         String nextWord = null;
         do {
-            nextWord = (String) defineMap.get(lastWord);
+            nextWord = defineMap.get(lastWord);
             if (nextWord != null) {
                 lastWord = nextWord;
             }
@@ -566,7 +620,7 @@ public class PCPP {
         debugPrint(true, (isIfdef ? "#ifdef " : "#ifndef ") + symbolName);
         boolean symbolIsDefined = defineMap.get(symbolName) != null;
         debugPrint(true, (isIfdef ? "#ifdef " : "#ifndef ") + symbolName + "(defined: "+symbolIsDefined+")");
-        pushEnableBit(enabled() && symbolIsDefined == isIfdef);    
+        pushEnableBit(enabled() && symbolIsDefined == isIfdef);
     }
 
     /** Handles #else directives */
@@ -604,7 +658,7 @@ public class PCPP {
     //static int tmp = -1;
 
     /**
-     * This method is called recursively to process nested sub-expressions such as: 
+     * This method is called recursively to process nested sub-expressions such as:
      * <pre>
      *   #if !defined(OPENSTEP) && !(defined(NeXT) || !defined(NeXT_PDO))
      *</pre>
@@ -617,15 +671,15 @@ public class PCPP {
      */
     private boolean handleIfRecursive(boolean greedy) throws IOException {
         //System.out.println("IN HANDLE_IF_RECURSIVE (" + ++tmp + ", greedy = " + greedy + ")"); System.out.flush();
-    
+
         // ifValue keeps track of the current value of the potentially nested
         // "defined()" expressions as we process them.
-        boolean ifValue = true; 
+        boolean ifValue = true;
         int openParens = 0;
         int tok;
-        do {       
-            tok = nextToken(true);          
-            //System.out.println("-- READ: [" + (tok == StreamTokenizer.TT_EOL ? "<EOL>" :curTokenAsString()) + "]"); 
+        do {
+            tok = nextToken(true);
+            //System.out.println("-- READ: [" + (tok == StreamTokenizer.TT_EOL ? "<EOL>" :curTokenAsString()) + "]");
             switch (tok) {
                 case '(':
                     ++openParens;
@@ -644,7 +698,7 @@ public class PCPP {
                         //System.out.println("HANDLE_IF_RECURSIVE HANDLED OUT !, RHS = " + rhs);
                     }
                     break;
-                case '&':        
+                case '&':
                     {
                         nextRequiredToken('&');
                         //System.out.println("HANDLE_IF_RECURSIVE HANDLING &&, LHS = " + ifValue);
@@ -683,7 +737,7 @@ public class PCPP {
                         ifValue = false;
                     }
                     break;
-                case StreamTokenizer.TT_WORD: 
+                case StreamTokenizer.TT_WORD:
                     {
                         String word = curTokenAsString();
                         if (word.equals("defined")) {
@@ -696,7 +750,7 @@ public class PCPP {
                             nextRequiredToken(')');
                         } else {
                             // Handle things like #if SOME_SYMBOL.
-                            String symbolValue = (String)defineMap.get(word);
+                            String symbolValue = defineMap.get(word);
 
                             // See if the statement is "true"; i.e., a non-zero expression
                             if (symbolValue != null) {
@@ -704,7 +758,7 @@ public class PCPP {
                                 return (!nonConstantDefines.contains(word));
                             } else {
                                 // The statement is true if the symbol evaluates to a non-zero value
-                                // 
+                                //
                                 // NOTE: This doesn't yet handle evaluable expressions like "#if
                                 // SOME_SYMBOL > 5" or "#if SOME_SYMBOL == 0", both of which are
                                 // valid syntax. It only handles numeric symbols like "#if 1"
@@ -726,22 +780,22 @@ public class PCPP {
                                         }
                                     }
                                 }
-                            }     
-                        } 
+                            }
+                        }
                     } // end case TT_WORD
                     break;
                 case StreamTokenizer.TT_EOL:
                     //System.out.println("HANDLE_IF_RECURSIVE HIT <EOL>!");
                     pushBackToken(); // so caller hits EOL as well if we're recursing
-                    break; 
-                case StreamTokenizer.TT_EOF: 
+                    break;
+                case StreamTokenizer.TT_EOF:
                     throw new RuntimeException("Unexpected end of file while parsing " +
-                                               "#if statement at file " + filename() + ", line " + lineNumber());        
-        
+                                               "#if statement at file " + filename() + ", line " + lineNumber());
+
                 default:
                     throw new RuntimeException("Unexpected token (" + curTokenAsString() +
                                                ") while parsing " + "#if statement at file " + filename() +
-                                               ", line " + lineNumber());        
+                                               ", line " + lineNumber());
             }
             //System.out.println("END OF WHILE: greedy = " + greedy + " parens = " +openParens + " not EOL = " + (tok != StreamTokenizer.TT_EOL) + " --> " + ((greedy && openParens >= 0) && tok != StreamTokenizer.TT_EOL));
         } while ((greedy && openParens >= 0) && tok != StreamTokenizer.TT_EOL);
@@ -749,11 +803,11 @@ public class PCPP {
         //System.out.flush();
         return ifValue;
     }
-  
+
     /////////////////////////////////////
     // Handling of #include directives //
     /////////////////////////////////////
-    
+
     private void handleInclude() throws IOException {
         // Two kinds of #includes: one with quoted string for argument,
         // one with angle brackets surrounding argument
@@ -784,12 +838,12 @@ public class PCPP {
             if (fullname == null) {
                 System.err.println("WARNING: unable to find #include file \"" + filename + "\"");
                 return;
-            }      
+            }
             // Process this file in-line
             Reader reader = new BufferedReader(new FileReader(fullname));
             run(reader, fullname);
         } else {
-            //System.out.println("INACTIVE BLOCK, SKIPPING " + filename);      
+            //System.out.println("INACTIVE BLOCK, SKIPPING " + filename);
         }
     }
 
@@ -799,15 +853,15 @@ public class PCPP {
 
     private OutputStream out;
     private PrintWriter  writer;
-    private ArrayList    enabledBits = new ArrayList();
-  
+    private List<Boolean> enabledBits = new ArrayList<Boolean>();
+
     private static int debugPrintIndentLevel = 0;
     private void debugPrint(boolean onlyPrintIfEnabled, String msg)
     {
         if (disableDebugPrint) {
             return;
         }
-    
+
         if (!onlyPrintIfEnabled || (onlyPrintIfEnabled && enabled()))
             {
                 for (int i = debugPrintIndentLevel; --i >0; ) {
@@ -818,7 +872,7 @@ public class PCPP {
     }
 
     private void pushEnableBit(boolean enabled) {
-        enabledBits.add(new Boolean(enabled));
+        enabledBits.add(enabled);
         ++debugPrintIndentLevel;
         debugPrint(false, "PUSH_ENABLED, NOW: " + enabled());
     }
@@ -834,8 +888,7 @@ public class PCPP {
     }
 
     private boolean enabled() {
-        return (enabledBits.size() == 0 ||
-                ((Boolean) enabledBits.get(enabledBits.size() - 1)).booleanValue());
+        return (enabledBits.size() == 0 || enabledBits.get(enabledBits.size() - 1));
     }
 
     private void print(String s) {
@@ -844,7 +897,7 @@ public class PCPP {
             //System.out.print(s);//debug
         }
     }
-  
+
     private void print(char c) {
         if (enabled()) {
             writer.print(c);