dar_core/

parser.rs

// crates/dar-core/src/parser.rs
use crate::{ast::*, lexer::Lexer, token::Token};
pub struct Parser {
    lexer: Lexer,
    current: Token,
}
impl Parser {
    pub fn new(mut lexer: Lexer,) -> Result<Self, String,> {
        let current = lexer.next_token()?;
        Ok(Self { lexer, current, },)
    }
    fn advance(&mut self,) -> Result<(), String,> {
        self.current = self.lexer.next_token()?;
        Ok((),)
    }
    fn expect(&mut self, expected: Token,) -> Result<(), String,> {
        if self.current == expected {
            self.advance()
        } else {
            Err(format!("Expected {:?}, found {:?}", expected, self.current),)
        }
    }
    pub fn parse(&mut self,) -> Result<Vec<Stmt,>, String,> {
        let mut stmts = Vec::new();
        while self.current != Token::Eof {
            stmts.push(self.parse_stmt()?,);
        }
        Ok(stmts,)
    }
    fn parse_stmt(&mut self,) -> Result<Stmt, String,> {
        match &self.current {
            Token::KeywordText => self.parse_decl(),
            Token::KeywordPrint => self.parse_print(),
            Token::KeywordExternal => self.parse_external(),
            Token::KeywordMod => self.parse_mod(),
            Token::KeywordLua => self.parse_lua(),
            Token::Identifier(name,) => {
                let func = name.clone();
                self.advance()?;
                self.expect(Token::LParen,)?;
                let arg = self.parse_expr()?;
                self.expect(Token::RParen,)?;
                Ok(Stmt::Call { func, arg, },)
            },
            _ => Err(format!("Unexpected token: {:?}", self.current),),
        }
    }
    fn parse_decl(&mut self,) -> Result<Stmt, String,> {
        self.advance()?; // 'text'
        let name = match &self.current {
            Token::Identifier(id,) => id.clone(),
            _ => return Err("Expected identifier after 'text'".to_string(),),
        };
        self.advance()?;
        let init = if self.current == Token::Equal {
            self.advance()?;
            Some(self.parse_expr()?,)
        } else {
            None
        };
        Ok(Stmt::Decl { name, init, },)
    }
    fn parse_name(&mut self,) -> Result<String, String,> {
        match &self.current {
            Token::Identifier(name,) => {
                let n = name.clone();
                self.advance()?;
                Ok(n,)
            },
            Token::KeywordText => {
                self.advance()?;
                Ok("text".to_string(),)
            },
            Token::KeywordPrint => {
                self.advance()?;
                Ok("print".to_string(),)
            },
            Token::KeywordExternal => {
                self.advance()?;
                Ok("external".to_string(),)
            },
            Token::KeywordMod => {
                self.advance()?;
                Ok("mod".to_string(),)
            },
            Token::Upper => {
                self.advance()?;
                Ok("Upper".to_string(),)
            },
            Token::Empty => {
                self.advance()?;
                Ok("empty".to_string(),)
            },
            _ => Err(format!(
                "Expected identifier or keyword, found {:?}",
                self.current
            ),),
        }
    }
    fn parse_print(&mut self,) -> Result<Stmt, String,> {
        self.advance()?; // 'print'
        self.expect(Token::LParen,)?;
        let expr = self.parse_expr()?;
        self.expect(Token::RParen,)?;
        Ok(Stmt::Print { expr, },)
    }
    fn parse_lua(&mut self,) -> Result<Stmt, String,> {
        self.advance()?; // 'lua'
        let path = match &self.current {
            Token::StringLiteral(s,) => s.clone(),
            _ => {
                return Err(
                    "Expected string literal with Lua script path".to_string(),
                );
            },
        };
        self.advance()?;
        self.expect(Token::LBrace,)?;
        let mut mappings = Vec::new();
        while self.current != Token::RBrace && self.current != Token::Eof {
            let dar_name = match &self.current {
                Token::Identifier(id,) => id.clone(),
                _ => {
                    return Err("Expected DAR function name inside lua block"
                        .to_string(),);
                },
            };
            self.advance()?;
            self.expect(Token::Colon,)?;
            let lua_name = self.parse_name()?; // может быть идентификатор или ключевое слово
            mappings.push((dar_name, lua_name,),);
            if self.current == Token::Comma {
                self.advance()?;
                continue;
            } else if self.current == Token::RBrace {
                break;
            } else {
                return Err("Expected ',' or '}' in lua block".to_string(),);
            }
        }
        self.expect(Token::RBrace,)?;
        Ok(Stmt::Lua { path, mappings, },)
    }
    fn parse_external(&mut self,) -> Result<Stmt, String,> {
        self.advance()?; // 'external'
        let path = match &self.current {
            Token::StringLiteral(s,) => s.clone(),
            _ => {
                return Err(
                    "Expected string literal with library path".to_string(),
                );
            },
        };
        self.advance()?;
        self.expect(Token::LBrace,)?;
        let mut functions = Vec::new();
        while self.current != Token::RBrace && self.current != Token::Eof {
            let source_name = match &self.current {
                Token::Identifier(id,) => id.clone(),
                _ => {
                    return Err("Expected function name inside external block"
                        .to_string(),);
                },
            };
            self.advance()?;
            let alias = if self.current == Token::Colon {
                self.advance()?;
                Some(self.parse_name()?,)
            } else {
                None
            };
            functions.push(ExternalFunc { source_name, alias, },);
            if self.current == Token::Comma {
                self.advance()?;
                continue;
            } else if self.current == Token::RBrace {
                break;
            } else {
                return Err(
                    "Expected ',' or '}' in external block".to_string(),
                );
            }
        }
        self.expect(Token::RBrace,)?;
        Ok(Stmt::External { path, functions, },)
    }
    fn parse_mod(&mut self,) -> Result<Stmt, String,> {
        self.advance()?; // 'mod'
        let path = match &self.current {
            Token::StringLiteral(s,) => s.clone(),
            _ => {
                return Err(
                    "Expected string literal with module path".to_string(),
                );
            },
        };
        self.advance()?;
        Ok(Stmt::Mod { path, },)
    }
    fn parse_expr(&mut self,) -> Result<Expr, String,> {
        let primary = self.parse_primary()?;
        if self.current == Token::Dot {
            self.advance()?;
            match self.current {
                Token::Upper => {
                    self.advance()?;
                    self.expect(Token::LParen,)?;
                    self.expect(Token::RParen,)?;
                    Ok(Expr::MethodCall {
                        obj: Box::new(primary,),
                        method: Method::Upper,
                    },)
                },
                _ => Err("Only .Upper() method supported".to_string(),),
            }
        } else if self.current == Token::LParen {
            match primary {
                Expr::Variable(name,) => {
                    self.advance()?; // '('
                    let arg = Box::new(self.parse_expr()?,);
                    self.expect(Token::RParen,)?;
                    Ok(Expr::Call { func: name, arg, },)
                },
                _ => Err("Only direct function calls allowed".to_string(),),
            }
        } else {
            Ok(primary,)
        }
    }
    fn parse_primary(&mut self,) -> Result<Expr, String,> {
        match &self.current {
            Token::Identifier(id,) => {
                let id = id.clone();
                self.advance()?;
                Ok(Expr::Variable(id,),)
            },
            Token::StringLiteral(s,) => {
                let s = s.clone();
                self.advance()?;
                Ok(Expr::StringLiteral(s,),)
            },
            Token::Empty => {
                self.advance()?;
                Ok(Expr::EmptyLiteral,)
            },
            _ => Err(format!(
                "Unexpected token in expression: {:?}",
                self.current
            ),),
        }
    }
}