lang.loli.txt

# ===================================================
# Symbols
#

token s_assign = "=";
token s_semi = ";";
token s_colon = ":";
token s_arrow = "->";
token s_comma = ",";

token s_asterisk = "\*";
token s_slash = "/";
token s_modulus = "%";
token s_plus = "\+";
token s_minus = "-";
token s_amp = "&";
token s_bar = "\|";
token s_caret = "^";

token s_gt = ">";
token s_gteq = ">=";
token s_ls = "<";
token s_lseq = "<=";
token s_eq = "==";
token s_ne = "!=";

token s_ampamp = "&&";
token s_barbar = "\|\|";

token s_lp = "\(";
token s_rp = "\)";
token s_lb = "{";
token s_rb = "}";

# ===================================================
# Keywords
#

token k_func = "func";
token k_val = "val";
token k_var = "var";
token k_if = "if";
token k_else = "else";
token k_while = "while";
token k_break = "break";
token k_continue = "continue";
token k_return = "return";

token k_true = "true";
token k_false = "false";

token k_unit = "unit";
token k_int = "int";
token k_bool = "bool";

# ===================================================
# Component
#
token id = "[_a-zA-Z][_a-zA-Z0-9]*";
token l_int = "[0-9]+";

# ===================================================
# Ignore
#

ignore whitespace = "[ \t\r\n]+";

# ===================================================
# Literal
#

base Literal;

enum BoolValue
{ True; False; }

node BoolLiteral : Literal
{ BoolValue content; }

node IntLiteral : Literal
{ token content; }

rule BoolValue : BoolValue
    = k_true -> True
    = k_false -> False
    ;

rule BoolLiteral : BoolLiteral
    = BoolValue:content -> _
    ;

rule IntLiteral : IntLiteral
    = l_int:content -> _
    ;

# ===================================================
# Type
#

base Type;

node NamedType : Type
{
    token name;
}

rule KeywordNamedType : NamedType
    = k_unit:name -> _
    = k_bool:name -> _
    = k_int:name -> _
    ;
rule UserNamedType : NamedType
    = id:name -> _
    ;

rule Type : Type
    = KeywordNamedType!
    = UserNamedType!
    ;

# ===================================================
# Expression
#

# Operator enums
enum BinaryOp
{
    # multiplicative
    Asterisk; Slash; Modulus;

    # additive
    Plus; Minus;
    
    # bitwise op
    And; Or; Xor;

    # comparative
    Gt; GtEq; Ls; LsEq; Eq; NotEq;

    # logic composition
    LogicAnd; LogicOr;
}

rule MultiplicativeOp : BinaryOp
    = s_asterisk -> Asterisk
    = s_slash -> Slash
    = s_modulus -> Modulus
    ;
rule AdditiveOp : BinaryOp
    = s_plus -> Plus
    = s_minus -> Minus
    ;
rule BitwiseManipOp : BinaryOp
    = s_amp -> And
    = s_bar -> Or
    = s_caret -> Xor
    ;
rule ComparativeOp : BinaryOp
    = s_gt -> Gt
    = s_gteq -> GtEq
    = s_ls -> Ls
    = s_lseq -> LsEq
    = s_eq -> Eq
    = s_ne -> NotEq
    ;
rule LogicCompositionOp : BinaryOp
    = s_ampamp -> LogicAnd
    = s_barbar -> LogicOr
    ;

# Expression
base Expression;

node BinaryExpr : Expression
{
    BinaryOp op;
    Expression lhs;
    Expression rhs;
}
node NamedExpr : Expression
{
    token id;
}
node LiteralExpr : Expression
{
    Literal content;
}

rule Factor : Expression
    = IntLiteral:content -> LiteralExpr
    = BoolLiteral:content -> LiteralExpr
    = id:id -> NamedExpr
    = s_lp Expr! s_rp
    ;
rule MultiplicativeExpr : BinaryExpr
    = MultiplicativeExpr:lhs MultiplicativeOp:op Factor:rhs -> _
    = Factor!
    ;
rule AdditiveExpr : BinaryExpr
    = AdditiveExpr:lhs AdditiveOp:op MultiplicativeExpr:rhs -> _
    = MultiplicativeExpr!
    ;
rule BitwiseManipExpr : BinaryExpr
    = BitwiseManipExpr:lhs BitwiseManipOp:op AdditiveExpr:rhs -> _
    = AdditiveExpr!
    ;
