Moved GlueGen out of the JOGL workspace and into its own project.

Restructured JOGL and JOAL build processes to separately invoke
GlueGen's main build.xml before using it to generate their code.
Refactored OS/CPU detection code into gluegen-cpptasks.xml build file
in GlueGen workspace, which is now imported by both the JOGL and JOAL
build processes. Unfortunately it seems to be somewhat difficult to
completely factor out the C compiler configuration into the GlueGen
workspace so this has been left for a later date. Added missed
ALProcAddressLookup file to JOAL workspace. Updated JOGL and JOAL
build documentation. More documentation for the GlueGen workspace is
forthcoming.


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/../svn-server-sync/gluegen/trunk@3 a78bb65f-1512-4460-ba86-f6dc96a7bf27

1 files changed, 852 insertions, 0 deletions

diff --git a/src/java/com/sun/gluegen/cgram/GnuCTreeParser.g b/src/java/com/sun/gluegen/cgram/GnuCTreeParser.g
new file mode 100644
index 0000000..5231dee
--- /dev/null
+++ b/src/java/com/sun/gluegen/cgram/GnuCTreeParser.g
@@ -0,0 +1,852 @@
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+        Copyright (c) Non, Inc. 1998 -- All Rights Reserved
+
+PROJECT:        C Compiler
+MODULE:         GnuCTreeParser
+FILE:           GnuCTreeParser.g
+
+AUTHOR:         Monty Zukowski ([email protected]) April 28, 1998
+
+DESCRIPTION:
+
+                This tree grammar is for a Gnu C AST.  No actions in it,
+                subclass to do something useful.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+
+
+header {
+        package com.sun.gluegen.cgram;
+
+        import java.io.*;
+
+        import antlr.CommonAST;
+        import antlr.DumpASTVisitor;
+}
+
+                     
+class GnuCTreeParser extends TreeParser;
+
+options
+        {
+        importVocab = GNUC;
+        buildAST = false;
+        ASTLabelType = "TNode";
+
+        // Copied following options from java grammar.
+        codeGenMakeSwitchThreshold = 2;
+        codeGenBitsetTestThreshold = 3;
+        }
+
+
+{
+        int traceDepth = 0;
+        public void reportError(RecognitionException ex) {
+          if ( ex != null)   {
+                System.err.println("ANTLR Tree Parsing RecognitionException Error: " + ex.getClass().getName() + " " + ex );
+                ex.printStackTrace(System.err);
+          }
+        }
+        public void reportError(NoViableAltException ex) {
+                System.err.println("ANTLR Tree Parsing NoViableAltException Error: " + ex.toString());
+                TNode.printTree( ex.node );
+                ex.printStackTrace(System.err);
+        }
+        public void reportError(MismatchedTokenException ex) {
+          if ( ex != null)   {
+                TNode.printTree( ex.node );
+                System.err.println("ANTLR Tree Parsing MismatchedTokenException Error: " + ex );
+                ex.printStackTrace(System.err);
+          }
+        }
+        public void reportError(String s) {
+                System.err.println("ANTLR Error from String: " + s);
+        }
+        public void reportWarning(String s) {
+                System.err.println("ANTLR Warning from String: " + s);
+        }
+        protected void match(AST t, int ttype) throws MismatchedTokenException {
+                //System.out.println("match("+ttype+"); cursor is "+t);
+                super.match(t, ttype);
+        }
+        public void match(AST t, BitSet b) throws MismatchedTokenException {
+                //System.out.println("match("+b+"); cursor is "+t);
+                super.match(t, b);
+        }
+        protected void matchNot(AST t, int ttype) throws MismatchedTokenException {
+                //System.out.println("matchNot("+ttype+"); cursor is "+t);
+                super.matchNot(t, ttype);
+                }
+        public void traceIn(String rname, AST t) {
+          traceDepth += 1;
+          for (int x=0; x<traceDepth; x++) System.out.print(" ");
+          super.traceIn(rname, t);   
+        }
+        public void traceOut(String rname, AST t) {
+          for (int x=0; x<traceDepth; x++) System.out.print(" ");
+          super.traceOut(rname, t);
+          traceDepth -= 1;
+        }
+
+
+}
+
+translationUnit  options {
+  defaultErrorHandler=false;
+}
+        :       ( externalList )? 
+        ;
+
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+externalList
+        :       ( externalDef )+
+        ;
+
+
+externalDef
+        :       declaration
+        |       functionDef
+        |       asm_expr
+        |       SEMI
+        |       typelessDeclaration
+        ;
+
+typelessDeclaration
+        :       #(NTypeMissing initDeclList SEMI)
+        ;
+
+
+
+asm_expr
+        :       #( "asm" ( "volatile" )? LCURLY expr RCURLY ( SEMI )+ )
+        ;
+
+
+declaration
+        :       #( NDeclaration
+                    declSpecifiers
+                    (                   
+                        initDeclList
+                    )?
+                    ( SEMI )+
+                )
+        ;
+
+
+declSpecifiers 
+        :       ( storageClassSpecifier
+                | typeQualifier
+                | typeSpecifier
+                )+
+        ;
+
+storageClassSpecifier
+        :       "auto"
+        |       "register"
+        |       "typedef"
+        |       functionStorageClassSpecifier
+        ;
+
+
+functionStorageClassSpecifier
+        :       "extern"
+        |       "static"
+        |       "inline"
+        ;
+
+
+typeQualifier
+        :       "const"
+        |       "volatile"
+        ;
+
+
+typeSpecifier
+        :       "void"
+        |       "char"
+        |       "short"
+        |       "int"
+        |       "long"
+        |       "float"
+        |       "double"
+        |       "signed"
+        |       "unsigned"
+        |       structSpecifier ( attributeDecl )*
+        |       unionSpecifier  ( attributeDecl )*
+        |       enumSpecifier
+        |       typedefName
+        |       #("typeof" LPAREN
+                    ( (typeName )=> typeName 
+                    | expr
+                    )
+                    RPAREN
+                )
+        |       "__complex"
+        ;
+
+
+typedefName
+        :       #(NTypedefName ID)
+        ;
+
+
+structSpecifier
+        :   #( "struct" structOrUnionBody )
+        ;
+
+unionSpecifier
+        :   #( "union" structOrUnionBody )
+        ;
+   
+structOrUnionBody
+        :       ( (ID LCURLY) => ID LCURLY
+                        ( structDeclarationList )?
+                        RCURLY  
+                |   LCURLY
+                    ( structDeclarationList )?
+                    RCURLY
+                | ID
+                )
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+structDeclarationList
+        :       ( structDeclaration )+
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+
+structDeclaration
+        :       specifierQualifierList structDeclaratorList
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+
+specifierQualifierList
+        :       (
+                typeSpecifier
+                | typeQualifier
+                )+
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+
+structDeclaratorList
+        :       ( structDeclarator )+
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+
+structDeclarator
+        :
+        #( NStructDeclarator      
+            ( declarator )?
+            ( COLON expr )?
+            ( attributeDecl )*
+        )
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+
+
+enumSpecifier
+        :   #(  "enum"
+                ( ID )? 
+                ( LCURLY enumList RCURLY )?
+            )
+        ;
+
+
+enumList
+        :       ( enumerator )+
+        ;
+
+
+enumerator
+        :       ID ( ASSIGN expr )?
+        ;
+
+
+
+attributeDecl:
+        #( "__attribute" (.)* )
+        | #( NAsmAttribute LPAREN expr RPAREN )
+        ;
+
+initDeclList
+        :       ( initDecl )+
+        ;
+
+
+initDecl
+                                        { String declName = ""; }
+        :       #( NInitDecl
+                declarator
+                ( attributeDecl )*
+                ( ASSIGN initializer
+                | COLON expr
+                )?
+                )
+        ;
+
+
+pointerGroup
+        :       #( NPointerGroup ( STAR ( typeQualifier )* )+ )
+        ;
+
+
+
+idList
+        :       ID ( COMMA ID )*
+        ;
+
+
+
+initializer
+        :       #( NInitializer (initializerElementLabel)? expr )
+                |   lcurlyInitializer
+        ;
+
+initializerElementLabel
+        :   #( NInitializerElementLabel
+                (
+                    ( LBRACKET expr RBRACKET (ASSIGN)? )
+                    | ID COLON
+                    | DOT ID ASSIGN
+                )
+            )
+        ;
+
+lcurlyInitializer
+        :  #( NLcurlyInitializer
+                initializerList
+                RCURLY
+            )
+        ;
+
+initializerList
+        :       ( initializer )*
+        ;
+
+
+declarator
+        :   #( NDeclarator
+                ( pointerGroup )?               
+
+                ( id:ID
+                | LPAREN declarator RPAREN
+                )
+
+                (   #( NParameterTypeList
+                      (
+                        parameterTypeList
+                        | (idList)?
+                      )
+                      RPAREN
+                    )
+                 | LBRACKET ( expr )? RBRACKET
+                )*
+             )
+        ;
+
+
+ 
+parameterTypeList
+        :       ( parameterDeclaration ( COMMA | SEMI )? )+ ( VARARGS )?
+        ;
+    
+
+
+parameterDeclaration
+        :       #( NParameterDeclaration
+                declSpecifiers
+                (declarator | nonemptyAbstractDeclarator)?
+                )
+        ;
+
+
+functionDef
+        :   #( NFunctionDef
+                ( functionDeclSpecifiers)? 
+                declarator
+                (declaration | VARARGS)*
+                compoundStatement
+            )
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+functionDeclSpecifiers
+        :       
+                ( functionStorageClassSpecifier
+                | typeQualifier
+                | typeSpecifier
+                )+
+        ;
+
+declarationList
+        :       
+                (   //ANTLR doesn't know that declarationList properly eats all the declarations
+                    //so it warns about the ambiguity
+                    options {
+                        warnWhenFollowAmbig = false;
+                    } :
+                localLabelDecl
+                | declaration
+                )+
+        ;
+
+localLabelDecl
+        :   #("__label__" (ID)+ )
+        ;
+   
+
+
+compoundStatement
+        :       #( NCompoundStatement
+                ( declarationList
+                | functionDef
+                )*
+                ( statementList )?
+                RCURLY
+                )
+        ;
+
+statementList
+        :       ( statement )+
+        ;
+
+statement
+        :       statementBody
+        ;
+        
+statementBody
+        :       SEMI                    // Empty statements
+
+        |       compoundStatement       // Group of statements
+
+        |       #(NStatementExpr expr)                    // Expressions
+
+// Iteration statements:
+
+        |       #( "while" expr statement )
+        |       #( "do" statement expr )
+        |       #( "for"
+                expr expr expr
+                statement
+                )
+
+
+// Jump statements:
+
+        |       #( "goto" expr )
+        |       "continue" 
+        |       "break"
+        |       #( "return" ( expr )? )
+
+
+// Labeled statements:
+        |       #( NLabel ID (statement)? )
+        |       #( "case" expr (statement)? )
+        |       #( "default" (statement)? )
+
+
+
+// Selection statements:
+
+        |       #( "if"
+                    expr statement  
+                    ( "else" statement )?
+                 )
+        |       #( "switch" expr statement )
+
+
+
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+
+
+
+
+
+expr
+        :       assignExpr
+        |       conditionalExpr
+        |       logicalOrExpr
+        |       logicalAndExpr
+        |       inclusiveOrExpr
+        |       exclusiveOrExpr
+        |       bitAndExpr
+        |       equalityExpr
+        |       relationalExpr
+        |       shiftExpr
+        |       additiveExpr
+        |       multExpr
+        |       castExpr
+        |       unaryExpr
+        |       postfixExpr
+        |       primaryExpr
+        |       commaExpr
+        |       emptyExpr
+        |       compoundStatementExpr
+        |       initializer
+        |       rangeExpr
+        |       gnuAsmExpr
+        ;
+
+commaExpr
+        :   #(NCommaExpr expr expr)
+        ;
+
+emptyExpr
+        :   NEmptyExpression
+        ;
+
+compoundStatementExpr
+        :   #(LPAREN compoundStatement RPAREN)
+        ;
+
+rangeExpr
+        :   #(NRangeExpr expr VARARGS expr)
+        ;
+
+gnuAsmExpr
+        :   #(NGnuAsmExpr
+                ("volatile")? 
+                LPAREN stringConst
+                ( options { warnWhenFollowAmbig = false; }:
+                  COLON (strOptExprPair ( COMMA strOptExprPair)* )?
+                  ( options { warnWhenFollowAmbig = false; }:
+                    COLON (strOptExprPair ( COMMA strOptExprPair)* )?
+                  )?
+                )?
+                ( COLON stringConst ( COMMA stringConst)* )?
+                RPAREN
+            )
+        ;
+
+strOptExprPair
+        :  stringConst ( LPAREN expr RPAREN )?
+        ;
+        
+assignExpr
+        :       #( ASSIGN expr expr)
+        |       #( DIV_ASSIGN expr expr)
+        |       #( PLUS_ASSIGN expr expr)
+        |       #( MINUS_ASSIGN expr expr)
+        |       #( STAR_ASSIGN expr expr)
+        |       #( MOD_ASSIGN expr expr)
+        |       #( RSHIFT_ASSIGN expr expr)
+        |       #( LSHIFT_ASSIGN expr expr)
+        |       #( BAND_ASSIGN expr expr)
+        |       #( BOR_ASSIGN expr expr)
+        |       #( BXOR_ASSIGN expr expr)
+        ;
+
+
+conditionalExpr
+        :       #( QUESTION expr (expr)? COLON expr )
+        ;
+
+
+logicalOrExpr
+        :       #( LOR expr expr) 
+        ;
+
+
+logicalAndExpr
+        :       #( LAND expr expr )
+        ;
+
+
+inclusiveOrExpr
+        :       #( BOR expr expr )
+        ;
+
+
+exclusiveOrExpr
+        :       #( BXOR expr expr )
+        ;
+
+
+bitAndExpr
+        :       #( BAND expr expr )
+        ;
+
+
+
+equalityExpr
+        :       #( EQUAL expr expr)
+        |       #( NOT_EQUAL expr expr)
+        ;
+
+
+relationalExpr
+        :       #( LT expr expr)
+        |       #( LTE expr expr)
+        |       #( GT expr expr)
+        |       #( GTE expr expr)
+        ;
+
+
+
+shiftExpr
+        :       #( LSHIFT expr expr)
+                | #( RSHIFT expr expr)
+        ;
+
+
+additiveExpr
+        :       #( PLUS expr expr)
+        |       #( MINUS expr expr)
+        ;
+
+
+multExpr
+        :       #( STAR expr expr)
+        |       #( DIV expr expr)
+        |       #( MOD expr expr)
+        ;
+
+
+
+castExpr
+        :       #( NCast typeName RPAREN expr)
+        ;
+
+
+typeName
+        :       specifierQualifierList (nonemptyAbstractDeclarator)?
+        ;
+
+nonemptyAbstractDeclarator
+        :   #( NNonemptyAbstractDeclarator
+            (   pointerGroup
+                (   (LPAREN  
+                    (   nonemptyAbstractDeclarator
+                        | parameterTypeList
+                    )?
+                    RPAREN)
+                | (LBRACKET (expr)? RBRACKET)
+                )*
+
+            |  (   (LPAREN  
+                    (   nonemptyAbstractDeclarator
+                        | parameterTypeList
+                    )?
+                    RPAREN)
+                | (LBRACKET (expr)? RBRACKET)
+                )+
+            )
+            )
+        ;
+
+
+
+unaryExpr
+        :       #( INC expr )
+        |       #( DEC expr )
+        |       #( NUnaryExpr unaryOperator expr)
+        |       #( "sizeof"
+                    ( ( LPAREN typeName )=> LPAREN typeName RPAREN
+                    | expr
+                    )
+                )
+        |       #( "__alignof"
+                    ( ( LPAREN typeName )=> LPAREN typeName RPAREN
+                    | expr
+                    )
+                )
+        ;
+/*
+exception
+catch [RecognitionException ex]
+                        {
+                        reportError(ex);
+                        System.out.println("PROBLEM TREE:\n" 
+                                                + _t.toStringList());
+                        if (_t!=null) {_t = _t.getNextSibling();}
+                        }
+*/
+
+    unaryOperator
+        :       BAND
+        |       STAR
+        |       PLUS
+        |       MINUS
+        |       BNOT
+        |       LNOT
+        |       LAND
+        |       "__real"
+        |       "__imag"
+        ;
+
+
+postfixExpr
+        :       #( NPostfixExpr
+                    primaryExpr
+                    ( PTR ID
+                    | DOT ID
+                    | #( NFunctionCallArgs (argExprList)? RPAREN )
+                    | LBRACKET expr RBRACKET
+                    | INC
+                    | DEC
+                    )+
+                )
+        ;
+
+
+
+primaryExpr
+        :       ID
+        |       Number
+        |       charConst
+        |       stringConst
+
+// JTC:
+// ID should catch the enumerator
+// leaving it in gives ambiguous err
+//      | enumerator
+
+        |       #( NExpressionGroup expr )
+        ;
+
+
+
+argExprList
+        :       ( expr )+
+        ;
+
+
+
+protected
+charConst
+        :       CharLiteral
+        ;
+
+
+protected
+stringConst
+        :       #(NStringSeq (StringLiteral)+)
+        ;
+
+
+protected
+intConst
+        :       IntOctalConst
+        |       LongOctalConst
+        |       UnsignedOctalConst
+        |       IntIntConst
+        |       LongIntConst
+        |       UnsignedIntConst
+        |       IntHexConst
+        |       LongHexConst
+        |       UnsignedHexConst
+        ;
+
+
+protected
+floatConst
+        :       FloatDoubleConst
+        |       DoubleDoubleConst
+        |       LongDoubleConst
+        ;
+
+
+    
+
+
+
+
+
+