refactoring and code cleanup in gluegen.opengl and gluegen.procaddress package.

1 files changed, 236 insertions, 220 deletions

diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java b/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java
index 9409a1e..993f917 100755
--- a/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java
+++ b/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.procaddress;
 
 import java.io.*;
@@ -45,262 +44,279 @@ import java.util.*;
 
 import com.sun.gluegen.*;
 
-public class ProcAddressConfiguration extends JavaConfiguration
-{
-  private boolean emitProcAddressTable = false;
-  private String  tableClassPackage;
-  private String  tableClassName = "ProcAddressTable";
-  private Set/*<String>*/ skipProcAddressGen  = new HashSet();
-  private List/*<String>*/ forceProcAddressGen  = new ArrayList();
-  private Set/*<String>*/ forceProcAddressGenSet = new HashSet();
-  private boolean forceProcAddressGen4All=false;
-  private String  getProcAddressTableExpr;
-  private ConvNode procAddressNameConverter;
-  // This is needed only on Windows. Ideally we would modify the
-  // HeaderParser and PCPP to automatically pick up the calling
-  // convention from the headers
-  private Map/*<String,String>*/ localProcAddressCallingConventionMap = new HashMap();
-  private String localProcAddressCallingConvention4All=null;
-
-  protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
-    if (cmd.equalsIgnoreCase("EmitProcAddressTable"))
-      {
-        emitProcAddressTable =
-          readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue();
-      }
-    else if (cmd.equalsIgnoreCase("ProcAddressTablePackage"))
-      {
-        tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("ProcAddressTableClassName"))
-      {
-        tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("SkipProcAddressGen"))
-      {
-        String sym = readString("SkipProcAddressGen", tok, filename, lineNo);
-        skipProcAddressGen.add(sym);
-      }
-    else if (cmd.equalsIgnoreCase("ForceProcAddressGen"))
-      {
-        String funcName = readString("ForceProcAddressGen", tok, filename, lineNo);
-        if(funcName.equals("__ALL__")) {
-            forceProcAddressGen4All=true;
+public class ProcAddressConfiguration extends JavaConfiguration {
+
+    private boolean emitProcAddressTable = false;
+    private boolean forceProcAddressGen4All = false;
+
+    private String tableClassPackage;
+    private String tableClassName = "ProcAddressTable";
+    private String getProcAddressTableExpr;
+    private String localProcAddressCallingConvention4All = null;
+
+    private ConvNode procAddressNameConverter;
+    private final Set<String> skipProcAddressGen = new HashSet<String>();
+    private final List<String> forceProcAddressGen = new ArrayList<String>();
+    private final Set<String> forceProcAddressGenSet = new HashSet<String>();
+
+    // This is needed only on Windows. Ideally we would modify the
+    // HeaderParser and PCPP to automatically pick up the calling
+    // convention from the headers
+    private Map<String, String> localProcAddressCallingConventionMap = new HashMap<String, String>();
+
+    @Override
+    protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
+        if (cmd.equalsIgnoreCase("EmitProcAddressTable")) {
+            emitProcAddressTable = readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue();
+        } else if (cmd.equalsIgnoreCase("ProcAddressTablePackage")) {
+            tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("ProcAddressTableClassName")) {
+            tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("SkipProcAddressGen")) {
+            String sym = readString("SkipProcAddressGen", tok, filename, lineNo);
+            skipProcAddressGen.add(sym);
+        } else if (cmd.equalsIgnoreCase("ForceProcAddressGen")) {
+            String funcName = readString("ForceProcAddressGen", tok, filename, lineNo);
+            if (funcName.equals("__ALL__")) {
+                forceProcAddressGen4All = true;
+            } else {
+                addForceProcAddressGen(funcName);
+            }
+        } else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr")) {
+            getProcAddressTableExpr = readGetProcAddressTableExpr(tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("ProcAddressNameExpr")) {
+            readProcAddressNameExpr(tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention")) {
+            readLocalProcAddressCallingConvention(tok, filename, lineNo);
         } else {
-            addForceProcAddressGen( funcName );
+            super.dispatch(cmd, tok, file, filename, lineNo);
         }
-      }
-    else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr"))
-      {
-        getProcAddressTableExpr = readGetProcAddressTableExpr(tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("ProcAddressNameExpr"))
-      {
-        readProcAddressNameExpr(tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention"))
-      {
-        readLocalProcAddressCallingConvention(tok, filename, lineNo);
-      }
-    else
-      {
-        super.dispatch(cmd,tok,file,filename,lineNo);
-      }
-  }
-
-  protected String readGetProcAddressTableExpr(StringTokenizer tok, String filename, int lineNo) {
-    try {
-      String restOfLine = tok.nextToken("\n\r\f");
-      return restOfLine.trim();
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo +
-                                 " in file \"" + filename + "\"", e);
     }
-  }
-
-  protected void setProcAddressNameExpr(String expr) {
-    // Parse this into something allowing us to map from a function
-    // name to the typedef'ed function pointer name
-    List/*<String>*/ tokens = new ArrayList/*<String>*/();
-    StringTokenizer tok1 = new StringTokenizer(expr);
-    while (tok1.hasMoreTokens()) {
-      String sstr = tok1.nextToken();
-      StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true);
-      while (tok2.hasMoreTokens()) {
-        tokens.add(tok2.nextToken());
-      }
+
+    protected String readGetProcAddressTableExpr(StringTokenizer tok, String filename, int lineNo) {
+        try {
+            String restOfLine = tok.nextToken("\n\r\f");
+            return restOfLine.trim();
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
+        }
     }
 
-    // Now that the string is flattened out, convert it to nodes
-    procAddressNameConverter = makeConverter(tokens.iterator());
-    if (procAddressNameConverter == null) {
-      throw new NoSuchElementException("Error creating converter from string");
+    protected void setProcAddressNameExpr(String expr) {
+        // Parse this into something allowing us to map from a function
+        // name to the typedef'ed function pointer name
+        List<String> tokens = new ArrayList<String>();
+        StringTokenizer tok1 = new StringTokenizer(expr);
+        while (tok1.hasMoreTokens()) {
+            String sstr = tok1.nextToken();
+            StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true);
+            while (tok2.hasMoreTokens()) {
+                tokens.add(tok2.nextToken());
+            }
+        }
+
+        // Now that the string is flattened out, convert it to nodes
+        procAddressNameConverter = makeConverter(tokens.iterator());
+        if (procAddressNameConverter == null) {
+            throw new NoSuchElementException("Error creating converter from string");
+        }
     }
-  }
-
-  protected void readProcAddressNameExpr(StringTokenizer tok, String filename, int lineNo) {
-    try {
-      String restOfLine = tok.nextToken("\n\r\f");
-      restOfLine = restOfLine.trim();
-      setProcAddressNameExpr(restOfLine);
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo +
-                                 " in file \"" + filename + "\"", e);
+
+    protected void readProcAddressNameExpr(StringTokenizer tok, String filename, int lineNo) {
+        try {
+            String restOfLine = tok.nextToken("\n\r\f");
+            restOfLine = restOfLine.trim();
+            setProcAddressNameExpr(restOfLine);
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
+        }
     }
-  }
-
-  protected void readLocalProcAddressCallingConvention(StringTokenizer tok, String filename, int lineNo) throws IOException {
-    try {
-      String functionName = tok.nextToken();
-      String callingConvention = tok.nextToken();
-      if(functionName.equals("__ALL__")) {
-        localProcAddressCallingConvention4All=callingConvention;
-      } else {
-        localProcAddressCallingConventionMap.put(functionName, callingConvention);
-      }
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo +
-        " in file \"" + filename + "\"", e);
+
+    protected void readLocalProcAddressCallingConvention(StringTokenizer tok, String filename, int lineNo) throws IOException {
+        try {
+            String functionName = tok.nextToken();
+            String callingConvention = tok.nextToken();
+            if (functionName.equals("__ALL__")) {
+                localProcAddressCallingConvention4All = callingConvention;
+            } else {
+                localProcAddressCallingConventionMap.put(functionName, callingConvention);
+            }
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
+        }
     }
-  }
-
-  private static ConvNode makeConverter(Iterator/*<String>*/ iter) {
-    List/*<ConvNode>*/ result = new ArrayList/*<ConvNode>*/();
-    while (iter.hasNext()) {
-      String str = (String) iter.next();
-      if (str.equals("$")) {
-        String command = (String) iter.next();
-        String openParen = (String) iter.next();
-        if (!openParen.equals("(")) {
-          throw new NoSuchElementException("Expected \"(\"");
+
+    private static ConvNode makeConverter(Iterator<String> iter) {
+        List<ConvNode> result = new ArrayList<ConvNode>();
+
+        while (iter.hasNext()) {
+            String str = iter.next();
+            if (str.equals("$")) {
+                String command = iter.next();
+                String openParen = iter.next();
+                if (!openParen.equals("(")) {
+                    throw new NoSuchElementException("Expected \"(\"");
+                }
+                boolean uppercase = false;
+                if (command.equalsIgnoreCase("UPPERCASE")) {
+                    uppercase = true;
+                } else if (!command.equalsIgnoreCase("LOWERCASE")) {
+                    throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\"");
+                }
+                result.add(new CaseNode(uppercase, makeConverter(iter)));
+            } else if (str.equals(")")) {
+                // Fall through and return
+            } else if (str.indexOf('{') >= 0) {
+                result.add(new FormatNode(str));
+            } else {
+                result.add(new ConstStringNode(str));
+            }
         }
-        boolean uppercase = false;
-        if (command.equalsIgnoreCase("UPPERCASE")) {
-          uppercase = true;
-        } else if (!command.equalsIgnoreCase("LOWERCASE")) {
-          throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\"");
+        if (result.isEmpty()) {
+            return null;
+        } else if (result.size() == 1) {
+            return result.get(0);
+        } else {
+            return new ConcatNode(result);
         }
-        result.add(new CaseNode(uppercase, makeConverter(iter)));
-      } else if (str.equals(")")) {
-        // Fall through and return
-      } else if (str.indexOf('{') >= 0) {
-        result.add(new FormatNode(str));
-      } else {
-        result.add(new ConstStringNode(str));
-      }
     }
-    if (result.size() == 0) {
-      return null;
-    } else if (result.size() == 1) {
-      return (ConvNode) result.get(0);
-    } else {
-      return new ConcatNode(result);
+
+    /** Helper class for converting a function name to the typedef'ed
+    function pointer name */
+    static abstract class ConvNode {
+        abstract String convert(String funcName);
     }
-  }
 
-  /** Helper class for converting a function name to the typedef'ed
-      function pointer name */
-  static abstract class ConvNode {
-    abstract String convert(String funcName);
-  }
+    static class FormatNode extends ConvNode {
+
+        private MessageFormat msgFmt;
 
-  static class FormatNode extends ConvNode {
-    private MessageFormat msgFmt;
+        FormatNode(String fmt) {
+            msgFmt = new MessageFormat(fmt);
+        }
 
-    FormatNode(String fmt) {
-      msgFmt = new MessageFormat(fmt);
+        String convert(String funcName) {
+            StringBuffer buf = new StringBuffer();
+            msgFmt.format(new Object[]{funcName}, buf, null);
+            return buf.toString();
+        }
     }
 
-    String convert(String funcName) {
-      StringBuffer buf = new StringBuffer();
-      msgFmt.format(new Object[] { funcName }, buf, null);
-      return buf.toString();
+    static class ConstStringNode extends ConvNode {
+
+        private String str;
+
+        ConstStringNode(String str) {
+            this.str = str;
+        }
+
+        String convert(String funcName) {
+            return str;
+        }
     }
-  }
 
-  static class ConstStringNode extends ConvNode {
-    private String str;
+    static class ConcatNode extends ConvNode {
 
-    ConstStringNode(String str) {
-      this.str = str;
+        private List<ConvNode> children;
+
+        ConcatNode(List<ConvNode> children) {
+            this.children = children;
+        }
+
+        String convert(String funcName) {
+            StringBuilder res = new StringBuilder();
+            for (ConvNode node : children) {
+                res.append(node.convert(funcName));
+            }
+            return res.toString();
+        }
     }
 
-    String convert(String funcName) {
-      return str;
+    static class CaseNode extends ConvNode {
+
+        private boolean upperCase;
+        private ConvNode child;
+
+        CaseNode(boolean upperCase, ConvNode child) {
+            this.upperCase = upperCase;
+            this.child = child;
+        }
+
+        public String convert(String funcName) {
+            if (upperCase) {
+                return child.convert(funcName).toUpperCase();
+            } else {
+                return child.convert(funcName).toLowerCase();
+            }
+        }
     }
-  }
 
-  static class ConcatNode extends ConvNode {
-    private List/*<ConvNode>*/ children;
+    public boolean emitProcAddressTable() {
+        return emitProcAddressTable;
+    }
 
-    ConcatNode(List/*<ConvNode>*/ children) {
-      this.children = children;
+    public String tableClassPackage() {
+        return tableClassPackage;
     }
 
-    String convert(String funcName) {
-      StringBuffer res = new StringBuffer();
-      for (Iterator iter = children.iterator(); iter.hasNext(); ) {
-        ConvNode node = (ConvNode) iter.next();
-        res.append(node.convert(funcName));
-      }
-      return res.toString();
+    public String tableClassName() {
+        return tableClassName;
     }
-  }
 
-  static class CaseNode extends ConvNode {
-    private boolean upperCase;
-    private ConvNode child;
+    public boolean skipProcAddressGen(String name) {
+        return skipProcAddressGen.contains(name);
+    }
 
-    CaseNode(boolean upperCase, ConvNode child) {
-      this.upperCase = upperCase;
-      this.child = child;
+    public boolean isForceProcAddressGen4All() {
+        return forceProcAddressGen4All;
     }
 
-    public String convert(String funcName) {
-      if (upperCase) {
-        return child.convert(funcName).toUpperCase();
-      } else {
-        return child.convert(funcName).toLowerCase();
-      }
+    public List<String> getForceProcAddressGen() {
+        return forceProcAddressGen;
     }
-  }
-
-  public boolean emitProcAddressTable()           { return emitProcAddressTable;               }
-  public String  tableClassPackage()              { return tableClassPackage;                  }
-  public String  tableClassName()                 { return tableClassName;                     }
-  public boolean skipProcAddressGen (String name) { return skipProcAddressGen.contains(name);  }
-  public boolean isForceProcAddressGen4All()      { return forceProcAddressGen4All;            }
-  public List    getForceProcAddressGen()         { return forceProcAddressGen;                }
-  public String  getProcAddressTableExpr() {
-    if (getProcAddressTableExpr == null) {
-      throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file");
+
+    public String getProcAddressTableExpr() {
+        if (getProcAddressTableExpr == null) {
+            throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file");
+        }
+        return getProcAddressTableExpr;
     }
-    return getProcAddressTableExpr;
-  }
-  public String  convertToFunctionPointerName(String funcName) {
-    if (procAddressNameConverter == null) {
-      throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file");
+
+    public String convertToFunctionPointerName(String funcName) {
+        if (procAddressNameConverter == null) {
+            throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file");
+        }
+        return procAddressNameConverter.convert(funcName);
     }
 
-    return procAddressNameConverter.convert(funcName);
-  }
-  public boolean forceProcAddressGen(String funcName) {
-    return forceProcAddressGen4All || forceProcAddressGenSet.contains(funcName);
-  }
+    public boolean forceProcAddressGen(String funcName) {
+        return forceProcAddressGen4All || forceProcAddressGenSet.contains(funcName);
+    }
 
-  public void addForceProcAddressGen(String funcName) {
+    public void addForceProcAddressGen(String funcName) {
         forceProcAddressGen.add(funcName);
         forceProcAddressGenSet.add(funcName);
-  }
-
-  public void addLocalProcAddressCallingConvention(String funcName, String callingConvention) {
-    localProcAddressCallingConventionMap.put(funcName, callingConvention);
-  }
-
-  public String getLocalProcAddressCallingConvention(String funcName) {
-    if(isLocalProcAddressCallingConvention4All()) return getLocalProcAddressCallingConvention4All();
-    return (String) localProcAddressCallingConventionMap.get(funcName);
-  }
-  public boolean isLocalProcAddressCallingConvention4All()  { return localProcAddressCallingConvention4All!=null; }
-  public String  getLocalProcAddressCallingConvention4All()  { return localProcAddressCallingConvention4All; }
+    }
+
+    public void addLocalProcAddressCallingConvention(String funcName, String callingConvention) {
+        localProcAddressCallingConventionMap.put(funcName, callingConvention);
+    }
+
+    public String getLocalProcAddressCallingConvention(String funcName) {
+        if (isLocalProcAddressCallingConvention4All()) {
+            return getLocalProcAddressCallingConvention4All();
+        }
+        return localProcAddressCallingConventionMap.get(funcName);
+    }
+
+    public boolean isLocalProcAddressCallingConvention4All() {
+        return localProcAddressCallingConvention4All != null;
+    }
+
+    public String getLocalProcAddressCallingConvention4All() {
+        return localProcAddressCallingConvention4All;
+    }
 }