bril_grammar.lalrpop

#![allow(clippy::needless_lifetimes)]
#![allow(clippy::just_underscores_and_digits)]
#![allow(clippy::deprecated_cfg_attr)]
#![allow(clippy::no_effect_underscore_binding)]
#![allow(clippy::unnested_or_patterns)]
#![allow(clippy::trivially_copy_pass_by_ref)]
#![allow(clippy::missing_const_for_fn)]
#![allow(clippy::unnecessary_wraps)]
#![allow(clippy::redundant_pub_crate)]
#![allow(clippy::cloned_instead_of_copied)]
#![allow(clippy::too_many_lines)]
#![allow(clippy::use_self)]
#![allow(clippy::needless_pass_by_value)]
#![allow(clippy::cast_sign_loss)]
#![allow(clippy::must_use_candidate)]
#![allow(clippy::uninlined_format_args)]
#![allow(clippy::match_same_arms)]
#![allow(clippy::option_if_let_else)]
#![allow(clippy::extra_unused_lifetimes)]
#![allow(clippy::needless_raw_string_hashes)]

use std::str::FromStr;
use std::path::PathBuf;
use crate::{Lines, ParsingArgs, escape_control_chars};
use bril_rs::{AbstractProgram, AbstractFunction, AbstractArgument, AbstractCode, AbstractInstruction, ConstOps, AbstractType, Literal, Import, ImportedFunction};

grammar(lines : &Lines);

match {
    "const", "true", "false", "from", "import", "as" // keywords get special priority
} else {
    r"[[:space:]]*" => { }, /// Whitespace
    r"#[^\n\r]*[\n\r]*" => { }, /// Comments
    r"(\+|-)?[0-9]+" => INT_TOKEN, // int
    r"(\+|-)?(((([0-9]+\.?[0-9]*)|(\.[0-9]+))(E|e)(\+|-)?[0-9]+)|(([0-9]+\.[0-9]*)|(\.[0-9]+)))" => FLOAT_TOKEN, // https://stackoverflow.com/questions/12643009/regular-expression-for-floating-point-numbers
    r"(_|%|[[:alpha:]])(_|%|\.|[[:alnum:]])*" => IDENT_TOKEN,
    r"('.')|('\\[0abtnvfr]')" => CHAR_TOKEN,
    r#""[^"]*""# => STRING_TOKEN,
    _
}

pub AbstractProgram : AbstractProgram = {
    <i: (<Imports>)*> <f :(<AbstractFunction>)*> => AbstractProgram {
        imports: i,
        functions : f,
    }
}

Imports : Import = {
    "from" <p: Path> "import" <n:Comma<ImportedFunction>> ";" => {
        Import {
            path: p,
            functions: n,
        }
    }
}

ImportedFunction : ImportedFunction = {
    <n:Func> <a:Alias?> => {
        ImportedFunction {
            name: n,
            alias: a,
        }
    }
}

Alias : String = {
    "as" <a:Func> => {
        a
    }
}

AbstractFunction : AbstractFunction = {
    <loc:@L> <f: Func> <a: (Argument_List)?> <t:OutputType?> <loc2:@R> "{" <c :(<AbstractCode>)*> "}" => {let a = a.unwrap_or_default(); AbstractFunction {
        name : f,
        args : a,
        return_type : t,
        instrs: c,
        pos : lines.get_position(loc, loc2),
    }}
}

OutputType : AbstractType = {
    ":" <t:AbstractType> => t
}

Argument_List : Vec<AbstractArgument> = {
    "(" <a : Comma<AbstractArgument>> ")" => a,
}

AbstractArgument : AbstractArgument = {
   <i:Ident> ":" <t: AbstractType> => AbstractArgument {
        name : i,
        arg_type : t,
    }
}

AbstractCode : AbstractCode = {
    <loc:@L> <l: Label> ":" <loc2:@R> => AbstractCode::Label{ label : l, pos : lines.get_position(loc, loc2)},
    <i: AbstractInstruction> => AbstractCode::Instruction(i),
}

