---
name: "flx_grammar"
section: "1"
platform: "linux"
package: "felix"
version: "1.1.1-2+b1"
release: "Debian 4.0 (Etch)"
platforms: ["linux"]
url: "https://new.carta.tech/flx_grammar"
---

# flx\_grammar(1)

## NAME

Felix grammar summary.

## Grammar

**compilation\_unit:**\
\
   \| statement\_aster ENDMARKER\

**expression:**\
\
   \| expr ENDMARKER\

**statement\_aster:**\
\
   \| statement statement\_aster\
\
   \| /\* empty \*/\

**statement:**\
\
   \| binding\_definition\
\
   \| declarative\
\
   \| executable\
\
   \| inclusion\
\
   \| directive\
\
   \| publish\
\
   \| comment\
\
   \| null\_statement\

**comment:**\
\
   \| COMMENT\_KEYWORD STRING SEMI\

**binding\_definition:**\
\
   \| abstract\_type\
\
   \| const\_def\
\
   \| binding\_header\
\
   \| export\_statement\

**publish:**\
\
   \| PUBLISH STRING binding\_definition\
\
   \| PUBLISH STRING declarative\
\
   \| PRIVATE declarative\
\
   \| PRIVATE binding\_definition\

**declarative:**\
\
   \| function\_definition\
\
   \| object\_definition\
\
   \| procedure\_definition\
\
   \| module\_definition\
\
   \| union\_decl\
\
   \| struct\_decl\
\
   \| type\_alias\

**directive:**\
\
   \| open\_decl\
\
   \| use\_decl\
\
   \| regdef\
\
   \| glr\_production\
\
   \| macro\_definition\

**executable:**\
\
   \| var\_def\
\
   \| val\_def\
\
   \| call\
\
   \| svc\
\
   \| return\
\
   \| ifgoto\_stmt\
\
   \| whilst\_stmt\
\
   \| todo\
\
   \| assignment\
\
   \| inline\_cpp\
\
   \| goto\_statement\
\
   \| label\_statement\
\
   \| assert\_statement\

**null\_statement:**\
\
   \| SEMI\

**inclusion:**\
\
   \| INCLUDE STRING SEMI\

**regdef:**\
\
   \| REGEXP NAME EQUAL re1 SEMI\

**re0:**\
\
   \| re1 AS NAME\
\
   \| re1\

**re1:**\
\
   \| re1 VBAR re2\
\
   \| re2\

**re2:**\
\
   \| re2 re3\
\
   \| re3\

**re3:**\
\
   \| re4 STAR\
\
   \| re4 PLUS\
\
   \| re4 QUEST\
\
   \| re4\

**re4:**\
\
   \| STRING\
\
   \| UNDERSCORE\
\
   \| DOT\
\
   \| LPAR re0 RPAR\
\
   \| LSQB charset RSQB\
\
   \| LSQB CIRCUMFLEX charset RSQB\
\
   \| re\_name\

**re\_name:**\
\
   \| re\_name COLONCOLON NAME\
\
   \| NAME\

**charset0:**\
\
   \| INTEGER MINUS INTEGER\
\
   \| STRING MINUS STRING\
\
   \| STRING\
\
   \| INTEGER\

**charset:**\
\
   \| charset charset0\
\
   \| charset0\

**tvar:**\
\
   \| NAME\
\
   \| NAME COLON tpattern\

**tvar\_comma\_list:**\
\
   \| tvar COMMA tvar\_comma\_list\
\
   \| tvar\
\
   \| /\* empty \*/\

**tvarlist:**\
\
   \| LSQB tvar\_comma\_list RSQB\
\
   \| /\* empty \*/\

**type\_qual:**\
\
   \| INCOMPLETE\
\
   \| POD\
\
   \| GC\_POINTER\

**type\_quals:**\
\
   \| type\_qual type\_quals\
\
   \| /\* empty \*/\

**abstract\_type:**\
\
   \| type\_quals CTYPES basic\_name\_comma\_list requires\_clause SEMI\
