; Lexical rules
; Lexer 逻辑比这个特殊一些，不能当作是真正的词法规则，只能用于参考

; 内用规则
; dummy rules
any_char -> ; any character
char -> ; any character, alias for any_char
identifier -> ; sequence in /[a-zA-Z_]{a-zA-Z0-9_}/

; 正则
regexp  -> /{any_char}/ ['i' | 'o' | 'p']
               | '%r' char {any_char} char

; Heredoc 注释
heredoc -> << (identifier | string) {any_char} identifier

; 字符串
string -> '"' {any_char} '"'
            | '’' {any_char} '’'
            | '‘' {any_char} '‘'
string2 -> '%' ('Q' | 'q' | 'x') char {any_char} char

; 全局变量名称
global -> '$' identifier | `$` any_char | '$-' any_char

; 有效变量名
varname -> global | '@' identifier | identifier

operation -> identifier ['!' | '?']

; 有效方法名
fname -> identifier | '..' | '|' | '^' | '&' | '<=>' | '==' | '===' | '=~' | '>'
             | '>=' | '<' | '<=' | '+' | '-' | '*' | '/' | '%' | '**' | '<<' | '>>' | '~' | '+@'
             | '-@' | '[]' | '[]='

; 符号，如 :[]= :a :var
symbol -> ':' fname | ':' varname

; 赋值运算符，>>= 和垃圾 Monad 类型系统没关系
; 皮一下，吐 Monad 类型系统无聊的属性
op-assign -> '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '&&=' | '||='

; 从小到大 233

; 字面量们如 2132、"Hello"、:Hello、%q[233]、<<AAAbbcAAA、/a-z/
literal -> NUMERIC | symbol | string | string2 | heredoc | regexp

; 变量值
variable -> varname | NIL | SELF

; 例子： { 'foo' => 'bar'  }
; { :a => :b, :b => :c}
; 在 Ruby 新版里，应该使用 { a: :b, b: :c }
assocation -> arg '=>' arg
assocations -> assocation {',' assocation}

singleton -> variable | '(' expr ')'

; 方法参数列表
; 由于特殊逻辑使用 EBNF 表述起来很麻烦，简要说一下
; 你可以在参数列表里使用 '*' identifier 表示 vararg name
; 也可以使用 '&' identifier 表示自动转换 block 为 Proc 对象，这个 identifier 就是 Proc 参数名
; '*' vararg name 和 '&' block arg 后不能出现一般方法参数
; Ruby 新版还支持 default value，对于这种情况，identifier '=' expr 的视为一般方法参数
arglist -> identifier {',' identifier}

; 类似 ES 的 newline 自动切分
; def foo arg0 arg1; puts arg0; puts arg1; end
t -> ';' | '\n'

; 参数列表定义
arg-decl -> '(' arglist ')' | arglist t

args -> arg {',' arg}

; 方法调用参数
call-args -> args
                 | args [',' assocations] [',' '*' arg] [',' '&' arg]
                 | assocations [',' '*' arg] [',' '&' arg]
                 | '*' arg [',' '&' arg] | '&' arg
                 | command

; 这一部分我也蒙蔽（逃
block-var -> lhs | mlhs
mlhs -> [mlhs-item {',' mlhs_item}] ['*' [lhs]] | '*' lhs
mlhs-item -> lhs | '(' mlhs ')'
lhs -> variable | primary '[' [args] ']' | primary '.' identifier
mrhs -> args [',' '*' arg] | '*' arg

; 程序结构的 BNF
program -> compstmt
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 '}'
          | END '{' compstmt '}'
          | 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