better exception handling in GlueGen.

WIP: refactored PCPP to implement macros, next step is to replace StreamTokenizer with Scanner (we need a propper look ahead).

2 files changed, 256 insertions, 127 deletions

diff --git a/src/java/com/sun/gluegen/GlueGen.java b/src/java/com/sun/gluegen/GlueGen.java
index 7c1fa4c..68d65d7 100644
--- a/src/java/com/sun/gluegen/GlueGen.java
+++ b/src/java/com/sun/gluegen/GlueGen.java
@@ -154,15 +154,11 @@ public class GlueGen implements GlueEmitterControls {
 
       // invoke parser
       try {
-        parser.translationUnit();
-      }
-      catch (RecognitionException e) {
-        System.err.println("Fatal IO error:\n"+e);
-        System.exit(1);
-      }
-      catch (TokenStreamException e) {
-        System.err.println("Fatal IO error:\n"+e);
-        System.exit(1);
+          parser.translationUnit();
+      } catch (RecognitionException e) {
+          throw new RuntimeException("Fatal IO error", e);
+      } catch (TokenStreamException e) {
+          throw new RuntimeException("Fatal IO error", e);
       }
 
       HeaderParser headerParser = new HeaderParser();
@@ -190,9 +186,7 @@ public class GlueGen implements GlueEmitterControls {
         try {
           emit = (GlueEmitter) Class.forName(emitterClass).newInstance();
         } catch (Exception e) {
-          System.err.println("Exception occurred while instantiating emitter class. Exiting.");
-          e.printStackTrace();
-          System.exit(1);
+          throw new RuntimeException("Exception occurred while instantiating emitter class.", e);
         }
       }
 
@@ -333,9 +327,7 @@ public class GlueGen implements GlueEmitterControls {
       emit.endEmission();
 
     } catch ( Exception e ) {
-      e.printStackTrace();
-      System.err.println("Exception occurred while generating glue code. Exiting.");
-      System.exit(1);
+      throw new RuntimeException("Exception occurred while generating glue code.", e);
     }
   }
   
diff --git a/src/java/com/sun/gluegen/pcpp/PCPP.java b/src/java/com/sun/gluegen/pcpp/PCPP.java
index 05580a8..1a8b3d9 100644
--- a/src/java/com/sun/gluegen/pcpp/PCPP.java
+++ b/src/java/com/sun/gluegen/pcpp/PCPP.java
@@ -39,24 +39,52 @@
 
 package com.sun.gluegen.pcpp;
 
-import java.io.*;
-import java.util.*;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.Reader;
+import java.io.StreamTokenizer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /** 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;
 
+    /** 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<String, String>(128);
+//    private Map<String, Macro>  macroMap           = new HashMap<String, Macro>(128);
+    private Set<String>         nonConstantDefines = new HashSet<String>(128);
+
+    /** List containing the #include paths as Strings */
+    private List<String> includePaths;
+
+    private ParseState  state;
+
     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;
@@ -65,71 +93,35 @@ public class PCPP {
         } else {
             bufReader = new BufferedReader(reader);
         }
+
         tok = new StreamTokenizer(new ConcatenatingReader(bufReader));