\
   \| type\_quals TYPE NAME tvarlist EQUAL code\_spec requires\_clause SEMI\

**union\_decl:**\
\
   \| ENUM NAME LBRACE enum\_items RBRACE SEMI\
\
   \| UNION NAME tvarlist EQUAL type\_sum\_items SEMI\
\
   \| UNION NAME tvarlist EQUAL VBAR type\_sum\_items SEMI\

**enum\_items:**\
\
   \| enum\_items COMMA enum\_item\
\
   \| enum\_item\

**enum\_item:**\
\
   \| NAME\

**type\_sum\_items:**\
\
   \| type\_sum\_items VBAR type\_sum\_item\
\
   \| type\_sum\_item\

**type\_sum\_item:**\
\
   \| NAME OF expr\
\
   \| NAME\

**opt\_equal:**\
\
   \| EQUAL\
\
   \| /\* empty \*/\

**struct\_decl:**\
\
   \| STRUCT NAME tvarlist opt\_equal LBRACE struct\_component\_aster RBRACE\
\
   \| CSTRUCT NAME tvarlist opt\_equal LBRACE struct\_component\_aster RBRACE\
\
   \| CCLASS NAME tvarlist opt\_equal LBRACE class\_component\_aster RBRACE\

**struct\_component\_aster:**\
\
   \| struct\_component struct\_component\_aster\
\
   \| /\* empty \*/\

**struct\_component:**\
\
   \| NAME COLON expr SEMI\

**opt\_name:**\
\
   \| NAME\
\
   \| /\* empty \*/\

**class\_component\_aster:**\
\
   \| class\_component class\_component\_aster\
\
   \| /\* empty \*/\

**class\_component:**\
\
   \| VAR NAME COLON expr SEMI\
\
   \| VAL NAME COLON expr SEMI\
\
   \| FUNCTION NAME COLON expr opt\_cstring SEMI\
\
   \| PROCEDURE NAME COLON expr opt\_cstring SEMI\
\
   \| CTOR opt\_name COLON expr opt\_cstring SEMI\

**const\_def:**\
\
   \| CONST NAME tvarlist COLON expr EQUAL code\_spec requires\_clause SEMI\
\
   \| CONST NAME tvarlist COLON expr requires\_clause SEMI\

**code\_spec:**\
\
   \| STRING\
\
   \| CSTRING\

**requirement:**\
\
   \| qualified\_name\
\
   \| BODY code\_spec\
\
   \| HEADER code\_spec\
\
   \| PROPERTY STRING\

**requirements:**\
\
   \| requirement COMMA requirements\
\
   \| requirement\

**requires\_clause:**\
\
   \| REQUIRES requirements\
\
   \| /\* empty \*/\

**binding\_header:**\
\
   \| HEADER code\_spec requires\_clause SEMI\
\
   \| BODY code\_spec requires\_clause SEMI\
\
   \| HEADER EQUAL code\_spec requires\_clause SEMI\
\
   \| BODY EQUAL code\_spec requires\_clause SEMI\
\
   \| HEADER NAME tvarlist EQUAL code\_spec requires\_clause SEMI\
\
   \| BODY NAME tvarlist EQUAL code\_spec requires\_clause SEMI\
\
   \| REQUIRES requirements SEMI\
\
   \| NAME REQUIRES requirements SEMI\

**inline\_cpp:**\
\
   \| CODE code\_spec SEMI\
\
   \| NORETURN CODE code\_spec SEMI\

**type\_alias:**\
\
   \| TYPEDEF NAME tvarlist EQUAL expr SEMI\
\
   \| TYPEDEF FUNCTION NAME tvarlist fun\_args COLON expr EQRIGHTARROW expr SEMI\
\
   \| TYPEDEF FUNCTION NAME tvarlist COLON expr EQUAL type\_matchings SEMI\
\
   \| RENAME NAME tvarlist EQUAL qualified\_name SEMI\
\
   \| RENAME FUNCTION NAME tvarlist EQUAL qualified\_name SEMI\
\
   \| INHERIT qualified\_name SEMI\

