文法

字句解析

TRAIL            ([\t \n]|"#"[^\n]*"\n")*
LETTER           [a-zA-Z_]
LETTER_OR_DIGIT  ({LETTER}|[0-9])
WORD             {LETTER}{LETTER_OR_DIGIT}*

"+"{TRAIL}  add
"-"{TRAIL}  sub
"*"{TRAIL}  mul
"/"{TRAIL}  div
"%"{TRAIL}  rem
"=="{TRAIL} eq
"!="{TRAIL} ne
"<"{TRAIL}  lt
"<="{TRAIL} le
">"{TRAIL}  gt
">="{TRAIL} ge
"&&"{TRAIL} and
"||"{TRAIL} or
"&"{TRAIL}  concat
"<-"{TRAIL} assign
"="{TRAIL}  assign2
":="{TRAIL} assign3
"->"{TRAIL} lambda
"=>"{TRAIL} lambda2
"::"{TRAIL} module

if                  if
{TRAIL}else{TRAIL}  else
skip{TRAIL}         skip
case{TRAIL}         case
emit                emit
return              return
module              module
def                 def
method              method
import              import
new                 new
nil                 nil
and                 and
or                  or
xor                 xor
true                true
false               false

{WORD} identifier

{WORD}: label

{TRAIL}"|"{TRAIL}  pipe
{TRAIL}\.{TRAIL}   dot
[(\[{,;:]{TRAIL}   [text]
[)\]}@]            [text]
"\n"             ln
"#"[^\n]*"\n"    ln

(([1-9][0-9]*)|0) number

(([1-9][0-9]*)|0)(\.[0-9][0-9]*)? number

0x[0-9a-fA-F]+ number

0o[0-7]+ number



\"([^\\\"]|\\.)*\"      string

:{WORD} symbol

\"([^\\\"]|\\.)*\": label

[ \t] 

. [error]

構文解析

topstmts        : topstmt_list opt_terms
                | terms topstmt_list opt_terms
                | opt_terms
                ;

topstmt_list    : topstmt
                | topstmt_list terms topstmt
                ;
topstmt         : namespace identifier '{' topstmts '}'
                | import identifier
                | method identifier '(' opt_f_args ')' '{' stmts '}'
                | method identifier '(' opt_f_args ')' assign3 expr
                | stmt
                ;
stmts           : stmt_list opt_terms
                | terms stmt_list opt_terms
                | opt_terms
                ;
stmt_list       : stmt
                | stmt_list terms stmt
                ;
stmt            : identifier assign3 expr
                | def identifier '(' opt_f_args ')' '{' stmts '}'
                | def identifier '(' opt_f_args ')' assign3 expr
                | def identifier assign3 expr
                | skip
                | emit opt_args
                | return opt_args
                | expr
                ;
expr            : expr add expr
                | expr sub expr
                | expr mul expr
                | expr div expr
                | expr rem expr
                | expr pipe expr
                | expr concat expr
                | expr gt expr
                | expr ge expr
                | expr lt expr
                | expr le expr
                | expr eq expr
                | expr ne expr
                | add expr                 %prec '!'
                | sub expr                 %prec '!'
                | '!' expr
                | '~' expr
                | expr and expr
                | expr or expr
                | if '(' expr ')' expr opt_else
                | primary
                ;
opt_else        : /* none */           %prec else
                | else expr            %prec else
                ;
opt_args        : /* none */
                | args
                ;


arg             : expr
                | label expr
                | mul expr
                ;

args            : arg
                | args ',' arg
                ;
primary         : number
                | string
                | symbol
                | identifier
                | '(' expr ')'
                | '[' opt_args ']'
                | block
                | nil
                | true
                | false
                | new identifier '[' opt_args ']'
                | identifier '(' opt_args ')'
                | primary '.' identifier '(' opt_args ')'
                | primary '.' '(' opt_args ')'
                | concat identifier
                ;
opt_block       : /* none */
                | block
                ;

pterm           : identifier
                | number
                | string
                | nil
                | true
                | false
                | '[' ']'
                | '[' '@' identifier ']'
                | '[' pattern ']'
                | '[' '@' identifier pattern ']'
                | pterm '@' identifier
                ;
pary            : pterm
                | pary ',' pterm
                ;
pstruct         : label pterm
                | pstruct ',' label pterm
                ;

pattern         : pary
                | pary  ',' mul pterm
                | pary ',' mul pterm ',' pary
                | mul pterm
                | mul pterm ',' pary
                | pstruct
                | pstruct  ',' mul pterm
                ;
cparam          : lambda
                | if expr lambda
                | pattern lambda
                | pattern if expr lambda
                ;

case_body       : case cparam stmts
                | case_body case cparam stmts
                ;
block           : '{' stmts '}'
                | '{' bparam stmts '}'
                | '{' case_body '}'
                | '{' case_body else lambda stmts '}'
                ;

bparam          : lambda
                | f_args lambda
                ;

opt_f_args      : /* no args */
                | f_args
                ;

f_args          : identifier
                | f_args ',' identifier
                ;

opt_terms       : /* none */
                | terms
                ;

terms           : term
                | terms term {yyerrok;}
                ;

term            : ';' {yyerrok;}
                | '\n'
                ;