BNF

PROGRAM : COMPSTMT

T : “;” | “\n” //a newline can terminate a statement

COMPSTMT : STMT {T EXPR} [T]

STMT : CALL do [“|” [BLOCK_VAR] “|”] COMPSTMT end

| undef FNAME

| alias FNAME FNAME

| STMT if EXPR

| STMT while EXPR

| STMT unless EXPR

| STMT until EXPR

| “BEGIN” “{” COMPSTMT “}” //object initializer

| “END” “{” COMPSTMT “}” //object finalizer

| LHS = COMMAND [do [“|” [BLOCK_VAR] “|”] COMPSTMT end]

| EXPR

EXPR : MLHS = MRHS

| return CALL_ARGS

| yield CALL_ARGS

| EXPR and EXPR

| EXPR or EXPR

| not EXPR

| COMMAND

| ! COMMAND

| ARG

CALL : FUNCTION

| COMMAND

COMMAND : OPERATION CALL_ARGS

| PRIMARY.OPERATION CALL_ARGS

| PRIMARY :: OPERATION CALL_ARGS

| super CALL_ARGS

FUNCTION : OPERATION [“(” [CALL_ARGS] “)”]

| PRIMARY.OPERATION “(” [CALL_ARGS] “)”

| PRIMARY :: OPERATION “(” [CALL_ARGS] “)”

| PRIMARY.OPERATION

| PRIMARY :: OPERATION

| super “(” [CALL_ARGS] “)”

| super

ARG : LHS = ARG

| LHS OP_ASGN ARG

| ARG .. ARG | ARG … ARG

| ARG + ARG | ARG – ARG | ARG * ARG | ARG / ARG

| ARG % ARG | ARG ** ARG

| + ARG | – ARG

| ARG “|” ARG

| ARG ˆ ARG | ARG & ARG

| ARG <=> ARG

| ARG > ARG | ARG >= ARG | ARG < ARG | ARG <= ARG

| ARG == ARG | ARG === ARG | ARG != ARG

| ARG =˜ ARG | ARG !˜ ARG

| ! ARG | ˜ ARG

| ARG << ARG | ARG >> ARG

| ARG && ARG | ARG || ARG

| defined? ARG

| PRIMARY

PRIMARY: “(” COMPSTMT “)”

| LITERAL

| VARIABLE

| PRIMARY :: IDENTIFIER

| :: IDENTIFIER

| PRIMARY “[” [ARGS] “]”

| “[” [ARGS [,]] “]”

| “{” [ARGS | ASSOCS [,]] “}”

| return [“(” [CALL_ARGS] “)”]

| yield [“(” [CALL_ARGS] “)”]

| defined? “(” ARG “)”

| FUNCTION

| FUNCTION “{” [“|” [BLOCK_VAR] “|”] COMPSTMT “}”

| if EXPR THEN

COMPSTMT

{elsif EXPR THEN

COMPSTMT}

[else

COMPSTMT]

end

| unless EXPR THEN

COMPSTMT

[else

COMPSTMT]

end

| while EXPR DO COMPSTMT end

| until EXPR DO COMPSTMT end

| case COMPSTMT

when WHEN_ARGS THEN COMPSTMT

{when WHEN_ARGS THEN COMPSTMT}

[else

COMPSTMT]

End

| for BLOCK_VAR in EXPR DO

COMPSTMT

end

| begin

COMPSTMT

{rescue [ARGS] DO

COMPSTMT}

[else

COMPSTMT]

[ensure

COMPSTMT]

end

| class IDENTIFIER [< IDENTIFIER]

COMPSTMT

end

| module IDENTIFIER

COMPSTMT

end

| def FNAME ARGDECL

COMPSTMT

end

| def SINGLETON (. | ::) FNAME ARGDECL

COMPSTMT

End

WHEN_ARGS : ARGS [, * ARG] | * ARG

THEN : T | then | T then //”then” and “do” can go on next line