**export\_statement:**\
\
   \| EXPORT FUNCTION suffixed\_name AS STRING SEMI\
\
   \| EXPORT PROCEDURE suffixed\_name AS STRING SEMI\
\
   \| EXPORT TYPE LPAR expr RPAR AS STRING SEMI\

**open\_decl:**\
\
   \| OPEN qualified\_name SEMI\

**use\_decl:**\
\
   \| USE qualified\_name SEMI\
\
   \| USE NAME EQUAL qualified\_name SEMI\

**mac\_arg:**\
\
   \| NAME COLON FUNCTION\
\
   \| NAME COLON PROCEDURE\
\
   \| NAME COLON NAME\
\
   \| NAME\

**mac\_args:**\
\
   \| mac\_arg COMMA mac\_args\
\
   \| mac\_arg\

**mac\_arg\_list:**\
\
   \| LPAR mac\_args RPAR\
\
   \| LPAR RPAR\

**macro\_definition:**\
\
   \| MACRO NAME IS expr SEMI\
\
   \| MACRO FOR NAME IN expr DO statement\_aster DONE SEMI\
 /\*\
\
   \| MACRO NAME COLON LIST IDENT EQUAL rev\_name\_list SEMI\
 \*/\
\
   \| MACRO NAME IS NEW SEMI\
\
   \| MACRO VAR NAME EQUAL expr SEMI\
\
   \| MACRO NAME EQUAL expr SEMI\
\
   \| MACRO VAL NAME EQUAL expr SEMI\
\
   \| MACRO VAL NAME IS tuple SEMI\
\
   \| MACRO FUNCTION NAME mac\_arg\_list EQUAL expr SEMI\
\
   \| MACRO PROCEDURE NAME mac\_arg\_list compound\
\
   \| MACRO FORGET macro\_names SEMI\
\
   \| MACRO GOTO NAME SEMI\
\
   \| MACRO NAME COLONGREATER\
\
   \| MACRO IF expr GOTO NAME SEMI\
\
   \| MACRO FOR VAL NAME IN tuple DO statement\_aster DONE SEMI\

**macro\_name\_list:**\
\
   \| macro\_name\_list NAME\
\
   \| NAME\

**macro\_names:**\
\
   \| macro\_name\_list\
\
   \| /\* empty \*/\
 /\*\

**rev\_name\_list:**\
\
   \| NAME COMMA rev\_name\_list\
\
   \| NAME\
 \*/\

**fun\_arg:**\
\
   \| LPAR parameter\_comma\_list WHEN expr RPAR\
\
   \| LPAR parameter\_comma\_list RPAR\
\
   \| NAME\

**fun\_args:**\
\
   \| fun\_arg fun\_args\
\
   \| fun\_arg\

**opt\_fun\_args:**\
\
   \| fun\_args\
\
   \| /\* empty \*/\

**opt\_type\_expr:**\
\
   \| COLON expr EXPECT expr\
\
   \| COLON expr\
\
   \| EXPECT expr\
\
   \| /\* empty \*/\

**opt\_cstring:**\
\
   \| EQUAL code\_spec\
\
   \| /\* empty \*/\

**adjective:**\
\
   \| INLINE\
\
   \| NOINLINE\

**adjectives:**\
\
   \| adjective adjectives\
\
   \| /\* empty \*/\

**opt\_prec:**\
\
   \| IS NAME\
\
   \| /\* empty \*/\

**opt\_traint\_eq:**\
\
   \| EXPECT expr EQUAL\
\
   \| /\* empty \*/\

**function\_definition:**\
\
   \| adjectives FUNCTION NAME tvarlist fun\_args opt\_type\_expr EQRIGHTARROW expr SEMI\
\
   \| adjectives FUNCTION NAME tvarlist fun\_args opt\_type\_expr EQUAL compound\
\
   \| adjectives FUNCTION NAME tvarlist COLON expr opt\_cstring opt\_prec requires\_clause SEMI\
\
   \| adjectives FUNCTION NAME tvarlist COLON expr EQUAL matchings SEMI\