AbstractInstruction : AbstractInstruction = {
    <loc:@L> <i:Ident> <t:(":" <AbstractType>)?> "=" <c: ConstOps> <l: Literal> ";" <loc2:@R> => AbstractInstruction::Constant {
        op : c,
        dest : i,
        const_type : t,
        value : l,
        pos : lines.get_position(loc, loc2),
    },
    <loc:@L> <i:Ident> <t:(":" <AbstractType>)?> "=" <v:Ident> <f :(<Args>)*> ";" <loc2:@R> => {
        let mut a_vec = Vec::new();
        let mut f_vec = Vec::new();
        let mut l_vec = Vec::new();
        for x in f {
            match x {
                ParsingArgs::Ident(arg_name) => {a_vec.push(arg_name)}
                ParsingArgs::Func(arg_name) => {f_vec.push(arg_name)}
                ParsingArgs::Label(arg_name) => {l_vec.push(arg_name)}
            }
        }
        AbstractInstruction::Value {
            op: v,
            dest: i,
            op_type : t,
            args: a_vec,
            funcs: f_vec,
            labels: l_vec,
            pos : lines.get_position(loc, loc2),
        }
    },
    <loc:@L> <e:Ident> <f :(<Args>)*> ";" <loc2:@R> => {
        let mut a_vec = Vec::new();
        let mut f_vec = Vec::new();
        let mut l_vec = Vec::new();
        for x in f {
            match x {
                ParsingArgs::Ident(arg_name) => {a_vec.push(arg_name)}
                ParsingArgs::Func(arg_name) => {f_vec.push(arg_name)}
                ParsingArgs::Label(arg_name) => {l_vec.push(arg_name)}
            }
        }
        AbstractInstruction::Effect {
            op: e,
            args: a_vec,
            funcs: f_vec,
            labels: l_vec,
            pos : lines.get_position(loc, loc2),
        }
    }

}

ConstOps : ConstOps = {
    "const" => ConstOps::Const,
}

AbstractType : AbstractType = {
    <t:Ident> => AbstractType::Primitive(t),
    <p:Ident> "<" <t:AbstractType> ">" => AbstractType::Parameterized(p, Box::new(t)),
}

// We can't match on const because of a reduce-reduce conflict
Ident: String = {
    <s : IDENT_TOKEN> => s.to_string(),
    "true" => "true".to_owned(),
    "false" => "false".to_owned(),
}

Args: ParsingArgs = {
    <f:Func> => ParsingArgs::Func(f),
    <l:Label> => ParsingArgs::Label(l),
    <i:Ident> => ParsingArgs::Ident(i),
}

pub Func : String = {
    "@"<i:Ident> => i,
}

Path: PathBuf = {
    <p:STRING_TOKEN> => {
        PathBuf::from(p.trim_matches('\"'))
    }
}

Label: String = {
    "."<i:Ident> => i,
}

Literal: Literal = {
    <n: Num> => Literal::Int(n),
    <b: Bool> => Literal::Bool(b),
    <f: Float> => Literal::Float(f),
    <c: Char> => Literal::Char(c),
}

Num: i64 = <s:INT_TOKEN> => i64::from_str(s).unwrap();
Bool: bool = {
    "true" => true,
    "false" => false,
}

Float: f64 = <f:FLOAT_TOKEN> => f64::from_str(f).unwrap();

Char: char = <c:CHAR_TOKEN> => {let c = c.trim_matches('\''); escape_control_chars(c).unwrap()};

// https://lalrpop.github.io/lalrpop/tutorial/006_macros.html
Comma<T>: Vec<T> = { // (1)
    <mut v:(<T> ",")*> <e:T?> => match e { // (2)
        None => v,
        Some(e) => {
            v.push(e);
            v
        }
    }
}