GLU tesselator port by Pepijn Van Eeckhoudt and Nathan Parker Burg.

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@57 232f8b59-042b-4e1e-8c03-345bb8c30851

5 files changed, 851 insertions, 15 deletions

diff --git a/make/glu-common.cfg b/make/glu-common.cfg
index 49290bdd3..b7057a978 100644
--- a/make/glu-common.cfg
+++ b/make/glu-common.cfg
@@ -138,7 +138,7 @@ Ignore gluTessNormal
 Ignore gluTessProperty
 Ignore gluTessVertex
 Ignore gluTessCallback.*
-Ignore GLU_TESS.+
+Ignore GLUtesselator
 
 #
 # ------------------------
diff --git a/make/glu-impl-common-CustomJavaCode.java b/make/glu-impl-common-CustomJavaCode.java
index 04505db55..3332bd375 100644
--- a/make/glu-impl-common-CustomJavaCode.java
+++ b/make/glu-impl-common-CustomJavaCode.java
@@ -5,7 +5,77 @@ public boolean isFunctionAvailable(String gluFunctionName)
 }
 
 private GLUProcAddressTable gluProcAddressTable;
+
 public GLUImpl(GLUProcAddressTable gluProcAddressTable)
 {
   this.gluProcAddressTable = gluProcAddressTable;
 }
+
+public GLUtesselator gluNewTess() {
+    return GLUtesselatorImpl.gluNewTess();
+}
+
+public void gluDeleteTess(GLUtesselator tesselator) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluDeleteTess();
+}
+
+public void gluTessProperty(GLUtesselator tesselator, int which, double value) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessProperty(which, value);
+}
+
+public void gluGetTessProperty(GLUtesselator tesselator, int which, double[] value) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluGetTessProperty(which, value);
+}
+
+public void gluTessNormal(GLUtesselator tesselator, double x, double y, double z) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessNormal(x, y, z);
+}
+
+public void gluTessCallback(GLUtesselator tesselator, int which, GLUtesselatorCallback aCallback) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessCallback(which, aCallback);
+}
+
+public void gluTessVertex(GLUtesselator tesselator, double[] coords, Object data) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessVertex(coords, data);
+}
+
+public void gluTessBeginPolygon(GLUtesselator tesselator, Object data) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessBeginPolygon(data);
+}
+
+public void gluTessBeginContour(GLUtesselator tesselator) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessBeginContour();
+}
+
+public void gluTessEndContour(GLUtesselator tesselator) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessEndContour();
+}
+
+public void gluTessEndPolygon(GLUtesselator tesselator) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluTessEndPolygon();
+}
+
+public void gluBeginPolygon(GLUtesselator tesselator) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluBeginPolygon();
+}
+
+public void gluNextContour(GLUtesselator tesselator, int type) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluNextContour(type);
+}
+
+public void gluEndPolygon(GLUtesselator tesselator) {
+    GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
+    tess.gluEndPolygon();
+}
diff --git a/make/glu-impl-common.cfg b/make/glu-impl-common.cfg
index 1e6ae0699..539bf9784 100644
--- a/make/glu-impl-common.cfg
+++ b/make/glu-impl-common.cfg
@@ -9,6 +9,9 @@ EmitProcAddressTable true
 ProcAddressTableClassName GLUProcAddressTable
 GetProcAddressTableExpr gluProcAddressTable
 
+#GLUImpl needs access to the GLUtesselatorImpl class for GLUtesselator.
+Import net.java.games.jogl.impl.tesselator.GLUtesselatorImpl
+
 # Custom Java code for GLUImpl class
 IncludeAs CustomJavaCode GLUImpl glu-impl-common-CustomJavaCode.java
 