**procedure\_definition:**\
\
   \| PROCEDURE NAME tvarlist opt\_fun\_args opt\_traint\_eq compound\
\
   \| adjective PROCEDURE NAME tvarlist fun\_args opt\_traint\_eq compound\
\
   \| PROCEDURE NAME tvarlist COLON expr opt\_cstring requires\_clause SEMI\

**object\_definition:**\
\
   \| OBJECT NAME tvarlist fun\_args compound\

**parameter\_comma\_list:**\
\
   \| parameter COMMA parameter\_comma\_list\
\
   \| parameter\
\
   \| /\* empty \*/\

**parameter:**\
\
   \| NAME COLON arrow\
\
   \| NAME\
\
   \| VAR NAME COLON arrow\
\
   \| VAR NAME\

**assert\_statement:**\
\
   \| ASSERT expr SEMI\

**goto\_statement:**\
\
   \| GOTO NAME SEMI\

**label\_statement:**\
\
   \| NAME COLONGREATER\

**svc:**\
\
   \| SVC NAME SEMI\

**module\_definition:**\
\
   \| MODULE NAME tvarlist compound\

**var\_def:**\
\
   \| VAR NAME tvarlist EQUAL expr SEMI\
\
   \| VAR NAME tvarlist COLON expr LEFTARROW expr SEMI\
\
   \| VAR AMPER NAME tvarlist COLON expr LEFTARROW expr SEMI\
\
   \| VAR NAME tvarlist COLON expr EQUAL expr SEMI\
\
   \| VAR NAME tvarlist COLON expr SEMI\

**val\_def:**\
\
   \| VAL NAME tvarlist EQUAL expr SEMI\
\
   \| VAL NAME tvarlist COLON expr EQUAL expr SEMI\
\
   \| VAL NAME tvarlist COLON expr SEMI\

**return:**\
\
   \| RETURN expr SEMI\
\
   \| RETURN SEMI\

**compound:**\
\
   \| LBRACE statement\_aster RBRACE\

**call:**\
\
   \| expr SEMI\
\
   \| CALL expr SEMI\
\
   \| JUMP expr SEMI\
\
   \| LOOP expr SEMI\

**assignop:**\
\
   \| EQUAL\
\
   \| COLONEQUAL\

**rmwop:**\
\
   \| PLUSEQUAL\
\
   \| MINUSEQUAL\
\
   \| STAREQUAL\
\
   \| SLASHEQUAL\
\
   \| PERCENTEQUAL\
\
   \| LEFTSHIFTEQUAL\
\
   \| RIGHTSHIFTEQUAL\
\
   \| CARETEQUAL\
\
   \| VBAREQUAL\
\
   \| AMPEREQUAL\
\
   \| TILDEEQUAL\

**swapop:**\
\
   \| LEFTRIGHTARROW\

**incrop:**\
\
   \| PLUSPLUS\
\
   \| MINUSMINUS\

**lelement:**\
\
   \| VAL NAME\
\
   \| VAR NAME\
\
   \| NAME\
\
   \| UNDERSCORE\
\
   \| LPAR lexprs RPAR\

**tlelement:**\
\
   \| lelement COLON factor\
\
   \| lelement\

**lexprs:**\
\
   \| tlelement COMMA lexprs\
\
   \| tlelement\

**lexpr:**\
\
   \| lexprs\

**assignment:**\
\
   \| expr LEFTARROW expr SEMI\
\
   \| expr swapop expr SEMI\
\
   \| DEF lexpr EQUAL expr SEMI\
\
   \| expr assignop expr SEMI\
\
   \| expr rmwop expr SEMI\
\
   \| expr incrop SEMI\
\
   \| incrop expr SEMI\

**todo:**\
\
   \| TODO STRING SEMI\
\
   \| TODO SEMI\

**elif\_clause:**\
\
   \| ELIF expr DO statement\_aster\
\
   \| ELIF expr RETURN SEMI\
\
   \| ELIF expr GOTO NAME SEMI\

