/*
 * 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
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
 * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
 * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
 * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
 * 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.
 */

package com.sun.gluegen.pcpp;

import java.io.*;
import java.util.*;

/** A minimal pseudo-C-preprocessor designed in particular to preserve
    #define statements defining constants so they can be observed by a
    glue code generator. */

public class PCPP {
    private static final boolean disableDebugPrint = true;

    public PCPP(List/*<String>*/ includePaths) {
        this.includePaths = includePaths;
        setOut(System.out);
    }

    public OutputStream out()                    { return out;     }
    public void         setOut(OutputStream out) { this.out = out; writer = new PrintWriter(out); }

    public void run(Reader reader, String filename) throws IOException {
        StreamTokenizer tok = null;
        BufferedReader bufReader = null;
        if (reader instanceof BufferedReader) {
            bufReader = (BufferedReader) reader;
        } else {
            bufReader = new BufferedReader(reader);
        }
        tok = new StreamTokenizer(new ConcatenatingReader(bufReader));
        tok.resetSyntax();
        tok.wordChars('a', 'z');
        tok.wordChars('A', 'Z');
        tok.wordChars('0', '9');
        tok.wordChars('_', '_');
        tok.wordChars('-', '.');
        tok.wordChars(128 + 32, 255);
        tok.whitespaceChars(0, ' ');
        tok.quoteChar('"');
        tok.quoteChar('\'');
        tok.eolIsSignificant(true);
        tok.slashSlashComments(true);
        tok.slashStarComments(true);
        ParseState curState = new ParseState(tok, filename);
        ParseState oldState = state;
        state = curState;
        lineDirective();
        parse();
        state = oldState;
        if (state != null) {
            lineDirective();
        }
    }

    public static void main(String[] args) {
        try {
            Reader reader = null;
            String filename = null;

            if (args.length == 0) {
                usage();
            }

            List includePaths = new ArrayList();
            for (int i = 0; i < args.length; i++) {
                if (i < args.length - 1) {
                    String arg = args[i];
                    if (arg.startsWith("-I")) {
                        String[] paths = arg.substring(2).split(System.getProperty("path.separator"));
                        for (int j = 0; j < paths.length; j++) {
                            includePaths.add(paths[j]);
                        }
                    } else {
                        usage();
                    }
                } else {
                    String arg = args[i];
                    if (arg.equals("-")) {
                        reader = new InputStreamReader(System.in);
                        filename = "standard input";
                    } else {
                        if (arg.startsWith("-")) {
                            usage();
                        }
                        filename = arg;
                        reader = new BufferedReader(new FileReader(filename));
                    }
                }
            }

            new PCPP(includePaths).run(reader, filename);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String findFile(String filename) {
        String sep = File.separator;
        for (Iterator iter = includePaths.iterator(); iter.hasNext(); ) {
            String inclPath = (String) iter.next();
            String fullPath = inclPath + sep + filename;
            File file = new File(fullPath);
            if (file.exists()) {
                return fullPath;
            }
        }
        return null;
    }

    //----------------------------------------------------------------------
    // Internals only below this point
    //

    private static void usage() {
        System.out.println("Usage: java PCPP [filename | -]");
        System.out.println("Minimal pseudo-C-preprocessor.");
        System.out.println("Output goes to standard output. Standard input can be used as input");
        System.out.println("by passing '-' as the argument.");
        System.exit(1);
    }

    /** Map containing the results of #define statements. We must
        evaluate certain very simple definitions (to properly handle
        OpenGL's gl.h) but preserve the text of definitions evaluating
        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();

    /** List containing the #include paths as Strings */
    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;
        }

        StreamTokenizer tok()                       { return tok;          }
        String          filename()                  { return filename;     }
        int             lineNumber()                { return tok.lineno(); }
        boolean         startOfLine()               { return startOfLine;  }
        void            setStartOfLine(boolean val) { startOfLine = val;   }
        boolean         startOfFile()               { return startOfFile;  }
        void            setStartOfFile(boolean val) { startOfFile = val;   }
    }

    private ParseState  state;

    // Accessors

    private void pushBackToken() throws IOException {
        state.tok().pushBack();
    }