rule ComparativeExpr : BinaryExpr
    = ComparativeExpr:lhs ComparativeOp:op BitwiseManipExpr:rhs -> _
    = BitwiseManipExpr!
    ;
rule LogicCompositionExpr : BinaryExpr
    = LogicCompositionExpr:lhs LogicCompositionOp:op ComparativeExpr:rhs -> _
    = ComparativeExpr!
    ;

rule Expr : Expression
    = LogicCompositionExpr!
    ;

# ===================================================
# Statement
#

# Helper enums
enum JumpCommand
{
    Break; Continue;
}
rule JumpCommand : JumpCommand
    = k_break -> Break
    = k_continue -> Continue
    ;

enum VariableMutability
{
    Val; Var;
}
rule VariableMutability : VariableMutability
    = k_val -> Val
    = k_var -> Var
    ;

# Decl
base Statement;

node VariableDeclStmt : Statement
{
    VariableMutability mut;
    token name;
    Type type;
    Expression value;
}
rule VariableDeclStmt : VariableDeclStmt
    = VariableMutability:mut id:name s_colon Type:type s_assign Expr:value s_semi -> _
    ;

node JumpStmt : Statement
{
    JumpCommand command;
}
rule JumpStmt : JumpStmt
    = JumpCommand:command s_semi -> _
    ;

node ReturnStmt : Statement
{
    Expression expr;
}
rule ReturnStmt : ReturnStmt
    = k_return Expr:expr s_semi -> _
    = k_return s_semi -> _
    ;

node CompoundStmt : Statement
{
    Statement'vec children;
}
rule StmtList : Statement'vec
    = Stmt& -> _
    = StmtList! Stmt&
    ;
rule StmtListInBrace : Statement'vec
    = s_lb s_rb -> _
    = s_lb StmtList! s_rb
    ;
rule CompoundStmt : CompoundStmt
    = StmtListInBrace:children -> _
    ;

# an AtomicStmt has absolutely no dangling else problem to solve
rule AtomicStmt : Statement
    = VariableDeclStmt!
    = JumpStmt!
    = ReturnStmt!
    = CompoundStmt!
    ;

node WhileStmt : Statement
{
    Expression pred;
    Statement body;
}
rule OpenWhileStmt : WhileStmt
    = k_while s_lp Expr:pred s_rp OpenStmt:body -> _
    ;
rule CloseWhileStmt : WhileStmt
    = k_while s_lp Expr:pred s_rp CloseStmt:body -> _
    ;

node ChoiceStmt : Statement
{
    Expression pred;
    Statement positive;
    Statement'opt negative;
}
rule OpenChoiceStmt : ChoiceStmt
    = k_if s_lp Expr:pred s_rp Stmt:positive -> ChoiceStmt
    = k_if s_lp Expr:pred s_rp CloseStmt:positive k_else OpenStmt:negative -> _
    ;
rule CloseChoiceStmt : ChoiceStmt
    = k_if s_lp Expr:pred s_rp CloseStmt:positive k_else CloseStmt:negative -> _
    ;

# OpenStmt is a statement contains at least one unpaired ChoiceStmt
rule OpenStmt : Statement
    = OpenWhileStmt!
    = OpenChoiceStmt!
    ;
# CloseStmt is a statement inside of which all ChoiceStmt are paired with an else
rule CloseStmt : Statement
    = AtomicStmt!
    = CloseWhileStmt!
    = CloseChoiceStmt!
    ;

rule Stmt : Statement
    = OpenStmt!
    = CloseStmt!
    ;
    
# ===================================================
# Top-level Declarations
#

node TypedName
{
    token name;
    Type type;
}
rule TypedName : TypedName
    = id:name s_colon Type:type -> _
    ;

node FuncDecl
{
    token name;

    TypedName'vec params;
    Type ret;

    Statement'vec body;
}
rule TypedNameList : TypedName'vec
    = TypedName& -> _
    = TypedNameList! s_comma TypedName&
    ;
rule FuncParameters : TypedName'vec
    = s_lp s_rp -> _
    = s_lp TypedNameList! s_rp
    ;
rule FuncDecl : FuncDecl
    = k_func id:name FuncParameters:params s_arrow Type:ret StmtListInBrace:body -> _
    ;

# ===================================================
# Global Symbol
#
node TranslationUnit
{
    FuncDecl'vec functions;
}

rule FuncDeclList : FuncDecl'vec
    = FuncDecl& -> _
    = FuncDeclList! FuncDecl&
    ;
rule TranslationUnit : TranslationUnit
    = FuncDeclList:functions -> _
    ;