**elif\_clauses:**\
\
   \| elif\_clauses elif\_clause\
\
   \| elif\_clause\

**else\_clause:**\
\
   \| elif\_clauses ELSE statement\_aster\
\
   \| ELSE statement\_aster\

**ifgoto\_stmt:**\
\
   \| IF expr GOTO NAME SEMI\
\
   \| IF expr RETURN SEMI\
\
   \| IF expr DO statement\_aster else\_clause DONE SEMI\
\
   \| IF expr DO statement\_aster DONE SEMI\

**whilst\_stmt:**\
\
   \| WHILST expr DO statement\_aster DONE SEMI\
\
   \| UNTIL expr DO statement\_aster DONE SEMI\

**regmatch\_expr:**\
\
   \| REGMATCH expr WITH regmatch\_alternatives ENDMATCH\
\
   \| REGLEX expr TO expr WITH regmatch\_alternatives ENDMATCH\

**regmatch\_alternatives:**\
\
   \| regmatch\_alternatives regmatch\_alternative\
\
   \| regmatch\_alternative\

**regmatch\_alternative:**\
\
   \| VBAR re1 EQRIGHTARROW expr\

**match\_expr:**\
\
   \| MATCH expr WITH matchings ENDMATCH\

**matchings:**\
\
   \| matching matchings\
\
   \| matching\

**matching:**\
\
   \| VBAR pattern EQRIGHTARROW expr\
\
   \| VBAR EQRIGHTARROW expr\

**pattern:**\
\
   \| as\_pattern WHEN expr\
\
   \| as\_pattern\

**as\_pattern:**\
\
   \| variant\_pattern AS NAME\
\
   \| variant\_pattern\

**variant\_pattern:**\
\
   \| tuple\_pattern\

**tuple\_pattern:**\
\
   \| coercive\_pattern\_list\

**coercive\_pattern\_list:**\
\
   \| coercive\_pattern COMMA coercive\_pattern\_list\
\
   \| coercive\_pattern\

**coercive\_pattern:**\
\
   \| atomic\_pattern COLON arrow\
\
   \| atomic\_pattern\

**atomic\_pattern:**\
 /\* constants \*/\
\
   \| STRING\
\
   \| integral\
\
   \| NAN\
 /\* ranges \*/\
\
   \| STRING DOTDOT STRING\
\
   \| integral DOTDOT integral\
\
   \| floating DOTDOT floating\
 /\* other \*/\
\
   \| ctor\_pattern\
 /\*\
\
   \| QUEST NAME\
 \*/\
\
   \| QUEST NAME\
\
   \| QUEST\
\
   \| UNDERSCORE\
\
   \| LPAR pattern RPAR\
\
   \| REGEXP STRING LPAR basic\_name\_comma\_list RPAR\

**ctor\_pattern:**\
\
   \| ctor\_name atomic\_pattern\
\
   \| ctor\_name\

**ctor\_name:**\
\
   \| simple\_name\_parts\
\
   \| CASE INTEGER\

**integral:**\
\
   \| INTEGER\
\
   \| MINUS INTEGER\

**floating:**\
\
   \| FLOAT\
\
   \| MINUS FLOAT\
\
   \| INF\
\
   \| MINUS INF\

**basic\_name:**\
\
   \| NAME\

**basic\_name\_comma\_list:**\
\
   \| basic\_name COMMA basic\_name\_comma\_list\
\
   \| basic\_name\
\
   \| /\* empty \*/\

**tpattern\_comma\_list:**\
\
   \| tpattern COMMA tpattern\_comma\_list\
\
   \| tpattern\
\
   \| /\* empty \*/\

**tuple\_tpattern:**\
\
   \| tpattern\_comma\_list\

**tpattern:**\
\
   \| tpattern AS NAME\
\
   \| tpat0\

**tpat0:**\
\
   \| tpat1 RIGHTARROW tpat0\
\
   \| tpat1\

**tpat1:**\
\
   \| sumpat\

**sumpat:**\
\
   \| tpat2 PLUS sumpat\