+        initTokenizer(tok);
+
+        ParseState curState = new ParseState(tok, filename);
+        ParseState oldState = state;
+        state = curState;
+        lineDirective();
+        parse();
+        state = oldState;
+        if (state != null) {
+            lineDirective();
+        }
+    }
+
+    private void initTokenizer(StreamTokenizer tok) {
         tok.resetSyntax();
         tok.wordChars('a', 'z');
         tok.wordChars('A', 'Z');
         tok.wordChars('0', '9');
         tok.wordChars('_', '_');
         tok.wordChars('-', '.');
-        tok.wordChars(128 + 32, 255);
+        tok.wordChars(128, 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<String> includePaths = new ArrayList<String>();
-            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) {
@@ -144,36 +136,22 @@ public class PCPP {
         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);
+    public OutputStream out() {
+        return out;
     }
 
-    /** 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<String, String>(128);
-    private Set<String>         nonConstantDefines = new HashSet<String>(128);
-
-    /** List containing the #include paths as Strings */
-    private List<String> includePaths;
+    public void setOut(OutputStream out) {
+        this.out = out;
+        writer = new PrintWriter(out);
+    }
 
     // State
     static class ParseState {
+
         private StreamTokenizer tok;
-        private String          filename;
-        private boolean         startOfLine;
-        private boolean         startOfFile;
+        private String filename;
+        private boolean startOfLine;
+        private boolean startOfFile;
 
         ParseState(StreamTokenizer tok, String filename) {
             this.tok = tok;
@@ -182,22 +160,67 @@ public class PCPP {
             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;   }
+        void pushBackToken() throws IOException {
+            tok.pushBack();
+        }
+
+        int curToken() {
+            return tok.ttype;
+        }
+
+        int nextToken() throws IOException {
+            return tok.nextToken();
+        }
+
+        String curWord() {
+            return tok.sval;
+        }
+
+        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 static class Macro {
 
-    private ParseState  state;
+        private final List<String> values;
+        private final List<String> params;
 
-    // Accessors
+        public Macro(List<String> params, List<String> values) {
+            this.values = values;
+            this.params = params;
+        }
+
+        @Override
+        public String toString() {
+            return "params: "+params+" values: "+values;
+        }
 
-    private void pushBackToken() throws IOException {
-        state.tok().pushBack();
     }
+*/
+
+    // Accessors
 
     /** Equivalent to nextToken(false) */
     private int nextToken() throws IOException {
@@ -208,18 +231,18 @@ public class PCPP {
         int lineno = lineNumber();
         // Check to see whether the previous call to nextToken() left an
         // EOL on the stream
-        if (curToken() == StreamTokenizer.TT_EOL) {
+        if (state.curToken() == StreamTokenizer.TT_EOL) {
             state.setStartOfLine(true);
         } else if (!state.startOfFile()) {
             state.setStartOfLine(false);
         }
         state.setStartOfFile(false);
-        int val = state.tok().nextToken();
+        int val = state.nextToken();
         if (!returnEOLs) {
             if (val == StreamTokenizer.TT_EOL) {
                 do {
                     // Consume and return next token, setting state appropriately
-                    val = state.tok().nextToken();
+                    val = state.nextToken();
                     state.setStartOfLine(true);
                     println();
                 } while (val == StreamTokenizer.TT_EOL);
@@ -251,14 +274,11 @@ public class PCPP {
         }
     }
 
-    private int curToken() {
-        return state.tok().ttype;
-    }
 
     private String curTokenAsString() {
-        int t = curToken();
+        int t = state.curToken();
         if (t == StreamTokenizer.TT_WORD) {
-            return curWord();
+            return state.curWord();
         }
         if (t == StreamTokenizer.TT_EOL) {
             throw new RuntimeException("Should not be converting EOL characters to strings");
@@ -267,7 +287,7 @@ public class PCPP {
         if (c == '"' || c == '\'') {
             StringBuilder sb = new StringBuilder();
             sb.append(c);
-            sb.append(state.tok().sval);
+            sb.append(state.curWord());
             sb.append(c);
             return sb.toString();
         }
@@ -280,11 +300,7 @@ public class PCPP {
             throw new RuntimeException("Expected word at file " + filename() +
                                        ", line " + lineNumber());
         }
-        return curWord();
-    }
-
-    private String curWord() {
-        return state.tok().sval;
+        return state.curWord();
     }
 
     private boolean startOfLine() {
@@ -323,6 +339,40 @@ public class PCPP {
                 if (newS == null) {
                     newS = s;
                 }
+                /*
+                Macro macro = macroMap.get(newS);
+                if(macro != null) {
+                    List<String> args = new ArrayList<String>();
+                    while (nextToken(true) != StreamTokenizer.TT_EOL) {
+                        String token = curTokenAsString();
+                        if(")".equals(token)) {
+                            break;
+                        }else if(!",".equals(token) && !"(".equals(token)) {
+                            args.add(token);
+                        }
+                    }
+
+                    for (int i = 0; i < macro.values.size(); i++) {
+                        String value = macro.values.get(i);
+
+                        for (int j = 0; j < macro.params.size(); j++) {
+                            String param = macro.params.get(j);
+                            if(param.equals(value)) {
+                                value = args.get(j);
+                                break;
+                            }
+                        }
+
+                        if(isIdentifier(value)) {
+                            newS +=" ";
+                        }
+
+                        newS += value;
+
+                    }
+
+                }*/
+
                 print(newS);
             }
         }
@@ -395,6 +445,16 @@ public class PCPP {
     private void handleDefine() throws IOException {
         // Next token is the name of the #define
         String name = nextWord();
+
+        // read the next char even when it is a space
+        // we need this to determine wether we have a macro definition <name>'('..
+        // macro functions have no space between identifier and '(', we would otherwise mix them with casts
+//        initTokenizer(state.tok, false);
+//        state.tok.nextToken();
+//        boolean macroDef = state.curToken() == '(';
+//        state.tok.pushBack();
+//        initTokenizer(state.tok, true);
+
         //System.err.println("IN HANDLE_DEFINE: '" + name + "'  (line " + lineNumber() + " file " + filename() + ")");
         // (Note that this is not actually proper handling for multi-line #defines)
         List<String> values = new ArrayList<String>();
@@ -455,7 +515,34 @@ public class PCPP {
                         emitDefine = false;
                     }
                 }
-            } else {
+            /*
+            } else if (macroDef) {
+
+                // list parameters
+                List<String> params = new ArrayList<String>();
+                for (int i = 1; i < values.size(); i++) {
+                    String v = values.get(i);
+                    if(")".equals(v)) { // end of params
+                        if(i != values.size()-1) {
+                            values = values.subList(i+1, values.size()-1);
+                        }else{
+                            values = Collections.emptyList();
+                        }
+                        break;
+                    }else if(!",".equals(v)) {
+                        params.add(v);
+                    }
+                }
+
+                Macro macro = new Macro(params, values);
+                Macro oldDef = macroMap.put(name, macro);
+                if (oldDef != null) {
+                    System.err.println("WARNING: \"" + name + "\" redefined from \"" +
+                                       oldDef + "\" to \"" + macro + "\"");
+                }
+                emitDefine = false;
+             */
+            }else{
 
                 // find constant expressions like (1 << 3)
                 // if found just pass them through, they will most likely work in java too
@@ -475,7 +562,7 @@ public class PCPP {
                     // 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();
+                    StringBuilder val = new StringBuilder();
                     for (int i = 0; i < sz; i++) {
                         if (i != 0) {
                             val.append(" ");
@@ -786,7 +873,7 @@ public class PCPP {
                     break;
                 case StreamTokenizer.TT_EOL:
                     //System.out.println("HANDLE_IF_RECURSIVE HIT <EOL>!");
-                    pushBackToken(); // so caller hits EOL as well if we're recursing
+                    state.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 " +
@@ -814,7 +901,7 @@ public class PCPP {
         int t = nextToken();
         String filename = null;
         if (t == '"') {
-            filename = curWord();
+            filename = state.curWord();
         } else if (t == '<') {
             // Components of path name are coming in as separate tokens;
             // concatenate them
@@ -856,8 +943,7 @@ public class PCPP {
     private List<Boolean> enabledBits = new ArrayList<Boolean>();
 
     private static int debugPrintIndentLevel = 0;
-    private void debugPrint(boolean onlyPrintIfEnabled, String msg)
-    {
+    private void debugPrint(boolean onlyPrintIfEnabled, String msg)   {
         if (disableDebugPrint) {
             return;
         }
@@ -927,4 +1013,55 @@ public class PCPP {
         print("# " + lineNumber() + " \"" + filename() + "\"");
         println();
     }
+    
+    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);
+    }
+
+    public static void main(String[] args) {
+        try {
+            Reader reader = null;
+            String filename = null;
+
+            if (args.length == 0) {
+                usage();
+            }
+
+            List<String> includePaths = new ArrayList<String>();
+            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();
+        }
+    }
+
 }