DO : T | do | T do

BLOCK_VAR : LHS | MLHS

MLHS : MLHS_ITEM , [MLHS_ITEM (, MLHS_ITEM)*] [* [LHS]]

| * LHS

MLHS_ITEM : LHS | “(” MLHS “)”

LHS : VARIABLE

| PRIMARY “[” [ARGS] “]”

| PRIMARY.IDENTIFIER

MRHS : ARGS [, * ARG] | * ARG

CALL_ARGS : ARGS

| ARGS [, ASSOCS] [, * ARG] [, & ARG]

| ASSOCS [, * ARG] [, & ARG]

| * ARG [, & ARG] | & ARG

| COMMAND

ARGS : ARG (, ARG)*

ARGDECL : “(” ARGLIST “)”

| ARGLIST T

ARGLIST : IDENTIFIER(,IDENTIFIER)*[, *[IDENTIFIER]][,&IDENTIFIER]

| *IDENTIFIER[, &IDENTIFIER]

| [&IDENTIFIER]

SINGLETON : VARIABLE

| “(” EXPR “)”

ASSOCS : ASSOC {, ASSOC}

ASSOC : ARG => ARG

VARIABLE : VARNAME | nil | self

LITERAL : numeric | SYMBOL | STRING | STRING2 | HERE_DOC | REGEXP

The following are recognized by the lexical analyzer.

OP_ASGN : += | -= | *= | /= | %= | **=

| &= | |= | ˆ= | <<= | >>=

| &&= | ||=

SYMBOL : :FNAME | :VARNAME

FNAME : IDENTIFIER | .. | “|” | ˆ | & | <=> | == | === | =˜

| > | >= | < | <= | + | – | * | / | % | **

| << | >> | ˜ | +@ | -@ | [] | []=

OPERATION : IDENTIFIER [! | ?]

VARNAME : GLOBAL | @IDENTIFIER | IDENTIFIER

GLOBAL : $IDENTIFIER | $any_char | $-any_char

STRING : ” {any_char} “

| ’ {any_char} ’

| ‘ {any_char} ‘

STRING2 : %(Q|q|x)char {any_char} char

HERE_DOC : <<(IDENTIFIER | STRING)

{any_char}

IDENTIFIER

REGEXP : / {any_char} / [i|o|p]

| %r char {any_char} char

IDENTIFIER : sequence in /[a-zA-Z_]{a-zA-Z0-9_}/.

---

COMENTÁRIOS:

STRING : ” {any_char} ”
| ´ {any_char} ´
| ` {any_char} `

Uma STRING é definida como 0,1 ou vários caracteres, delimitados por ”
” ou ´ ´ ou ` `.

VARIABLE : VARNAME
| nil
| self

Uma variável é definida por um nome, VARNAME (abstração que consistena definição de um nome válido para variáveis); ou nil(palavra reservada que representa o valor de uma variável não inicializada); ou self (é uma variável especial que recebe um método, quando este nãotem uma variável específica que o chame).

PROGRAM : COMPSTMT

COMPSTMT : STMT (TERM EXPR)* [TERM]

STMT : CALL do [`|’ [BLOCK_VAR] `|’] COMPSTMT end

| undef FNAME
| alias FNAME FNAME
| STMT if EXPR
| STMT while EXPR
| STMT unless EXPR
| STMT until EXPR
| `BEGIN’ `{‘ COMPSTMT `}’
| `END’ `{‘ COMPSTMT `}’
| LHS `=’ COMMAND [do [`|’ [BLOCK_VAR] `|’] COMPSTMT end]
| EXPR

Dessa parte, concluimos que todo programa é composto de um “complete statemente”, por sua vez um complete statemente é composto de um ou vários “statements” e os statements devem começar e terminar com variáveis de bloco, no caso de ruby palavras reservadas como ” def”, “begin”, “do” e outras para iniciar e “end” para terminar o bloco.