\
   \| tpat2\

**tpat2:**\
\
   \| mulpat\

**mulpat:**\
\
   \| tpat3 STAR mulpat\
\
   \| tpat3\

**tpat3:**\
\
   \| NAME tpatlist\
\
   \| LPAR tuple\_tpattern RPAR\
\
   \| QUEST NAME\
\
   \| QUEST\
\
   \| UNDERSCORE\
\
   \| INTEGER\

**tpatlist:**\
\
   \| LSQB tpattern\_comma\_list RSQB\
\
   \| /\* empty \*/\

**type\_match\_expr:**\
\
   \| TYPEMATCH expr WITH type\_matchings ENDMATCH\

**type\_matchings:**\
\
   \| type\_matching type\_matchings\
\
   \| type\_matching\

**type\_matching:**\
\
   \| VBAR tuple\_tpattern EQRIGHTARROW expr\

**glr\_term:**\
\
   \| qualified\_name\
 /\* \| LSQB glr\_alts RSQB   \*/\
\
   \| LBRACE glr\_alternatives RBRACE\
\
   \| LPAR glr\_alternatives RPAR\
\
   \| glr\_term QUEST\
\
   \| glr\_term STAR\
\
   \| glr\_term PLUS\

**glr\_alternatives:**\
\
   \| glr\_sequence VBAR glr\_alts\
\
   \| glr\_sequence\

**glr\_alts:**\
\
   \| glr\_sequence VBAR glr\_alts\
\
   \| glr\_sequence\

**glr\_sequence:**\
\
   \| glr\_term glr\_seqs\
\
   \| glr\_term\

**glr\_seqs:**\
\
   \| glr\_term glr\_seqs\
\
   \| glr\_term\

**glr\_entry:**\
\
   \| NAME COLON glr\_term\
\
   \| glr\_term\

**glr\_entries:**\
\
   \| glr\_entry glr\_entries\
\
   \| glr\_entry\

**glr\_matching:**\
\
   \| VBAR glr\_entries EQRIGHTARROW expr\
\
   \| VBAR EQRIGHTARROW expr\

**glr\_matchings:**\
\
   \| glr\_matching glr\_matchings\
\
   \| glr\_matching\

**glr\_production:**\
\
   \| NONTERM NAME COLON expr EQUAL glr\_matchings SEMI\

**glr\_parse:**\
\
   \| PARSE expr WITH glr\_matchings ENDMATCH\

**expr:**\
\
   \| LET pattern EQUAL expr IN expr\
\
   \| rvalue\

**rvalue:**\
\
   \| lambda\
 /\* cannot use fun\_args, since ambiguity on the third case (NAME) \*/\

**lambda\_fun\_arg:**\
\
   \| LPAR parameter\_comma\_list WHEN expr RPAR\
\
   \| LPAR parameter\_comma\_list RPAR\

**lambda\_fun\_args:**\
\
   \| lambda\_fun\_arg lambda\_fun\_args\
\
   \| lambda\_fun\_arg\

**lambda:**\
\
   \| dollar\_apply\
\
   \| adjectives FUNCTION lambda\_fun\_args opt\_type\_expr EQUAL compound\
\
   \| adjectives FUNCTION lambda\_fun\_args opt\_type\_expr EQRIGHTARROW expr\
\
   \| PROCEDURE lambda\_fun\_args compound\
\
   \| PROCEDURE compound\

**dollar\_apply:**\
\
   \| tuple DOLLAR dollar\_apply\
\
   \| tuple\

**tuple:**\
\
   \| or\_condition tuple\_suffix\
\
   \| or\_condition\

**tuple\_suffix:**\
\
   \| COMMA or\_condition tuple\_suffix\
\
   \| COMMA or\_condition\

**/\*orop:**\
\
   \| OR\

**or\_condition:**\
\
   \| or\_condition orop and\_condition\
\
   \| and\_condition\
 \*/\
 /\* oring formation is 'psuedo-associative' \*/\

**or\_condition:**\
\
   \| and\_condition OR or\_list\
