Sync

2026-05-21 18:31:08 +01:00
parent c3e82e45f0
commit 6e7201bd4e
2 changed files with 0 additions and 169 deletions
@@ -1,169 +0,0 @@
 use std::str::Chars;
 struct Type {
    name: String,
    params: Vec<Type>,
 }
 struct Decl {
    name: String,
    typed: Option<Type>,
    default: Option<Expr>,
 }
 struct Param {
    borrow: bool,
    decl: Decl,
 }
 struct Call {
    name: String,
    params: Vec<Param>,
 }
 struct StructEntry {
    name: Option<String>,
    value: Expr
 }
 struct FuncEntry {
    name: Option<String>,
    value: Expr,
    borrow: bool,
 }
 struct Class {
    name: String,
    entries: Vec<Decl>,
    methods: Vec<Function>,
 }
 struct Function {
    annotations: Vec<Annotation>,
    name: String,
    params: Vec<FuncEntry>,
    result: Type,
 }
 enum Overloaded {
    Plus,
    Get,
    Set,
    GetIndex,
    SetIndex,
 }
 enum Annotation {
    Inline,
    Native,
    Overload(Overloaded),
    Expr(String),
 }
 enum Statement {
    Class(Class),
    DeclLet(Decl),
    DeclVar(Decl),
    Assignment {
        name: String,
        expr: Expr,
    },
    Call(Call),
    Return(Expr),
    Block(Block),
    While(Expr,Box<Statement>),
    Loop(Box<Statement>),
    Function(Function),
    Break,
 }
 enum Expr {
    Paren(Box<Expr>),
    Call(Call),
    Add {
        left: Box<Expr>,
        right: Box<Expr>,
    },
    String(String),
    Number(String),
 }
 struct Block(Vec<Statement>);
 struct ParseError(String);
 enum Part {
    Set(&'static str),
    Raw(&'static str),
 }
 enum Selector {
    Cap(Pattern),
    One(Part),
    Any(Part),
 }
 struct Pattern(&'static [Selector]);
 impl Pattern {
    fn eval<'a>(&self, str: &'a str) -> Result<(&'a str, Vec<&'a str>), ()> {
        let mut captures = Vec::new();
        let mut current = str;
        let mut count = 0;
        self.0.iter().try_for_each(|selector: &Selector| {
            match selector {
                Selector::Cap(pattern) => {
                    pattern.eval(str).and_then(|(sum, _)| {
                        captures.push(sum);
                        Ok(())
                    })
                },
                Selector::Any(part) => {
                    let mut delta = 0;
                    match part {
                        Part::Set(set) => {
                            delta = current.chars().take_while(|char| set.contains(*char)).count();
                            current = &current[delta..];
                        },
                        Part::Raw(raw) => {
                            while current.starts_with(raw) {
                                delta += raw.len();
                                current = &current[delta..];
                            }
                        },
                    }
                    count += delta;
                    Ok(())
                }
                Selector::One(part) => {
                    match part {
                        Part::Set(set) => {
                            let res = current.chars().next().is_some_and(|char| set.contains(char));
                            if res {
                                current = &current[1..];
                                count += 1;
                            }
                            res
                        },
                        Part::Raw(raw) => {
                            let res = current.starts_with(raw);
                            if res {
                                current = &current[raw.len()..];
                                count += raw.len();
                            }
                            res
                        }
                    }.then_some(()).ok_or(())
                }
            }
        }).map(|_| (&str[..count],captures))
    }
 }
 const IDENTIFIER_START_SET: &str = "abcdefghijklmnopqrstuvwxyz_";
 const IDENTIFIER_REST_SET: &str = "abcdefghijklmnopqrstuvwxyz_1234567890";
 const WHITESPACE_SET: &str = "\n\r\t ";
 const PATTERN_IDENTIFIER: Pattern = Pattern(&[
    Selector::One(Part::Set(IDENTIFIER_START_SET)),
    Selector::Any(Part::Set(IDENTIFIER_REST_SET)),
 ]);
 const PATTERN_WHITESPACE: Pattern = Pattern(&[Selector::Any(Part::Set(WHITESPACE_SET))]);
 const PATTERN_COMMENT: Pattern = Pattern(&[Selector::Any(Part::Raw())]);
 const PATTERN_CALL_START: Pattern = Pattern(&[
    Selector::Cap(PATTERN_IDENTIFIER),
    Selector::One(Part::Set("("))
 ]);
 fn parse_call(str: &str) -> Result<Block,ParseError> {
    PATTERN_CALL_START.eval(str).and_then(|_| {
        Ok(())
    });
    Ok(Block(vec!()))
 }
 fn parse_block(str: &str) -> Result<Block,ParseError> {
    parse_call(str)
 }
 fn parse(source: &str) -> Result<Block,ParseError> {
    parse_block(source)
 }