diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/java/com/sun/gluegen/JavaEmitter.java | 91 | ||||
| -rw-r--r-- | src/java/com/sun/gluegen/cgram/StdCParser.g | 21 | ||||
| -rwxr-xr-x | src/java/com/sun/gluegen/pcpp/ConcatenatingReader.java | 15 | ||||
| -rw-r--r-- | src/java/com/sun/gluegen/pcpp/PCPP.java | 241 |
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); |