\
   \| and\_condition\

**or\_list:**\
\
   \| and\_condition OR or\_list\
\
   \| and\_condition\
 /\* oring formation is 'psuedo-associative' \*/\

**and\_condition:**\
\
   \| not\_condition AND and\_list\
\
   \| not\_condition\

**and\_list:**\
\
   \| not\_condition AND and\_list\
\
   \| not\_condition\
 /\*\

**andop:**\
\
   \| AND\

**and\_condition:**\
\
   \| and\_condition andop not\_condition\
\
   \| not\_condition\
 \*/\

**notop:**\
\
   \| NOT\

**not\_condition:**\
\
   \| notop not\_condition\
\
   \| comparison\

**chain\_cmp\_op:**\
\
   \| ANDEQEQUAL\
\
   \| ANDNOTEQUAL\
\
   \| ANDLESS\
\
   \| ANDGREATER\
\
   \| ANDLESSEQUAL\
\
   \| ANDGREATEREQUAL\

**cmp\_item:**\
\
   \| chain\_cmp\_op sum\

**cmp\_item\_list:**\
\
   \| cmp\_item cmp\_item\_list\
\
   \| cmp\_item\

**cmp\_op:**\
\
   \| EQEQUAL\
\
   \| NOTEQUAL\
\
   \| LESS\
\
   \| GREATER\
\
   \| LESSEQUAL\
\
   \| GREATEREQUAL\
\
   \| ISIN\
 /\* hack \*/\

**comparison:**\
\
   \| sum cmp\_op sum cmp\_item\_list\
\
   \| sum cmp\_op sum\
\
   \| as\_expr\

**as\_expr:**\
\
   \| as\_expr AS NAME\
\
   \| setunion\

**setunion:**\
\
   \| user10 VBARVBAR setunion\_list\
\
   \| user10\

**setunion\_list:**\
\
   \| user10 VBARVBAR setunion\_list\
\
   \| user10\

**user10:**\
\
   \| user10 USER10 setintersection\
\
   \| setintersection\

**setintersection:**\
\
   \| arrow AMPERAMPER setintersection\_list\
\
   \| arrow\

**setintersection\_list:**\
\
   \| arrow AMPERAMPER setintersection\_list\
\
   \| arrow\

**arrow:**\
\
   \| case\_literal RIGHTARROW arrow\
\
   \| case\_literal\

**case\_literal:**\
\
   \| CASE INTEGER\
\
   \| CASE INTEGER OF sum\
\
   \| bor\

**bor:**\
\
   \| bor SLOSHVBAR bxor\
\
   \| bxor\

**bxor:**\
\
   \| bxor SLOSHCIRCUMFLEX band\
\
   \| band\

**band:**\
\
   \| band SLOSHAMPER shift\
\
   \| shift\

**shift:**\
\
   \| shift LEFTSHIFT sum\
\
   \| shift RIGHTSHIFT sum\
\
   \| sum\
 /\* sum formation is 'psuedo-associative' \*/\

**sum:**\
\
   \| subtraction PLUS sum\_list\
\
   \| subtraction\

**sum\_list:**\
\
   \| subtraction PLUS sum\_list\
\
   \| subtraction\

**subtraction:**\
\
   \| subtraction MINUS product\
\
   \| product\
 /\* product formation is 'psuedo-associative' \*/\

**product:**\
\
   \| term STAR product\_list\
\
   \| term\

**product\_list:**\
\
   \| term STAR product\_list\
\
   \| term\
 /\* division is left associative: note higher precedence\
 the product, so that\
 a \* b/c \* d -\> a \* (b/c) \* d\
 \*/\

**term:**\
\
   \| term SLASH power\
\
   \| term PERCENT power\
\
   \| prefixed\
 /\* note weird recursion here: we need to support\
 \-x \*\* -x = -(x\*\*(-x))\
 \*/\

**prefixed:**\
\
   \| LVAL power\
\
   \| PLUS power\
\
   \| MINUS power\
\
   \| TILDE power\
\
   \| power\
 /\* exponentiation is right associative \*/\

