aboutsummaryrefslogtreecommitdiffstats
path: root/src/main/antlr/com/jogamp/gluegen/cgram/HeaderParser.g
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/antlr/com/jogamp/gluegen/cgram/HeaderParser.g')
-rw-r--r--src/main/antlr/com/jogamp/gluegen/cgram/HeaderParser.g785
1 files changed, 0 insertions, 785 deletions
diff --git a/src/main/antlr/com/jogamp/gluegen/cgram/HeaderParser.g b/src/main/antlr/com/jogamp/gluegen/cgram/HeaderParser.g
deleted file mode 100644
index 75cf413..0000000
--- a/src/main/antlr/com/jogamp/gluegen/cgram/HeaderParser.g
+++ /dev/null
@@ -1,785 +0,0 @@
-/*
- * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
- * Copyright (c) 2010 JogAmp Community. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * - Redistribution of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistribution in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * Neither the name of Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MIDROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- *
- * You acknowledge that this software is not designed or intended for use
- * in the design, construction, operation or maintenance of any nuclear
- * facility.
- *
- * Sun gratefully acknowledges that this software was originally authored
- * and developed by Kenneth Bradley Russell and Christopher John Kline.
- */
-
-header {
- package com.jogamp.gluegen.cgram;
-
- import java.io.*;
- import java.util.*;
-
- import antlr.CommonAST;
- import com.jogamp.gluegen.cgram.types.*;
-}
-
-class HeaderParser extends GnuCTreeParser;
-options {
- k = 1;
-}
-
-{
- /** Name assigned to a anonymous EnumType (e.g., "enum { ... }"). */
- public static final String ANONYMOUS_ENUM_NAME = "<anonymous>";
-
- boolean debug = false;
-
- public boolean getDebug() {
- return debug;
- }
-
- public void setDebug(boolean debug) {
- this.debug = debug;
- }
-
- /** Set the dictionary mapping typedef names to types for this
- HeaderParser. Must be done before parsing. */
- public void setTypedefDictionary(TypeDictionary dict) {
- this.typedefDictionary = dict;
- }
-
- /** Returns the typedef dictionary this HeaderParser uses. */
- public TypeDictionary getTypedefDictionary() {
- return typedefDictionary;
- }
-
- /** Set the dictionary mapping struct names (i.e., the "foo" in
- "struct foo { ... };") to types for this HeaderParser. Must be done
- before parsing. */
- public void setStructDictionary(TypeDictionary dict) {
- this.structDictionary = dict;
- }
-
- /** Returns the struct name dictionary this HeaderParser uses. */
- public TypeDictionary getStructDictionary() {
- return structDictionary;
- }
-
- /** Get the canonicalization map, which is a regular HashMap
- mapping Type to Type and which is used for looking up the unique
- instances of e.g. pointer-to-structure types that have been typedefed
- and therefore have names. */
- public Map getCanonMap() {
- return canonMap;
- }
-
- /** Pre-define the list of EnumTypes for this HeaderParser. Must be
- done before parsing. */
- public void setEnums(List<EnumType> enumTypes) {
- // FIXME: Need to take the input set of EnumTypes, extract all
- // the enumerates from each EnumType, and fill in the enumHash
- // so that each enumerate maps to the enumType to which it
- // belongs.
- throw new RuntimeException("setEnums is Unimplemented!");
- }
-
- /** Returns the EnumTypes this HeaderParser processed. */
- public List<EnumType> getEnums() {
- return new ArrayList<EnumType>(enumHash.values());
- }
-
- /** Clears the list of functions this HeaderParser has parsed.
- Useful when reusing the same HeaderParser for more than one
- header file. */
- public void clearParsedFunctions() {
- functions.clear();
- }
-
- /** Returns the list of FunctionSymbols this HeaderParser has parsed. */
- public List<FunctionSymbol> getParsedFunctions() {
- return functions;
- }
-
- private CompoundType lookupInStructDictionary(String typeName,
- CompoundTypeKind kind,
- int cvAttrs) {
- CompoundType t = (CompoundType) structDictionary.get(typeName);
- if (t == null) {
- t = CompoundType.create(null, null, kind, cvAttrs);
- t.setStructName(typeName);
- structDictionary.put(typeName, t);
- }
- return t;
- }
-
- private Type lookupInTypedefDictionary(String typeName) {
- Type t = typedefDictionary.get(typeName);
- if (t == null) {
- throw new RuntimeException("Undefined reference to typedef name " + typeName);
- }
- return t;
- }
-
- static class ParameterDeclaration {
- private String id;
- private Type type;
-
- ParameterDeclaration(String id, Type type) {
- this.id = id;
- this.type = type;
- }
- String id() { return id; }
- Type type() { return type; }
- }
-
- // A box for a Type. Allows type to be passed down to be modified by recursive rules.
- static class TypeBox {
- private Type origType;
- private Type type;
- private boolean isTypedef;
-
- TypeBox(Type type) {
- this(type, false);
- }
-
- TypeBox(Type type, boolean isTypedef) {
- this.origType = type;
- this.isTypedef = isTypedef;
- }
-
- Type type() {
- if (type == null) {
- return origType;
- }
- return type;
- }
- void setType(Type type) {
- this.type = type;
- }
- void reset() {
- type = null;
- }
-
- boolean isTypedef() { return isTypedef; }
-
- // for easier debugging
- public String toString() {
- String tStr = "Type=NULL_REF";
- if (type == origType) {
- tStr = "Type=ORIG_TYPE";
- } else if (type != null) {
- tStr = "Type: name=\"" + type.getCVAttributesString() + " " +
- type.getName() + "\"; signature=\"" + type + "\"; class " +
- type.getClass().getName();
- }
- String oStr = "OrigType=NULL_REF";
- if (origType != null) {
- oStr = "OrigType: name=\"" + origType.getCVAttributesString() + " " +
- origType.getName() + "\"; signature=\"" + origType + "\"; class " +
- origType.getClass().getName();
- }
- return "<["+tStr + "] [" + oStr + "] " + " isTypedef=" + isTypedef+">";
- }
- }
-
- private String getTypeString(Type t) {
- StringBuilder sb = new StringBuilder();
- sb.append("[");
- sb.append(t);
- sb.append(", size: ");
- if(null!=t) {
- SizeThunk st = t.getSize();
- if(null!=st) {
- sb.append(st.getClass().getName());
- } else {
- sb.append("undef");
- }
- }
- sb.append("]");
- return sb.toString();
- }
-
- private void debugPrintln(String msg) {
- if(debug) {
- System.err.println(msg);
- }
- }
-
- private void debugPrint(String msg) {
- if(debug) {
- System.err.print(msg);
- }
- }
-
- private boolean doDeclaration; // Used to only process function typedefs
- private String declId;
- private List parameters;
- private TypeDictionary typedefDictionary;
- private TypeDictionary structDictionary;
- private List<FunctionSymbol> functions = new ArrayList<FunctionSymbol>();
- // hash from name of an enumerated value to the EnumType to which it belongs
- private HashMap<String, EnumType> enumHash = new HashMap<String, EnumType>();
-
- // Storage class specifiers
- private static final int AUTO = 1 << 0;
- private static final int REGISTER = 1 << 1;
- private static final int TYPEDEF = 1 << 2;
- // Function storage class specifiers
- private static final int EXTERN = 1 << 3;
- private static final int STATIC = 1 << 4;
- private static final int INLINE = 1 << 5;
- // Type qualifiers
- private static final int CONST = 1 << 6;
- private static final int VOLATILE = 1 << 7;
- private static final int SIGNED = 1 << 8;
- private static final int UNSIGNED = 1 << 9;
-
- private void initDeclaration() {
- doDeclaration = false;
- declId = null;
- }
-
- private void doDeclaration() {
- doDeclaration = true;
- }
-
- private void processDeclaration(Type returnType) {
- if (doDeclaration) {
- FunctionSymbol sym = new FunctionSymbol(declId, new FunctionType(null, null, returnType, 0));
- if (parameters != null) { // handle funcs w/ empty parameter lists (e.g., "foo()")
- for (Iterator iter = parameters.iterator(); iter.hasNext(); ) {
- ParameterDeclaration pd = (ParameterDeclaration) iter.next();
- sym.addArgument(pd.type(), pd.id());
- }
- }
- functions.add(sym);
- }
- }
-
- private int attrs2CVAttrs(int attrs) {
- int cvAttrs = 0;
- if ((attrs & CONST) != 0) {
- cvAttrs |= CVAttributes.CONST;
- }
- if ((attrs & VOLATILE) != 0) {
- cvAttrs |= CVAttributes.VOLATILE;
- }
- return cvAttrs;
- }
-
- /** Helper routine which handles creating a pointer or array type
- for [] expressions */
- private void handleArrayExpr(TypeBox tb, AST t) {
- if (t != null) {
- try {
- int len = parseIntConstExpr(t);
- tb.setType(canonicalize(new ArrayType(tb.type(), SizeThunk.mul(SizeThunk.constant(len), tb.type().getSize()), len, 0)));
- return;
- } catch (RecognitionException e) {
- // Fall through
- }
- }
- tb.setType(canonicalize(new PointerType(SizeThunk.POINTER,
- tb.type(),
- 0)));
- }
-
- private int parseIntConstExpr(AST t) throws RecognitionException {
- return intConstExpr(t);
- }
-
- /** Utility function: creates a new EnumType with the given name, or
- returns an existing one if it has already been created. */
- private EnumType getEnumType(String enumTypeName) {
- EnumType enumType = null;
- Iterator<EnumType> it = enumHash.values().iterator();
- while (it.hasNext()) {
- EnumType potentialMatch = it.next();
- if (potentialMatch.getName().equals(enumTypeName)) {
- enumType = potentialMatch;
- break;
- }
- }
-
- if (enumType == null) {
- // This isn't quite correct. In theory the enum should expand to
- // the size of the largest element, so if there were a long long
- // entry the enum should expand to e.g. int64. However, using
- // "long" here (which is what used to be the case) was
- // definitely incorrect and caused problems.
- enumType = new EnumType(enumTypeName, SizeThunk.INT32);
- }
-
- return enumType;
- }
-
- // Map used to canonicalize types. For example, we may typedef
- // struct foo { ... } *pfoo; subsequent references to struct foo* should
- // point to the same PointerType object that had its name set to "pfoo".
- private Map canonMap = new HashMap();
- private Type canonicalize(Type t) {
- Type res = (Type) canonMap.get(t);
- if (res != null) {
- return res;
- }
- canonMap.put(t, t);
- return t;
- }
-}
-
-declarator[TypeBox tb] returns [String s] {
- initDeclaration();
- s = null;
- List params = null;
- String funcPointerName = null;
- TypeBox dummyTypeBox = null;
-}
- : #( NDeclarator
- ( pointerGroup[tb] )?
-
- ( id:ID { s = id.getText(); }
- | LPAREN funcPointerName = declarator[dummyTypeBox] RPAREN
- )
-
- ( #( NParameterTypeList
- (
- params = parameterTypeList
- | (idList)?
- )
- RPAREN
- ) {
- if (id != null) {
- declId = id.getText();
- parameters = params; // FIXME: Ken, why are we setting this class member here?
- doDeclaration();
- } else if ( funcPointerName != null ) {
- /* TypeBox becomes function pointer in this case */
- FunctionType ft = new FunctionType(null, null, tb.type(), 0);
- if (params == null) {
- // If the function pointer has no declared parameters, it's a
- // void function. I'm not sure if the parameter name is
- // ever referenced anywhere when the type is VoidType, so
- // just in case I'll set it to a comment string so it will
- // still compile if written out to code anywhere.
- ft.addArgument(new VoidType(0), "/*unnamed-void*/");
- } else {
- for (Iterator iter = params.iterator(); iter.hasNext(); ) {
- ParameterDeclaration pd = (ParameterDeclaration) iter.next();
- ft.addArgument(pd.type(), pd.id());
- }
- }
- tb.setType(canonicalize(new PointerType(SizeThunk.POINTER,
- ft,
- 0)));
- s = funcPointerName;
- }
- }
- | LBRACKET ( e:expr )? RBRACKET { handleArrayExpr(tb, e); }
- )*
- )
- ;
-
-typelessDeclaration {
- TypeBox tb = null;
-}
- : #(NTypeMissing initDeclList[tb] SEMI)
- ;
-
-declaration {
- TypeBox tb = null;
-}
- : #( NDeclaration
- tb = declSpecifiers
- (
- initDeclList[tb]
- )?
- ( SEMI )+
- ) { processDeclaration(tb.type()); }
- ;
-
-parameterTypeList returns [List l] { l = new ArrayList(); ParameterDeclaration decl = null; }
- : ( decl = parameterDeclaration { if (decl != null) l.add(decl); } ( COMMA | SEMI )? )+ ( VARARGS )?
- ;
-
-parameterDeclaration returns [ParameterDeclaration pd] {
- Type t = null;
- String decl = null;
- pd = null;
- TypeBox tb = null;
-}
- : #( NParameterDeclaration
- tb = declSpecifiers
- (decl = declarator[tb] | nonemptyAbstractDeclarator[tb])?
- ) { pd = new ParameterDeclaration(decl, tb.type()); }
- ;
-
-functionDef {
- TypeBox tb = null;
-}
- : #( NFunctionDef
- ( functionDeclSpecifiers)?
- declarator[tb]
- (declaration | VARARGS)*
- compoundStatement
- )
- ;
-
-declSpecifiers returns [TypeBox tb] {
- tb = null;
- Type t = null;
- int x = 0;
- int y = 0;
-}
- : ( y = storageClassSpecifier { x |= y; }
- | y = typeQualifier { x |= y; }
- | t = typeSpecifier[x]
- )+
-{
- if (t == null &&
- (x & (SIGNED | UNSIGNED)) != 0) {
- t = new IntType("int", SizeThunk.INTxx, ((x & UNSIGNED) != 0), attrs2CVAttrs(x));
- }
- tb = new TypeBox(t, ((x & TYPEDEF) != 0));
-}
- ;
-
-storageClassSpecifier returns [int x] { x = 0; }
- : "auto" { x |= AUTO; }
- | "register" { x |= REGISTER; }
- | "typedef" { x |= TYPEDEF; }
- | x = functionStorageClassSpecifier
- ;
-
-
-functionStorageClassSpecifier returns [int x] { x = 0; }
- : "extern" { x |= EXTERN; }
- | "static" { x |= STATIC; }
- | "inline" { x |= INLINE; }
- ;
-
-
-typeQualifier returns [int x] { x = 0; }
- : "const" { x |= CONST; }
- | "volatile" { x |= VOLATILE; }
- | "signed" { x |= SIGNED; }
- | "unsigned" { x |= UNSIGNED; }
- ;
-
-typeSpecifier[int attributes] returns [Type t] {
- t = null;
- int cvAttrs = attrs2CVAttrs(attributes);
- boolean unsigned = ((attributes & UNSIGNED) != 0);
-}
- : "void" { t = new VoidType(cvAttrs); }
- | "char" { t = new IntType("char" , SizeThunk.INT8, unsigned, cvAttrs); }
- | "short" { t = new IntType("short", SizeThunk.INT16, unsigned, cvAttrs); }
- | "int" { t = new IntType("int" , SizeThunk.INTxx, unsigned, cvAttrs); }
- | "long" { t = new IntType("long" , SizeThunk.LONG, unsigned, cvAttrs); }
- | "float" { t = new FloatType("float", SizeThunk.FLOAT, cvAttrs); }
- | "double" { t = new DoubleType("double", SizeThunk.DOUBLE, cvAttrs); }
- | "__int32" { t = new IntType("__int32", SizeThunk.INT32, unsigned, cvAttrs); }
- | "__int64" { t = new IntType("__int64", SizeThunk.INT64, unsigned, cvAttrs); }
- | "int8_t" { t = new IntType("int8_t", SizeThunk.INT8, false, cvAttrs); /* TS: always signed */ }
- | "uint8_t" { t = new IntType("uint8_t", SizeThunk.INT8, true, cvAttrs); /* TS: always unsigned */ }
- | "int16_t" { t = new IntType("int16_t", SizeThunk.INT16, false, cvAttrs); /* TS: always signed */ }
- | "uint16_t" { t = new IntType("uint16_t", SizeThunk.INT16, true, cvAttrs); /* TS: always unsigned */ }
- | "int32_t" { t = new IntType("int32_t", SizeThunk.INT32, false, cvAttrs); /* TS: always signed */ }
- | "wchar_t" { t = new IntType("wchar_t", SizeThunk.INT32, false, cvAttrs); /* TS: always signed */ }
- | "uint32_t" { t = new IntType("uint32_t", SizeThunk.INT32, true, cvAttrs, true); /* TS: always unsigned */ }
- | "int64_t" { t = new IntType("int64_t", SizeThunk.INT64, false, cvAttrs); /* TS: always signed */ }
- | "uint64_t" { t = new IntType("uint64_t", SizeThunk.INT64, true, cvAttrs, true); /* TS: always unsigned */ }
- | "ptrdiff_t" { t = new IntType("ptrdiff_t", SizeThunk.POINTER, false, cvAttrs); /* TS: always signed */ }
- | "intptr_t" { t = new IntType("intptr_t", SizeThunk.POINTER, false, cvAttrs); /* TS: always signed */ }
- | "size_t" { t = new IntType("size_t", SizeThunk.POINTER, true, cvAttrs, true); /* TS: always unsigned */ }
- | "uintptr_t" { t = new IntType("uintptr_t", SizeThunk.POINTER, true, cvAttrs, true); /* TS: always unsigned */ }
- | t = structSpecifier[cvAttrs] ( attributeDecl )*
- | t = unionSpecifier [cvAttrs] ( attributeDecl )*
- | t = enumSpecifier [cvAttrs]
- | t = typedefName [cvAttrs]
- | #("typeof" LPAREN
- ( (typeName )=> typeName
- | expr
- )
- RPAREN
- )
- | "__complex"
- ;
-
-typedefName[int cvAttrs] returns [Type t] { t = null; }
- : #(NTypedefName id : ID)
- {
- Type tdict = lookupInTypedefDictionary(id.getText());
- t = canonicalize(tdict.getCVVariant(cvAttrs));
- debugPrintln("Adding typedef canon : [" + id.getText() + "] -> [" + tdict + "] -> "+getTypeString(t));
- }
- ;
-
-structSpecifier[int cvAttrs] returns [Type t] { t = null; }
- : #( "struct" t = structOrUnionBody[CompoundTypeKind.STRUCT, cvAttrs] )
- ;
-
-unionSpecifier[int cvAttrs] returns [Type t] { t = null; }
- : #( "union" t = structOrUnionBody[CompoundTypeKind.UNION, cvAttrs] )
- ;
-
-structOrUnionBody[CompoundTypeKind kind, int cvAttrs] returns [CompoundType t] {
- t = null;
-}
- : ( (ID LCURLY) => id:ID LCURLY {
- t = (CompoundType) canonicalize(lookupInStructDictionary(id.getText(), kind, cvAttrs));
- } ( structDeclarationList[t] )?
- RCURLY { t.setBodyParsed(); }
- | LCURLY { t = CompoundType.create(null, null, kind, cvAttrs); }
- ( structDeclarationList[t] )?
- RCURLY { t.setBodyParsed(); }
- | id2:ID { t = (CompoundType) canonicalize(lookupInStructDictionary(id2.getText(), kind, cvAttrs)); }
- )
- ;
-
-structDeclarationList[CompoundType t]
- : ( structDeclaration[t] )+
- ;
-
-structDeclaration[CompoundType containingType] {
- Type t = null;
- boolean addedAny = false;
-}
- : t = specifierQualifierList addedAny = structDeclaratorList[containingType, t] {
- if (!addedAny) {
- if (t != null) {
- CompoundType ct = t.asCompound();
- if (ct.isUnion()) {
- // Anonymous union
- containingType.addField(new Field(null, t, null));
- }
- }
- }
- }
- ;
-
-specifierQualifierList returns [Type t] {
- t = null; int x = 0; int y = 0;
-}
- : (
- t = typeSpecifier[x]
- | y = typeQualifier { x |= y; }
- )+ {
- if (t == null &&
- (x & (SIGNED | UNSIGNED)) != 0) {
- t = new IntType("int", SizeThunk.INTxx, ((x & UNSIGNED) != 0), attrs2CVAttrs(x));
- }
-}
- ;
-
-structDeclaratorList[CompoundType containingType, Type t] returns [boolean addedAny] {
- addedAny = false;
- boolean y = false;
-}
- : ( y = structDeclarator[containingType, t] { addedAny = y; })+
- ;
-
-structDeclarator[CompoundType containingType, Type t] returns [boolean addedAny] {
- addedAny = false;
- String s = null;
- TypeBox tb = new TypeBox(t);
-}
- :
- #( NStructDeclarator
- ( s = declarator[tb] { containingType.addField(new Field(s, tb.type(), null)); addedAny = true; } )?
- ( COLON expr { /* FIXME: bit types not handled yet */ } ) ?
- ( attributeDecl )*
- )
- ;
-
-// FIXME: this will not correctly set the name of the enumeration when
-// encountering a declaration like this:
-//
-// typedef enum { } enumName;
-//
-// In this case calling getName() on the EnumType return value will
-// incorrectly return HeaderParser.ANONYMOUS_ENUM_NAME instead of
-// "enumName"
-//
-// I haven't implemented it yet because I'm not sure how to get the
-// "enumName" *before* executing the enumList rule.
-enumSpecifier [int cvAttrs] returns [Type t] {
- t = null;
-}
- : #( "enum"
- ( ( ID LCURLY )=> i:ID LCURLY enumList[(EnumType)(t = getEnumType(i.getText()))] RCURLY
- | LCURLY enumList[(EnumType)(t = getEnumType(ANONYMOUS_ENUM_NAME))] RCURLY
- | ID { t = getEnumType(i.getText()); }
- )
- )
- ;
-
-enumList[EnumType enumeration] {
- long defaultEnumerantValue = 0;
-}
- : ( defaultEnumerantValue = enumerator[enumeration, defaultEnumerantValue] )+
- ;
-
-enumerator[EnumType enumeration, long defaultValue] returns [long newDefaultValue] {
- newDefaultValue = defaultValue;
-}
- : eName:ID ( ASSIGN eVal:expr )? {
- long value = 0;
- if (eVal != null) {
- String vTxt = eVal.getAllChildrenText();
- if (enumHash.containsKey(vTxt)) {
- EnumType oldEnumType = enumHash.get(vTxt);
- value = oldEnumType.getEnumValue(vTxt);
- } else {
- try {
- value = Long.decode(vTxt).longValue();
- } catch (NumberFormatException e) {
- System.err.println("NumberFormatException: ID[" + eName.getText() + "], VALUE=[" + vTxt + "]");
- throw e;
- }
- }
- } else {
- value = defaultValue;
- }
-
- newDefaultValue = value+1;
- String eTxt = eName.getText();
- if (enumHash.containsKey(eTxt)) {
- EnumType oldEnumType = enumHash.get(eTxt);
- long oldValue = oldEnumType.getEnumValue(eTxt);
- System.err.println("WARNING: redefinition of enumerated value '" + eTxt + "';" +
- " existing definition is in enumeration '" + oldEnumType.getName() +
- "' with value " + oldValue + " and new definition is in enumeration '" +
- enumeration.getName() + "' with value " + value);
- // remove old definition
- oldEnumType.removeEnumerate(eTxt);
- }
- // insert new definition
- enumeration.addEnum(eTxt, value);
- enumHash.put(eTxt, enumeration);
- debugPrintln("ENUM [" + enumeration.getName() + "]: " + eTxt + " = " + enumeration.getEnumValue(eTxt) +
- " (new default = " + newDefaultValue + ")");
- }
- ;
-
-initDeclList[TypeBox tb]
- : ( initDecl[tb] )+
- ;
-
-initDecl[TypeBox tb] {
- String declName = null;
-}
- : #( NInitDecl
- declName = declarator[tb] {
- debugPrintln("GOT declName: " + declName + " TB=" + tb);
- }
- ( attributeDecl )*
- ( ASSIGN initializer
- | COLON expr
- )?
- )
-{
- if ((declName != null) && (tb != null) && tb.isTypedef()) {
- Type t = tb.type();
- debugPrint("Adding typedef mapping: [" + declName + "] -> "+getTypeString(t));
- if (!t.hasTypedefName()) {
- t.setName(declName);
- debugPrint(" - declName -> "+getTypeString(t));
- } else {
- // copy type to preserve declName !
- t = (Type) t.clone();
- t.setName(declName);
- debugPrint(" - copy -> "+getTypeString(t));
- }
- t = canonicalize(t);
- debugPrintln(" - canon -> "+getTypeString(t));
- typedefDictionary.put(declName, t);
- // Clear out PointerGroup effects in case another typedef variant follows
- tb.reset();
- }
-}
- ;
-
-pointerGroup[TypeBox tb] { int x = 0; int y = 0; }
- : #( NPointerGroup ( STAR { x = 0; y = 0; } ( y = typeQualifier { x |= y; } )*
- {
- debugPrintln("IN PTR GROUP: TB=" + tb);
- if (tb != null) {
- tb.setType(canonicalize(new PointerType(SizeThunk.POINTER,
- tb.type(),
- attrs2CVAttrs(x))));
- }
- }
- )+ )
- ;
-
-
-functionDeclSpecifiers
- :
- ( functionStorageClassSpecifier
- | typeQualifier
- | typeSpecifier[0]
- )+
- ;
-
-typeName {
- TypeBox tb = null;
-}
- : specifierQualifierList (nonemptyAbstractDeclarator[tb])?
- ;
-
-
-/* FIXME: the handling of types in this rule has not been well thought
- out and is known to be incomplete. Currently it is only used to handle
- pointerGroups for unnamed parameters. */
-nonemptyAbstractDeclarator[TypeBox tb]
- : #( NNonemptyAbstractDeclarator
- ( pointerGroup[tb]
- ( (LPAREN
- ( nonemptyAbstractDeclarator[tb]
- | parameterTypeList
- )?
- RPAREN)
- | (LBRACKET (e1:expr)? RBRACKET) { handleArrayExpr(tb, e1); }
- )*
-
- | ( (LPAREN
- ( nonemptyAbstractDeclarator[tb]
- | parameterTypeList
- )?
- RPAREN)
- | (LBRACKET (e2:expr)? RBRACKET) { handleArrayExpr(tb, e2); }
- )+
- )
- )
- ;
-
-/* Helper routine for parsing expressions which evaluate to integer
- constants. Can be made more complicated as necessary. */
-intConstExpr returns [int i] { i = -1; }
- : n:Number { return Integer.parseInt(n.getText()); }
- ;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-13 09:04:49 +0000