    /** Equivalent to nextToken(false) */
    private int nextToken() throws IOException {
        return nextToken(false);
    }

    private int nextToken(boolean returnEOLs) throws IOException {
        int lineno = lineNumber();
        // Check to see whether the previous call to nextToken() left an
        // EOL on the stream
        if (curToken() == StreamTokenizer.TT_EOL) {
            state.setStartOfLine(true);
        } else if (!state.startOfFile()) {
            state.setStartOfLine(false);
        }
        state.setStartOfFile(false);
        int val = state.tok().nextToken();
        if (!returnEOLs) {
            if (val == StreamTokenizer.TT_EOL) {
                do {
                    // Consume and return next token, setting state appropriately
                    val = state.tok().nextToken();
                    state.setStartOfLine(true);
                    println();
                } while (val == StreamTokenizer.TT_EOL);
            }
        }
        if (lineNumber() > lineno + 1) {
            // This is a little noisier than it needs to be, but does handle
            // the case of multi-line comments properly
            lineDirective();
        }
        return val;
    }
  
    /**
     * Reads the next token and throws an IOException if it is not the specified
     * token character.
     */
    private void nextRequiredToken(int requiredToken) throws IOException {
        int nextTok = nextToken();
        if (nextTok != requiredToken) {
            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;    
            }
            msg += " at file " + filename() + ", line " + lineNumber();
            throw new IOException(msg);
        }
    }

    private int curToken() {
        return state.tok().ttype;
    }

    private String curTokenAsString() {
        int t = curToken();
        if (t == StreamTokenizer.TT_WORD) {
            return curWord();
        }
        if (t == StreamTokenizer.TT_EOL) {
            throw new RuntimeException("Should not be converting EOL characters to strings");
        }
        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();
        }
        return new String(new char[] { c });
    }

    private String nextWord() throws IOException {
        int val = nextToken();
        if (val != StreamTokenizer.TT_WORD) {
            throw new RuntimeException("Expected word at file " + filename() +
                                       ", line " + lineNumber());
        }
        return curWord();
    }

    private String curWord() {
        return state.tok().sval;
    }

    private boolean startOfLine() {
        return state.startOfLine();
    }

    private String filename() {
        return state.filename();
    }

    private int lineNumber() {
        return state.lineNumber();
    }

    /////////////
    // Parsing //
    /////////////

    private void parse() throws IOException {
        int tok = 0;
        while ((tok = nextToken()) != StreamTokenizer.TT_EOF) {
            // A '#' at the beginning of a line is a preprocessor directive
            if (startOfLine() && (tok == '#')) {
                preprocessorDirective();
            } 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. 
                if (tok == StreamTokenizer.TT_WORD) {
                    print(" ");
                }
                String s = curTokenAsString();
                String newS = (String) defineMap.get(s);
                if (newS == null) {
                    newS = s;
                }
                print(newS);
            }
        }
        flush();
    }

    private void preprocessorDirective() throws IOException {
        String w = nextWord();
        boolean shouldPrint = true;
        if (w.equals("define")) {
            handleDefine();
            shouldPrint = false;
        } else if (w.equals("undef")) {
            handleUndefine();
            shouldPrint = false;
        } else if (w.equals("if") || w.equals("elif")) {
            handleIf(w.equals("if"));
            shouldPrint = false;
        } else if (w.equals("ifdef") || w.equals("ifndef")) {
            handleIfdef(w.equals("ifdef"));
            shouldPrint = false;
        } else if (w.equals("else")) {
            handleElse();
            shouldPrint = false;
        } else if (w.equals("endif")) {
            handleEndif();
            shouldPrint = false;
        } else if (w.equals("include")) {
            handleInclude();
            shouldPrint = false;
        } else {
            // Unknown preprocessor directive (#pragma?) -- ignore
        }
        if (shouldPrint) {
            print("# ");
            printToken();
        }
    }

    ////////////////////////////////////
    // Handling of #define directives //
    ////////////////////////////////////

    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();
        while (nextToken(true) != StreamTokenizer.TT_EOL) {
            values.add(curTokenAsString());
        }

        if (enabled()) {
            String oldDef = (String)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() + ")");        
            }      
            nonConstantDefines.remove(name);
        }
        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();
        while (nextToken(true) != StreamTokenizer.TT_EOL) {
            values.add(curTokenAsString());
        }
        // if we're not within an active block of code (like inside an "#ifdef
        // FOO" where FOO isn't defined), then don't actually alter the definition
        // map.
        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 oldDef = (String) defineMap.put(name, "");
                if (oldDef != null) {
                    System.err.println("WARNING: \"" + name + "\" redefined from \"" +
                                       oldDef + "\" to \"\"");
                }
                // We don't want to emit the define, because it would serve no purpose
                // and cause GlueGen errors (confuse the GnuCParser)
                emitDefine = false;
                //System.out.println("//---DEFINED: " + name + "to \"\"");
            } else if (sz == 1) {        
                // See whether the value is a constant
                String value = (String) 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);
                    if (oldDef != null) {
                        System.err.println("WARNING: \"" + name + "\" redefined from \"" +
                                           oldDef + "\" to \"" + value + "\"");
                    }
                    //System.out.println("//---DEFINED: " + name + " to \"" + value + "\"");
                } else {
                    // Value is a symbolic constant like "#define FOO BAR".
                    // Try to look up the symbol's value
                    String newValue = resolveDefine(value, true);
                    if (newValue != null) {
                        // Set the value to the value of the symbol.
                        //
                        // TO DO: Is this correct? Why not output the symbol unchanged?
                        // I think that it's a good thing to see that some symbols are
                        // defined in terms of others. -chris
                        values.set(0, newValue);
                    } else {
                        // Still perform textual replacement
                        defineMap.put(name, value);
                        nonConstantDefines.add(name);
                        emitDefine = false;
                    }
                }
            } 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(" ");
                    }
                    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() + "\"");
                }
                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());
                }
                println();
            }

        } // end if (enabled())
    
        //System.err.println("OUT HANDLE_DEFINE: " + name);
    }

    private boolean isConstant(String s) {
        if (s.startsWith("0x") || s.startsWith("0X")) {
            return checkHex(s);
        } else {
            return checkDecimal(s);
        }
    }

    private boolean checkHex(String s) {
        for (int i = 2; i < s.length(); i++) {
            char c = s.charAt(i);
            if (!((c >= '0' && c <= '9') ||
                  (c >= 'a' && c <= 'f') ||
                  (c >= 'A' && c <= 'F'))) {
                return false;
            }
        }
        return true;
    }

    private boolean checkDecimal(String s) {
        try {
            Float.valueOf(s);
        } catch (NumberFormatException e) {
            // not parsable as a number
            return false;
        }
        return true;
    }

    private String resolveDefine(String word, boolean returnNullIfNotFound) {
        String lastWord = (String) defineMap.get(word);
        if (lastWord == null) {
            if (returnNullIfNotFound) {
                return null;
            }
            return word;
        }
        String nextWord = null;
        do {
            nextWord = (String) defineMap.get(lastWord);
            if (nextWord != null) {
                lastWord = nextWord;
            }
        } while (nextWord != null);
        return lastWord;
    }

    ////////////////////////////////////////////////
    // Handling of #if/#ifdef/ifndef/endif directives //
    ////////////////////////////////////////////////

    /**
     * @param isIfdef if true, we're processing #ifdef; if false, we're
     * processing #ifndef.
     */
    private void handleIfdef(boolean isIfdef) throws IOException {
        // Next token is the name of the #ifdef
        String symbolName = nextWord();
        debugPrint(true, (isIfdef ? "#ifdef " : "#ifndef ") + symbolName);
        boolean symbolIsDefined = defineMap.get(symbolName) != null;
        //debugPrint(true, "HANDLE_IFDEF: ifdef(" + symbolName + ") = " + symbolIsDefined );    
        pushEnableBit(enabled() && symbolIsDefined == isIfdef);    
    }

    /** Handles #else directives */
    private void handleElse() throws IOException {
        boolean enabledStatusBeforeElse = enabled();
        popEnableBit();
        pushEnableBit(enabled() && !enabledStatusBeforeElse);
        debugPrint(true, "#else ");
    }

    private void handleEndif() {
        boolean enabledBeforePopping = enabled();
        popEnableBit();

        // print the endif if we were enabled prior to popEnableBit() (sending
        // false to debugPrint means "print regardless of current enabled() state).
        debugPrint(!enabledBeforePopping, "#endif/end-else");
    }

    /**
     * @param isIf if true, we're processing #if; if false, we're
     * processing #elif.
     */
    private void handleIf(boolean isIf) throws IOException {
        //System.out.println("IN HANDLE_" + (isIf ? "IF" : "ELIF") + " file \"" + filename() + " line " + lineNumber());
        debugPrint(true, (isIf ? "#if" : "#elif"));
        boolean defineEvaluatedToTrue = handleIfRecursive(true);
        if (!isIf) {
            popEnableBit();
        }
        pushEnableBit(enabled() && defineEvaluatedToTrue == isIf);
        //System.out.println("OUT HANDLE_" + (isIf ? "IF" : "ELIF") +" (evaluated to " + defineEvaluatedToTrue + ")");
    }

    //static int tmp = -1;

    /**
     * This method is called recursively to process nested sub-expressions such as: 
     * <pre>
     *   #if !defined(OPENSTEP) && !(defined(NeXT) || !defined(NeXT_PDO))
     *</pre>
     *
     * @param greedy if true, continue evaluating sub-expressions until EOL is
     * reached. If false, return as soon as the first sub-expression is
     * processed.
     * @return the value of the sub-expression or (if greedy==true)
     * series of sub-expressions.
     */
    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; 
        int openParens = 0;
        int tok;
        do {       
            tok = nextToken(true);          
            //System.out.println("-- READ: [" + (tok == StreamTokenizer.TT_EOL ? "<EOL>" :curTokenAsString()) + "]"); 
            switch (tok) {
                case '(':
                    ++openParens;
                    //System.out.println("OPEN PARENS = " + openParens);
                    ifValue = ifValue && handleIfRecursive(true);
                    break;
                case ')':
                    --openParens;
                    //System.out.println("OPEN PARENS = " + openParens);
                    break;
                case '!':
                    {
                        //System.out.println("HANDLE_IF_RECURSIVE HANDLING !");
                        boolean rhs = handleIfRecursive(false);
                        ifValue = !rhs;
                        //System.out.println("HANDLE_IF_RECURSIVE HANDLED OUT !, RHS = " + rhs);
                    }
                    break;
                case '&':        
                    {
                        nextRequiredToken('&');
                        //System.out.println("HANDLE_IF_RECURSIVE HANDLING &&, LHS = " + ifValue);
                        boolean rhs = handleIfRecursive(true);
                        //System.out.println("HANDLE_IF_RECURSIVE HANDLED &&, RHS = " + rhs);
                        ifValue = ifValue && rhs;
                    }
                    break;
                case '|':
                    {
                        nextRequiredToken('|');
                        //System.out.println("HANDLE_IF_RECURSIVE HANDLING ||, LHS = " + ifValue);
                        boolean rhs = handleIfRecursive(true);
                        //System.out.println("HANDLE_IF_RECURSIVE HANDLED ||, RHS = " + rhs);
                        ifValue = ifValue || rhs;
                    }
                    break;
                case '>':
                    {
                        // NOTE: we don't handle expressions like this properly
                        boolean rhs = handleIfRecursive(true);
                        ifValue = false;
                    }
                    break;
                case '<':
                    {
                        // NOTE: we don't handle expressions like this properly
                        boolean rhs = handleIfRecursive(true);
                        ifValue = false;
                    }
                    break;
                case '=':
                    {
                        // NOTE: we don't handle expressions like this properly
                        boolean rhs = handleIfRecursive(true);
                        ifValue = false;
                    }
                    break;
                case StreamTokenizer.TT_WORD: 
                    {
                        String word = curTokenAsString();
                        if (word.equals("defined")) {
                            // Handle things like #if defined(SOMESYMBOL)
                            nextRequiredToken('(');
                            String symbol = nextWord();
                            boolean isDefined = defineMap.get(symbol) != null;
                            //System.out.println("HANDLE_IF_RECURSIVE HANDLING defined(" + symbol + ") = " + isDefined);
                            ifValue = ifValue && isDefined;
                            nextRequiredToken(')');
                        } else {
                            // Handle things like #if SOME_SYMBOL.
                            String symbolValue = (String)defineMap.get(word);

                            // See if the statement is "true"; i.e., a non-zero expression
                            if (symbolValue != null) {
                                // The statement is true if the symbol is defined and is a constant expression
                                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"

                                try {
                                    // see if it's in decimal form
                                    return Double.parseDouble(word) != 0;
                                } catch (NumberFormatException nfe1) {
                                    try {
                                        // ok, it's not a valid decimal value, try hex/octal value
                                        return Long.parseLong(word) != 0;
                                    } catch (NumberFormatException nfe2) {
                                        try {
                                            // ok, it's not a valid hex/octal value, try boolean
                                            return Boolean.valueOf(word) == Boolean.TRUE;
                                        } catch (NumberFormatException nfe3) {
                                            // give up; the symbol isn't a numeric or boolean value
                                            return false;
                                        }
                                    }
                                }
                            }     
                        } 
                    } // 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: 
                    throw new RuntimeException("Unexpected end of file while parsing " +
                                               "#if statement at file " + filename() + ", line " + lineNumber());        
        
                default:
                    throw new RuntimeException("Unexpected token (" + curTokenAsString() +
                                               ") while parsing " + "#if statement at file " + filename() +
                                               ", 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);
        //System.out.println("OUT HANDLE_IF_RECURSIVE (" + tmp-- + ", returning " + ifValue + ")");
        //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
        int t = nextToken();
        String filename = null;
        if (t == '"') {
            filename = curWord();
        } else if (t == '<') {
            // Components of path name are coming in as separate tokens;
            // concatenate them
            StringBuffer buf = new StringBuffer();
            while ((t = nextToken()) != '>' && (t != StreamTokenizer.TT_EOF)) {
                buf.append(curTokenAsString());
            }
            if (t == StreamTokenizer.TT_EOF) {
                System.err.println("WARNING: unexpected EOF while processing #include directive");
            }
            filename = buf.toString();
        }
        // if we're not within an active block of code (like inside an "#ifdef
        // FOO" where FOO isn't defined), then don't actually process the
        // #included file.
        debugPrint(true, "#include [" + filename + "]");
        if (enabled()) {
            // Look up file in known #include path
            String fullname = findFile(filename);
            //System.out.println("ACTIVE BLOCK, LOADING " + filename);
            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);      
        }
    }

    ////////////
    // Output //
    ////////////

    private OutputStream out;
    private PrintWriter  writer;
    private ArrayList    enabledBits = new ArrayList();
  
    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; ) {
                    System.out.print("  ");
                }
                System.out.println(msg + "  (line " + lineNumber() + " file " + filename() + ")");
            }
    }

    private void pushEnableBit(boolean enabled) {
        enabledBits.add(new Boolean(enabled));
        ++debugPrintIndentLevel;
        //debugPrint(false, "PUSH_ENABLED, NOW: " + enabled());
    }

    private void popEnableBit() {
        if (enabledBits.size() == 0) {
            System.err.println("WARNING: mismatched #ifdef/endif pairs");
            return;
        }
        enabledBits.remove(enabledBits.size() - 1);
        --debugPrintIndentLevel;
        //debugPrint(false, "POP_ENABLED, NOW: " + enabled());
    }

    private boolean enabled() {
        return (enabledBits.size() == 0 ||
                ((Boolean) enabledBits.get(enabledBits.size() - 1)).booleanValue());
    }

    private void print(String s) {
        if (enabled()) {
            writer.print(s);
            //System.out.print(s);//debug
        }
    }
  
    private void print(char c) {
        if (enabled()) {
            writer.print(c);
            //System.err.print(c); //debug
        }
    }

    private void println() {
        if (enabled()) {
            writer.println();
            //System.err.println();//debug
        }
    }

    private void printToken() {
        print(curTokenAsString());
    }

    private void flush() {
        if (enabled()) {
            writer.flush();
            //System.err.flush(); //debug
        }
    }

    private void lineDirective() {
        print("# " + lineNumber() + " \"" + filename() + "\"");
        println();
    }
}