**power:**\
\
   \| superscript STARSTAR prefixed\
\
   \| superscript\

**superscript:**\
\
   \| superscript CIRCUMFLEX refr\
\
   \| refr\

**refr:**\
\
   \| AMPER refr\
\
   \| STAR refr\
\
   \| application\
 /\* applications is left associative \*/\

**application:**\
\
   \| application coercion\
 /\*\
\
   \| MAP coercion coercion\
 \*/\
\
   \| CASENO coercion\
\
   \| coercion\

**coercion:**\
\
   \| coercion COLON factor\
\
   \| suffixed\_name\
\
   \| factor\

**factor:**\
\
   \| dollar\_name\
\
   \| factor DOT LSQB expr RSQB\
\
   \| factor DOT LSQB expr TO expr RSQB\
\
   \| factor DOT LSQB expr TO RSQB\
\
   \| factor DOT LSQB TO expr RSQB\
\
   \| factor DOT NAME\
\
   \| factor DOT LPAR INTEGER RPAR\

**dollar\_name:**\
\
   \| NOEXPAND qualified\_name\
\
   \| THE qualified\_name\
\
   \| qualified\_name\
\
   \| atom\

**qualified\_name:**\
\
   \| qualified\_name COLONCOLON simple\_name\_parts\
\
   \| simple\_name\_parts\

**elif:**\
\
   \| ELIF expr THEN expr\

**elifs:**\
\
   \| elifs elif\
\
   \| elif\

**else\_part:**\
\
   \| elifs ELSE expr\
\
   \| ELSE expr\

**cond:**\
\
   \| IF expr THEN expr else\_part ENDIF\

**expr\_code\_prefix:**\
\
   \| CODE LSQB expr RSQB\

**atom:**\
\
   \| DOTDOTDOT\
\
   \| type\_match\_expr\
\
   \| expr\_code\_prefix NAME\
\
   \| expr\_code\_prefix STRING\
\
   \| LSQBAR expr RSQBAR\
\
   \| LBRACE expr RBRACE\
\
   \| glr\_parse\
\
   \| match\_expr\
\
   \| regmatch\_expr\
\
   \| compound\
\
   \| LPAR expr RPAR\
\
   \| LPAR RPAR\
\
   \| literal\
\
   \| cond\
\
   \| USERLB expr USERRB\

**literal:**\
\
   \| INTEGER\
\
   \| FLOAT\
\
   \| STRING\
\
   \| CSTRING\

**simple\_name\_parts:**\
\
   \| NAME LSQB expr RSQB\
\
   \| NAME\

**suffixed\_name:**\
\
   \| qualified\_name OF LPAR expr RPAR\
\

## VERSION

**1.1.1\_rc1**

## SEE ALSO

**[felix(1)](/felix/1.md)** for a language introduction and man page index\
 **[flx(1)](/flx/1.md)** for a list of the tools.\
 **[flxcc(1)](/flxcc/1.md)** for a description of the wrapper generator tool.\
 **[flx\_lit(1)](/flx_lit/1.md)** for a description of literals\
 **[flx\_op(1)](/flx_op/1.md)** for a list of operators\
 **[flx\_cop(1)](/flx_cop/1.md)** for a list of C operator precedence names\
 **[flx\_key(1)](/flx_key/1.md)** for a list of keywords\
 **[flx\_grammar(1)](/flx_grammar/1.md)** for a grammar summary\
 **[flx\_lib\_typ(1)](/flx_lib_typ/1.md)** for a list of library types\
 **[flx\_dir(1)](/flx_dir/1.md)** for a list of directives\
 **[flx\_exec(1)](/flx_exec/1.md)** for a list of executable statements\
 **[flx\_decl(1)](/flx_decl/1.md)** for a list of declarative statements\
 **[flx\_bind(1)](/flx_bind/1.md)** for a list of binding statements\

## WEB SITE

See **http://felix.sourceforge.net**\

## AUTHOR

John Maxwell Skaller, mailto:skaller@users.sourceforge.net
