mirror of
https://github.com/arduino/Arduino.git
synced 2024-12-10 21:24:12 +01:00
858 lines
20 KiB
Plaintext
Executable File
858 lines
20 KiB
Plaintext
Executable File
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
Copyright (c) Non, Inc. 1998 -- All Rights Reserved
|
|
|
|
PROJECT: C Compiler
|
|
MODULE: WTreeParser
|
|
FILE: WTreeParser.g
|
|
|
|
AUTHOR: Monty Zukowski (jamz@cdsnet.net) April 28, 1998
|
|
MODIFICATIONS: Hernando Barragan added support for the Wiring language
|
|
|
|
DESCRIPTION:
|
|
|
|
This tree grammar is for a Gnu C AST. No actions in it,
|
|
subclass to do something useful.
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
|
|
|
|
|
|
header {
|
|
package processing.app.preproc;
|
|
|
|
import java.io.*;
|
|
|
|
import antlr.CommonAST;
|
|
import antlr.DumpASTVisitor;
|
|
}
|
|
|
|
|
|
class WTreeParser extends TreeParser;
|
|
|
|
options
|
|
{
|
|
importVocab = W;
|
|
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"
|
|
| "byte"
|
|
| "boolean"
|
|
| "Servo"
|
|
| "Wire"
|
|
| 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
|
|
;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|