diff --git a/make/glu-interface-common-CustomJavaCode.java b/make/glu-interface-common-CustomJavaCode.java
index b520c9487..ad3f94e6e 100644
--- a/make/glu-interface-common-CustomJavaCode.java
+++ b/make/glu-interface-common-CustomJavaCode.java
@@ -1,33 +1,794 @@
+/*****************************************************************************
+ * <b>gluBeginPolygon</b> and {@link net.java.games.jogl.GLU#gluEndPolygon
+ * gluEndPolygon} delimit the definition of a nonconvex polygon. To define
+ * such a polygon, first call <b>gluBeginPolygon</b>. Then define the contours
+ * of the polygon by calling {@link net.java.games.jogl.GLU#gluTessVertex
+ * gluTessVertex} for each vertex and
+ * {@link net.java.games.jogl.GLU#gluNextContour gluNextContour} to start each
+ * new contour. Finally, call {@link net.java.games.jogl.GLU#gluEndPolygon
+ * gluEndPolygon} to signal the end of the definition. See the
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex} and
+ * {@link net.java.games.jogl.GLU#gluNextContour gluNextContour} reference
+ * pages for more details.<P>
+ *
+ * Once {@link net.java.games.jogl.GLU#gluEndPolygon gluEndPolygon} is called,
+ * the polygon is tessellated, and the resulting triangles are described
+ * through callbacks. See {@link net.java.games.jogl.GLU#gluTessCallback
+ * gluTessCallback} for descriptions of the callback methods.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluNextContour      gluNextContour
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ ****************************************************************************/
+public void gluBeginPolygon(GLUtesselator tesselator);
+
+
+/*****************************************************************************
+ * <b>gluDeleteTess</b> destroys the indicated tessellation object (which was
+ * created with {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ *
+ * @param tesselator
+ *        Specifies the tessellation object to destroy.
+ *
+ * @see net.java.games.jogl.GLU#gluBeginPolygon gluBeginPolygon
+ * @see net.java.games.jogl.GLU#gluNewTess      gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessCallback gluTessCallback
+ ****************************************************************************/
+public void gluDeleteTess(GLUtesselator tesselator);
+
+
+/*****************************************************************************
+ * <b>gluEndPolygon</b> and {@link net.java.games.jogl.GLU#gluBeginPolygon
+ * gluBeginPolygon} delimit the definition of a nonconvex polygon. To define
+ * such a polygon, first call {@link net.java.games.jogl.GLU#gluBeginPolygon
+ * gluBeginPolygon}. Then define the contours of the polygon by calling
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex} for each vertex
+ * and {@link net.java.games.jogl.GLU#gluNextContour gluNextContour} to start
+ * each new contour. Finally, call <b>gluEndPolygon</b> to signal the end of
+ * the definition. See the {@link net.java.games.jogl.GLU#gluTessVertex
+ * gluTessVertex} and {@link net.java.games.jogl.GLU#gluNextContour
+ * gluNextContour} reference pages for more details.<P>
+ *
+ * Once <b>gluEndPolygon</b> is called, the polygon is tessellated, and the
+ * resulting triangles are described through callbacks. See
+ * {@link net.java.games.jogl.GLU#gluTessCallback gluTessCallback} for
+ * descriptions of the callback methods.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluNextContour      gluNextContour
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ ****************************************************************************/
+public void gluEndPolygon(GLUtesselator tesselator);
+
+
+/*****************************************************************************
+ * <b>gluGetTessProperty</b> retrieves properties stored in a tessellation
+ * object.  These properties affect the way that tessellation objects are
+ * interpreted and rendered.  See the
+ * {@link net.java.games.jogl.GLU#gluTessProperty gluTessProperty} reference
+ * page for information about the properties and what they do.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ * @param which
+ *        Specifies the property whose value is to be fetched. Valid values
+ *        are <b>GLU_TESS_WINDING_RULE</b>, <b>GLU_TESS_BOUNDARY_ONLY</b>,
+ *        and <b>GLU_TESS_TOLERANCES</b>.
+ * @param value
+ *        Specifices an array into which the value of the named property is
+ *        written.
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess      gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessProperty gluTessProperty
+ ****************************************************************************/
+public void gluGetTessProperty(GLUtesselator tesselator, int which, double[] value);
+
+
+/*****************************************************************************
+ * <b>gluNewTess</b> creates and returns a new tessellation object.  This
+ * object must be referred to when calling tesselation methods.  A return
+ * value of null means that there was not enough memeory to allocate the
+ * object.
+ *
+ * @return A new tessellation object.
+ *
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluDeleteTess       gluDeleteTess
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ ****************************************************************************/
+public GLUtesselator gluNewTess();
+
+
+/*****************************************************************************
+ * <b>gluNextContour</b> is used to describe polygons with multiple
+ * contours. After you describe the first contour through a series of
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex} calls, a
+ * <b>gluNextContour</b> call indicates that the previous contour is complete
+ * and that the next contour is about to begin. Perform another series of
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex} calls to
+ * describe the new contour. Repeat this process until all contours have been
+ * described.<P>
+ *
+ * The type parameter defines what type of contour follows. The following
+ * values are valid. <P>
+ *
+ * <b>GLU_EXTERIOR</b>
+ * <UL>
+ *   An exterior contour defines an exterior boundary of the polygon.
+ * </UL>
+ * <b>GLU_INTERIOR</b>
+ * <UL>
+ *   An interior contour defines an interior boundary of the polygon (such as
+ *   a hole).
+ * </UL>
+ * <b>GLU_UNKNOWN</b>
+ * <UL>
+ *   An unknown contour is analyzed by the library to determine whether it is
+ *   interior or exterior.
+ * </UL>
+ * <b>GLU_CCW, GLU_CW</b>
+ * <UL>
+ *   The first <b>GLU_CCW</b> or <b>GLU_CW</b> contour defined is considered
+ *   to be exterior. All other contours are considered to be exterior if they
+ *   are oriented in the same direction (clockwise or counterclockwise) as the
+ *   first contour, and interior if they are not. If one contour is of type
+ *   <b>GLU_CCW</b> or <b>GLU_CW</b>, then all contours must be of the same
+ *   type (if they are not, then all <b>GLU_CCW</b> and <b>GLU_CW</b> contours
+ *   will be changed to <b>GLU_UNKNOWN</b>). Note that there is no
+ *   real difference between the <b>GLU_CCW</b> and <b>GLU_CW</b> contour
+ *   types.
+ * </UL><P>
+ *
+ * To define the type of the first contour, you can call <b>gluNextContour</b>
+ * before describing the first contour. If you do not call
+ * <b>gluNextContour</b> before the first contour, the first contour is marked
+ * <b>GLU_EXTERIOR</b>.<P>
+ *
+ * <UL>
+ *   <b>Note:</b>  The <b>gluNextContour</b> function is obsolete and is
+ *   provided for backward compatibility only. The <b>gluNextContour</b>
+ *   function is mapped to {@link net.java.games.jogl.GLU#gluTessEndContour
+ *   gluTessEndContour} followed by
+ *   {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour}.
+ * </UL>
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ * @param type
+ *        The type of the contour being defined.
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessEndContour   gluTessEndContour
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ ****************************************************************************/
+public void gluNextContour(GLUtesselator tesselator, int type);
+
+
+/*****************************************************************************
+ * <b>gluTessBeginContour</b> and
+ * {@link net.java.games.jogl.GLU#gluTessEndContour gluTessEndContour} delimit
+ * the definition of a polygon contour. Within each
+ * <b>gluTessBeginContour</b>/
+ * {@link net.java.games.jogl.GLU#gluTessEndContour gluTessEndContour} pair,
+ * there can be zero or more calls to
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link net.java.games.jogl.GLU#gluTessVertex
+ * gluTessVertex} reference page for more details. <b>gluTessBeginContour</b>
+ * can only be called between
+ * {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon} and
+ * {@link net.java.games.jogl.GLU#gluTessEndPolygon gluTessEndPolygon}.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessProperty     gluTessProperty
+ * @see net.java.games.jogl.GLU#gluTessNormal       gluTessNormal
+ * @see net.java.games.jogl.GLU#gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public void gluTessBeginContour(GLUtesselator tesselator);
+
+
+/*****************************************************************************
+ * <b>gluTessBeginPolygon</b> and
+ * {@link net.java.games.jogl.GLU#gluTessEndPolygon gluTessEndPolygon} delimit
+ * the definition of a convex, concave or self-intersecting polygon. Within
+ * each <b>gluTessBeginPolygon</b>/
+ * {@link net.java.games.jogl.GLU#gluTessEndPolygon gluTessEndPolygon} pair,
+ * there must be one or more calls to
+ * {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour}/
+ * {@link net.java.games.jogl.GLU#gluTessEndContour gluTessEndContour}. Within
+ * each contour, there are zero or more calls to
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link net.java.games.jogl.GLU#gluTessVertex
+ * gluTessVertex}, {@link net.java.games.jogl.GLU#gluTessBeginContour
+ * gluTessBeginContour}, and {@link net.java.games.jogl.GLU#gluTessEndContour
+ * gluTessEndContour} reference pages for more details.<P>
+ *
+ * <b>data</b> is a reference to a user-defined data structure. If the
+ * appropriate callback(s) are specified (see
+ * {@link net.java.games.jogl.GLU#gluTessCallback gluTessCallback}), then this
+ * reference is returned to the callback method(s). Thus, it is a convenient
+ * way to store per-polygon information.<P>
+ *
+ * Once {@link net.java.games.jogl.GLU#gluTessEndPolygon gluTessEndPolygon} is
+ * called, the polygon is tessellated, and the resulting triangles are
+ * described through callbacks. See
+ * {@link net.java.games.jogl.GLU#gluTessCallback gluTessCallback} for
+ * descriptions of the callback methods.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ * @param data
+ *        Specifies a reference to user polygon data.
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessProperty     gluTessProperty
+ * @see net.java.games.jogl.GLU#gluTessNormal       gluTessNormal
+ * @see net.java.games.jogl.GLU#gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public void gluTessBeginPolygon(GLUtesselator tesselator, Object data);
+
+
+/*****************************************************************************
+ * <b>gluTessCallback</b> is used to indicate a callback to be used by a
+ * tessellation object. If the specified callback is already defined, then it
+ * is replaced. If <i>aCallback</i> is null, then the existing callback
+ * becomes undefined.<P>
+ *
+ * These callbacks are used by the tessellation object to describe how a
+ * polygon specified by the user is broken into triangles. Note that there are
+ * two versions of each callback: one with user-specified polygon data and one
+ * without. If both versions of a particular callback are specified, then the
+ * callback with user-specified polygon data will be used. Note that the
+ * polygonData parameter used by some of the methods is a copy of the
+ * reference that was specified when
+ * {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ * was called. The legal callbacks are as follows:<P>
+ *
+ * <b>GLU_TESS_BEGIN</b>
+ * <UL>
+ *   The begin callback is invoked like {@link net.java.games.jogl.GL#glBegin
+ *   glBegin} to indicate the start of a (triangle) primitive. The method
+ *   takes a single argument of type int. If the
+ *   <b>GLU_TESS_BOUNDARY_ONLY</b> property is set to <b>GL_FALSE</b>, then
+ *   the argument is set to either <b>GL_TRIANGLE_FAN</b>,
+ *   <b>GL_TRIANGLE_STRIP</b>, or <b>GL_TRIANGLES</b>. If the
+ *   <b>GLU_TESS_BOUNDARY_ONLY</b> property is set to <b>GL_TRUE</b>, then the
+ *   argument will be set to <b>GL_LINE_LOOP</b>. The method prototype for
+ *   this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void begin(int type);</PRE><P>
+ *
+ * <b>GLU_TESS_BEGIN_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_BEGIN</b> callback except
+ *   that it takes an additional reference argument. This reference is
+ *   identical to the opaque reference provided when
+ *   {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void beginData(int type, Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_EDGE_FLAG</b>
+ * <UL>
+ *   The edge flag callback is similar to
+ *   {@link net.java.games.jogl.GL#glEdgeFlag glEdgeFlag}. The method takes
+ *   a single boolean boundaryEdge that indicates which edges lie on the
+ *   polygon boundary. If the boundaryEdge is <b>GL_TRUE</b>, then each vertex
+ *   that follows begins an edge that lies on the polygon boundary, that is,
+ *   an edge that separates an interior region from an exterior one. If the
+ *   boundaryEdge is <b>GL_FALSE</b>, then each vertex that follows begins an
+ *   edge that lies in the polygon interior. The edge flag callback (if
+ *   defined) is invoked before the first vertex callback.<P>
+ *
+ *   Since triangle fans and triangle strips do not support edge flags, the
+ *   begin callback is not called with <b>GL_TRIANGLE_FAN</b> or
+ *   <b>GL_TRIANGLE_STRIP</b> if a non-null edge flag callback is provided.
+ *   (If the callback is initialized to null, there is no impact on
+ *   performance). Instead, the fans and strips are converted to independent
+ *   triangles. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void edgeFlag(boolean boundaryEdge);</PRE>
+ *
+ * <b>GLU_TESS_EDGE_FLAG_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_EDGE_FLAG</b> callback except that it takes
+ *   an additional reference argument. This reference is identical to the
+ *   opaque reference provided when
+ *   {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void edgeFlagData(boolean boundaryEdge, Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_VERTEX</b>
+ * <UL>
+ *   The vertex callback is invoked between the begin and end callbacks. It is
+ *   similar to {@link net.java.games.jogl.GL#glVertex glVertex}, and it
+ *   defines the vertices of the triangles created by the tessellation
+ *   process. The method takes a reference as its only argument. This
+ *   reference is identical to the opaque reference provided by the user when
+ *   the vertex was described (see
+ *   {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex}). The method
+ *   prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void vertex(Object vertexData);</PRE>
+ *
+ * <b>GLU_TESS_VERTEX_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_VERTEX</b> callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void vertexData(Object vertexData, Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_END</b>
+ * <UL>
+ *   The end callback serves the same purpose as
+ *   {@link net.java.games.jogl.GL#glEnd glEnd}. It indicates the end of a
+ *   primitive and it takes no arguments. The method prototype for this
+ *   callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void end();</PRE>
+ *
+ * <b>GLU_TESS_END_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_END</b> callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void endData(Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_COMBINE</b>
+ * <UL>
+ *   The combine callback is called to create a new vertex when the
+ *   tessellation detects an intersection, or wishes to merge features. The
+ *   method takes four arguments: an array of three elements each of type
+ *   double, an array of four references, an array of four elements each of
+ *   type float, and a reference to a reference. The prototype is:
+ * </UL>
+ *
+ * <PRE>
+ *         void combine(double[] coords, Object[] data,
+ *                      float[] weight, Object[] outData);</PRE>
+ *
+ * <UL>
+ *   The vertex is defined as a linear combination of up to four existing
+ *   vertices, stored in <i>data</i>. The coefficients of the linear
+ *   combination are given by <i>weight</i>; these weights always add up to 1.
+ *   All vertex pointers are valid even when some of the weights are 0.
+ *   <i>coords</i> gives the location of the new vertex.<P>
+ *
+ *   The user must allocate another vertex, interpolate parameters using
+ *   <i>data</i> and <i>weight</i>, and return the new vertex pointer
+ *   in <i>outData</i>. This handle is supplied during rendering callbacks.
+ *   The user is responsible for freeing the memory some time after
+ *   {@link net.java.games.jogl.GLU#gluTessEndPolygon gluTessEndPolygon} is
+ *   called.<P>
+ *
+ *   For example, if the polygon lies in an arbitrary plane in 3-space, and a
+ *   color is associated with each vertex, the <b>GLU_TESS_COMBINE</b>
+ *   callback might look like this:
+ * </UL>
+ * <PRE>
+ *         void myCombine(double[] coords, Object[] data,
+ *                        float[] weight, Object[] outData)
+ *         {
+ *            MyVertex newVertex = new MyVertex();
+ *
+ *            newVertex.x = coords[0];
+ *            newVertex.y = coords[1];
+ *            newVertex.z = coords[2];
+ *            newVertex.r = weight[0]*data[0].r +
+ *                          weight[1]*data[1].r +
+ *                          weight[2]*data[2].r +
+ *                          weight[3]*data[3].r;
+ *            newVertex.g = weight[0]*data[0].g +
+ *                          weight[1]*data[1].g +
+ *                          weight[2]*data[2].g +
+ *                          weight[3]*data[3].g;
+ *            newVertex.b = weight[0]*data[0].b +
+ *                          weight[1]*data[1].b +
+ *                          weight[2]*data[2].b +
+ *                          weight[3]*data[3].b;
+ *            newVertex.a = weight[0]*data[0].a +
+ *                          weight[1]*data[1].a +
+ *                          weight[2]*data[2].a +
+ *                          weight[3]*data[3].a;
+ *            outData = newVertex;
+ *         }</PRE>
+ *
+ * <UL>
+ *   If the tessellation detects an intersection, then the
+ *   <b>GLU_TESS_COMBINE</b> or <b>GLU_TESS_COMBINE_DATA</b> callback (see
+ *   below) must be defined, and it must write a non-null reference into
+ *   <i>outData</i>. Otherwise the <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> error
+ *   occurs, and no output is generated.
+ * </UL>
+ *
+ * <b>GLU_TESS_COMBINE_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_COMBINE</b> callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void combineData(double[] coords, Object[] data,
+                            float[] weight, Object[] outData,
+                            Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_ERROR</b>
+ * <UL>
+ *   The error callback is called when an error is encountered. The one
+ *   argument is of type int; it indicates the specific error that occurred
+ *   and will be set to one of <b>GLU_TESS_MISSING_BEGIN_POLYGON</b>,
+ *   <b>GLU_TESS_MISSING_END_POLYGON</b>,
+ *   <b>GLU_TESS_MISSING_BEGIN_CONTOUR</b>,
+ *   <b>GLU_TESS_MISSING_END_CONTOUR</b>, <b>GLU_TESS_COORD_TOO_LARGE</b>,
+ *   <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> or <b>GLU_OUT_OF_MEMORY</b>.
+ *   Character strings describing these errors can be retrieved with the
+ *   {@link net.java.games.jogl.GLU#gluErrorString gluErrorString} call. The
+ *   method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void error(int errnum);</PRE>
+ *
+ * <UL>
+ *   The GLU library will recover from the first four errors by inserting the
+ *   missing call(s). <b>GLU_TESS_COORD_TOO_LARGE</b> indicates that some
+ *   vertex coordinate exceeded the predefined constant
+ *   <b>GLU_TESS_MAX_COORD</b> in absolute value, and that the value has been
+ *   clamped. (Coordinate values must be small enough so that two can be
+ *   multiplied together without overflow.)
+ *   <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> indicates that the tessellation
+ *   detected an intersection between two edges in the input data, and the
+ *   <b>GLU_TESS_COMBINE</b> or <b>GLU_TESS_COMBINE_DATA</b> callback was not
+ *   provided. No output is generated. <b>GLU_OUT_OF_MEMORY</b> indicates that
+ *   there is not enough memory so no output is generated.
+ * </UL>
+ *
+ * <b>GLU_TESS_ERROR_DATA</b>
+ * <UL>
+ *   The same as the GLU_TESS_ERROR callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void errorData(int errnum, Object polygonData);</PRE>
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ * @param which
+ *        Specifies the callback being defined. The following values are
+ *        valid: <b>GLU_TESS_BEGIN</b>, <b>GLU_TESS_BEGIN_DATA</b>,
+ *        <b>GLU_TESS_EDGE_FLAG</b>, <b>GLU_TESS_EDGE_FLAG_DATA</b>,
+ *        <b>GLU_TESS_VERTEX</b>, <b>GLU_TESS_VERTEX_DATA</b>,
+ *        <b>GLU_TESS_END</b>, <b>GLU_TESS_END_DATA</b>,
+ *        <b>GLU_TESS_COMBINE</b>,  <b>GLU_TESS_COMBINE_DATA</b>,
+ *        <b>GLU_TESS_ERROR</b>, and <b>GLU_TESS_ERROR_DATA</b>.
+ * @param aCallback
+ *        Specifies the callback object to be called.
+ *
+ * @see net.java.games.jogl.GL#glBegin              glBegin
+ * @see net.java.games.jogl.GL#glEdgeFlag           glEdgeFlag
+ * @see net.java.games.jogl.GL#glVertex             glVertex
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluErrorString      gluErrorString
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ * @see net.java.games.jogl.GLU#gluTessProperty     gluTessProperty
+ * @see net.java.games.jogl.GLU#gluTessNormal       gluTessNormal
+ ****************************************************************************/
+public void gluTessCallback(GLUtesselator tesselator, int which,
+                            GLUtesselatorCallback aCallback);
+
+
+/*****************************************************************************
+ *  <b>gluTessEndContour</b> and
+ * {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour}
+ * delimit the definition of a polygon contour. Within each
+ * {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour}/
+ * <b>gluTessEndContour</b> pair, there can be zero or more calls to
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link net.java.games.jogl.GLU#gluTessVertex
+ * gluTessVertex} reference page for more details.
+ * {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour} can
+ * only be called between {@link net.java.games.jogl.GLU#gluTessBeginPolygon
+ * gluTessBeginPolygon} and
+ * {@link net.java.games.jogl.GLU#gluTessEndPolygon gluTessEndPolygon}.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessProperty     gluTessProperty
+ * @see net.java.games.jogl.GLU#gluTessNormal       gluTessNormal
+ * @see net.java.games.jogl.GLU#gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public void gluTessEndContour(GLUtesselator tesselator);
+
+
+/*****************************************************************************
+ * <b>gluTessEndPolygon</b> and
+ * {@link net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon}
+ * delimit the definition of a convex, concave or self-intersecting polygon.
+ * Within each {@link net.java.games.jogl.GLU#gluTessBeginPolygon
+ * gluTessBeginPolygon}/<b>gluTessEndPolygon</b> pair, there must be one or
+ * more calls to {@link net.java.games.jogl.GLU#gluTessBeginContour
+ * gluTessBeginContour}/{@link net.java.games.jogl.GLU#gluTessEndContour
+ * gluTessEndContour}. Within each contour, there are zero or more calls to
+ * {@link net.java.games.jogl.GLU#gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link net.java.games.jogl.GLU#gluTessVertex
+ * gluTessVertex}, {@link net.java.games.jogl.GLU#gluTessBeginContour
+ * gluTessBeginContour} and {@link net.java.games.jogl.GLU#gluTessEndContour
+ * gluTessEndContour} reference pages for more details.<P>
+ *
+ * Once <b>gluTessEndPolygon</b> is called, the polygon is tessellated, and
+ * the resulting triangles are described through callbacks. See
+ * {@link net.java.games.jogl.GLU#gluTessCallback gluTessCallback} for
+ * descriptions of the callback functions.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ *
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ * @see net.java.games.jogl.GLU#gluTessVertex       gluTessVertex
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessProperty     gluTessProperty
+ * @see net.java.games.jogl.GLU#gluTessNormal       gluTessNormal
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ ****************************************************************************/
+public void gluTessEndPolygon(GLUtesselator tesselator);
+
+
+/*****************************************************************************
+ * <b>gluTessNormal</b> describes a normal for a polygon that the program is
+ * defining. All input data will be projected onto a plane perpendicular to
+ * the one of the three coordinate axes before tessellation and all output
+ * triangles will be oriented CCW with repsect to the normal (CW orientation
+ * can be obtained by reversing the sign of the supplied normal).  For
+ * example, if you know that all polygons lie in the x-y plane, call
+ * <b>gluTessNormal</b>(tess, 0.0, 0.0, 0.0) before rendering any polygons.<P>
+ *
+ * If the supplied normal is (0.0, 0.0, 0.0)(the initial value), the normal
+ * is determined as follows.  The direction of the normal, up to its sign, is
+ * found by fitting a plane to the vertices, without regard to how the
+ * vertices are connected.  It is expected that the input data lies
+ * approximately in the plane; otherwise, projection perpendicular to one of
+ * the three coordinate axes may substantially change the geometry.  The sign
+ * of the normal is chosen so that the sum of the signed areas of all input
+ * contours is nonnegative (where a CCW contour has positive area).<P>
+ *
+ * The supplied normal persists until it is changed by another call to
+ * <b>gluTessNormal</b>.
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created by
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ * @param x
+ *        Specifies the first component of the normal.
+ * @param y
+ *        Specifies the second component of the normal.
+ * @param z
+ *        Specifies the third component of the normal.
+ *
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public void gluTessNormal(GLUtesselator tesselator, double x, double y, double z);
+
+
+/*****************************************************************************
+ * <b>gluTessProperty</b> is used to control properites stored in a
+ * tessellation object.  These properties affect the way that the polygons are
+ * interpreted and rendered.  The legal value for <i>which</i> are as
+ * follows:<P>
+ *
+ * <b>GLU_TESS_WINDING_RULE</b>
+ * <UL>
+ *   Determines which parts of the polygon are on the "interior".
+ *   <em>value</em> may be set to one of
+ *   <BR><b>GLU_TESS_WINDING_ODD</b>,
+ *   <BR><b>GLU_TESS_WINDING_NONZERO</b>,
+ *   <BR><b>GLU_TESS_WINDING_POSITIVE</b>, or
+ *   <BR><b>GLU_TESS_WINDING_NEGATIVE</b>, or
+ *   <BR><b>GLU_TESS_WINDING_ABS_GEQ_TWO</b>.<P>
+ *
+ *   To understand how the winding rule works, consider that the input
+ *   contours partition the plane into regions.  The winding rule determines
+ *   which of these regions are inside the polygon.<P>
+ *
+ *   For a single contour C, the winding number of a point x is simply the
+ *   signed number of revolutions we make around x as we travel once around C
+ *   (where CCW is positive).  When there are several contours, the individual
+ *   winding numbers are summed.  This procedure associates a signed integer
+ *   value with each point x in the plane.  Note that the winding number is
+ *   the same for all points in a single region.<P>
+ *
+ *   The winding rule classifies a region as "inside" if its winding number
+ *   belongs to the chosen category (odd, nonzero, positive, negative, or
+ *   absolute value of at least two).  The previous GLU tesselator (prior to
+ *   GLU 1.2) used the "odd" rule.  The "nonzero" rule is another common way
+ *   to define the interior.  The other three rules are useful for polygon CSG
+ *   operations.
+ * </UL>
+ * <BR><b>GLU_TESS_BOUNDARY_ONLY</b>
+ * <UL>
+ *   Is a boolean value ("value" should be set to GL_TRUE or GL_FALSE). When
+ *   set to GL_TRUE, a set of closed contours separating the polygon interior
+ *   and exterior are returned instead of a tessellation.  Exterior contours
+ *   are oriented CCW with respect to the normal; interior contours are
+ *   oriented CW. The <b>GLU_TESS_BEGIN</b> and <b>GLU_TESS_BEGIN_DATA</b>
+ *   callbacks use the type GL_LINE_LOOP for each contour.
+ * </UL>
+ * <BR><b>GLU_TESS_TOLERANCE</b>
+ * <UL>
+ *   Specifies a tolerance for merging features to reduce the size of the
+ *   output. For example, two vertices that are very close to each other
+ *   might be replaced by a single vertex.  The tolerance is multiplied by the
+ *   largest coordinate magnitude of any input vertex; this specifies the
+ *   maximum distance that any feature can move as the result of a single
+ *   merge operation.  If a single feature takes part in several merge
+ *   operations, the toal distance moved could be larger.<P>
+ *
+ *   Feature merging is completely optional; the tolerance is only a hint.
+ *   The implementation is free to merge in some cases and not in others, or
+ *   to never merge features at all.  The initial tolerance is 0.<P>
+ *
+ *   The current implementation merges vertices only if they are exactly
+ *   coincident, regardless of the current tolerance.  A vertex is spliced
+ *   into an edge only if the implementation is unable to distinguish which
+ *   side of the edge the vertex lies on.  Two edges are merged only when both
+ *   endpoints are identical.
+ * </UL>
+ *
+ * @param tesselator
+ *        Specifies the tessellation object created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}
+ * @param which
+ *        Specifies the property to be set.  Valid values are
+ *        <b>GLU_TESS_WINDING_RULE</b>, <b>GLU_TESS_BOUNDARDY_ONLY</b>,
+ *        <b>GLU_TESS_TOLERANCE</b>.
+ * @param value
+ *        Specifices the value of the indicated property.
+ *
+ * @see net.java.games.jogl.GLU#gluGetTessProperty gluGetTessProperty
+ * @see net.java.games.jogl.GLU#gluNewTess         gluNewTess
+ ****************************************************************************/
+public void gluTessProperty(GLUtesselator tesselator, int which, double value);
+
+
+/*****************************************************************************
+ * <b>gluTessVertex</b> describes a vertex on a polygon that the program
+ * defines. Successive <b>gluTessVertex</b> calls describe a closed contour.
+ * For example, to describe a quadrilateral <b>gluTessVertex</b> should be
+ * called four times. <b>gluTessVertex</b> can only be called between
+ * {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour} and
+ * {@link net.java.games.jogl.GLU#gluTessBeginContour gluTessEndContour}.<P>
+ *
+ * <b>data</b> normally references to a structure containing the vertex
+ * location, as well as other per-vertex attributes such as color and normal.
+ * This reference is passed back to the user through the
+ * <b>GLU_TESS_VERTEX</b> or <b>GLU_TESS_VERTEX_DATA</b> callback after
+ * tessellation (see the {@link net.java.games.jogl.GLU#gluTessCallback
+ * gluTessCallback} reference page).
+ *
+ * @param tesselator
+ *        Specifies the tessellation object (created with
+ *        {@link net.java.games.jogl.GLU#gluNewTess gluNewTess}).
+ * @param coords
+ *        Specifies the coordinates of the vertex.
+ * @param data
+ *        Specifies an opaque reference passed back to the program with the
+ *        vertex callback (as specified by
+ *        {@link net.java.games.jogl.GLU#gluTessCallback gluTessCallback}).
+ *
+ * @see net.java.games.jogl.GLU#gluTessBeginPolygon gluTessBeginPolygon
+ * @see net.java.games.jogl.GLU#gluNewTess          gluNewTess
+ * @see net.java.games.jogl.GLU#gluTessBeginContour gluTessBeginContour
+ * @see net.java.games.jogl.GLU#gluTessCallback     gluTessCallback
+ * @see net.java.games.jogl.GLU#gluTessProperty     gluTessProperty
+ * @see net.java.games.jogl.GLU#gluTessNormal       gluTessNormal
+ * @see net.java.games.jogl.GLU#gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public void gluTessVertex(GLUtesselator tesselator, double[] coords, Object data);
+
 
 /**
  * Returns true if the specified GLU core- or extension-function can be
- * successfully used through this GLU instance. By "successfully" we mean 
- * that the function is both <i>callable</i> on the machine running the 
- * program and <i>available</i> on the current display.<P> 
+ * successfully used through this GLU instance. By "successfully" we mean
+ * that the function is both <i>callable</i> on the machine running the
+ * program and <i>available</i> on the current display.<P>
  *
- * A GLU function is <i>callable</i> if it is a GLU core- or extension-function 
- * that is supported by the underlying GLU implementation. The function is 
+ * A GLU function is <i>callable</i> if it is a GLU core- or extension-function
+ * that is supported by the underlying GLU implementation. The function is
  * <i>available</i> if the OpenGL implementation on the display meets the
  * requirements of the GLU function being called (because GLU functions utilize
  * OpenGL functions). <P>
- * 
- * Whether or not a GLU function is <i>callable</i> is determined as follows: 
+ *
+ * Whether or not a GLU function is <i>callable</i> is determined as follows:
  * <ul>
  *   <li>If the function is a GLU core function (i.e., not an
  *   extension), <code>gluGetString(GLU_VERSION)</code> is used to determine the
  *   version number of the underlying GLU implementation on the host.
- *   then the function name is cross-referenced with that specification to 
+ *   then the function name is cross-referenced with that specification to
  *   see if it is part of that version's specification.
- * 
+ *
  *   <li> If the function is a GLU extension, the function name is
  *   cross-referenced with the list returned by
  *   <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of
  *   the extensions that is supported by the underlying GLU implementation.
  * </ul>
  *
- * Whether or not a GLU function is <i>available</i> is determined as follows: 
+ * Whether or not a GLU function is <i>available</i> is determined as follows:
  * <ul>
- *   <li>If the function is a GLU core function then the function is first 
+ *   <li>If the function is a GLU core function then the function is first
  *   cross-referenced with the GLU specifications to find the minimum GLU
  *   version required to <i>call</i> that GLU function. Then the following table
  *   is consulted to determine the minimum GL version required for that version
@@ -40,15 +801,15 @@
  *   </ul>
  *   Finally, <code>glGetString(GL_VERSION)</code> is used to determine the
  *   highest OpenGL version that both host and display support, and from that it
- *   is possible to determine if the GL facilities required by the GLU function 
+ *   is possible to determine if the GL facilities required by the GLU function
  *   are <i>available</i> on the display.
- * 
+ *
  *   <li> If the function is a GLU extension, the function name is
  *   cross-referenced with the list returned by
  *   <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of
  *   the extensions that is supported by the underlying GLU implementation.
  * </ul>
- * 
+ *
  * <b>NOTE:</b>The availability of a function may change at runtime in
  * response to changes in the display environment. For example, when a window
  * is dragged from one display to another on a multi-display system, or when
diff --git a/make/host.properties b/make/host.properties
index b88cd68ca..da187e3f1 100644
--- a/make/host.properties
+++ b/make/host.properties
@@ -21,6 +21,8 @@ antlr.jar=C:/Users/kbr/ANTLR/antlr-2.7.2/antlr.jar
 # antlr.jar=/home/kbr/antlr-2.7.2/antlr.jar
 # Mac OS X
 # antlr.jar=/Users/kbr/antlr-2.7.2/antlr.jar
+# Solaris
+# antlr.jar=/export/kbr/ANTLR/antlr-2.7.2/antlr.jar
 
 #
 # Force the use of jikes in +E (emacs) mode