944 lines
32 KiB
Rust
944 lines
32 KiB
Rust
// Charter Parser - 语法分析器模块
|
||
// 将Token流转换为AST
|
||
|
||
pub mod ast;
|
||
|
||
use crate::lexer::Token;
|
||
use ast::*;
|
||
use nac_udm::prelude::*;
|
||
use nac_udm::primitives::SovereigntyType;
|
||
use thiserror::Error;
|
||
|
||
#[derive(Error, Debug)]
|
||
#[allow(dead_code)]
|
||
pub enum ParseError {
|
||
#[error("意外的Token: 期望 {expected}, 实际 {actual:?}")]
|
||
UnexpectedToken { expected: String, actual: String },
|
||
|
||
#[error("意外的文件结束")]
|
||
UnexpectedEOF,
|
||
|
||
#[error("无效的类型注解")]
|
||
InvalidTypeAnnotation,
|
||
|
||
#[error("无效的表达式")]
|
||
InvalidExpression,
|
||
|
||
#[error("缺少GNACS声明")]
|
||
MissingGNACSDeclaration,
|
||
|
||
#[error("无效的GNACS编码: {0}")]
|
||
InvalidGNACSCode(String),
|
||
}
|
||
|
||
pub struct Parser {
|
||
tokens: Vec<Token>,
|
||
current: usize,
|
||
}
|
||
|
||
impl Parser {
|
||
pub fn new(tokens: Vec<Token>) -> Self {
|
||
Self { tokens, current: 0 }
|
||
}
|
||
|
||
fn is_at_end(&self) -> bool {
|
||
self.current >= self.tokens.len()
|
||
}
|
||
|
||
fn peek(&self) -> Option<&Token> {
|
||
self.tokens.get(self.current)
|
||
}
|
||
|
||
fn advance(&mut self) -> Option<&Token> {
|
||
if !self.is_at_end() {
|
||
self.current += 1;
|
||
self.tokens.get(self.current - 1)
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
fn expect(&mut self, expected: Token) -> Result<(), ParseError> {
|
||
if let Some(token) = self.peek() {
|
||
if std::mem::discriminant(token) == std::mem::discriminant(&expected) {
|
||
self.advance();
|
||
Ok(())
|
||
} else {
|
||
Err(ParseError::UnexpectedToken {
|
||
expected: format!("{:?}", expected),
|
||
actual: format!("{:?}", token),
|
||
})
|
||
}
|
||
} else {
|
||
Err(ParseError::UnexpectedEOF)
|
||
}
|
||
}
|
||
|
||
pub fn parse_program(&mut self) -> Result<Program, ParseError> {
|
||
let mut items = Vec::new();
|
||
|
||
while !self.is_at_end() {
|
||
items.push(self.parse_top_level_item()?);
|
||
}
|
||
|
||
Ok(Program { items })
|
||
}
|
||
|
||
fn parse_top_level_item(&mut self) -> Result<TopLevelItem, ParseError> {
|
||
match self.peek() {
|
||
Some(Token::Module) => {
|
||
self.advance();
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::Semicolon)?;
|
||
Ok(TopLevelItem::Module(ModuleDeclaration { name }))
|
||
}
|
||
Some(Token::Import) => {
|
||
self.advance();
|
||
let path = self.parse_string_literal()?;
|
||
self.expect(Token::Semicolon)?;
|
||
Ok(TopLevelItem::Import(ImportStatement { path }))
|
||
}
|
||
Some(Token::Asset) => {
|
||
Ok(TopLevelItem::Asset(self.parse_asset_definition()?))
|
||
}
|
||
Some(Token::Contract) => {
|
||
Ok(TopLevelItem::Contract(self.parse_contract_definition()?))
|
||
}
|
||
Some(Token::Pub) | Some(Token::Public) | Some(Token::Fn) => {
|
||
Ok(TopLevelItem::Function(self.parse_function_declaration()?))
|
||
}
|
||
_ => Err(ParseError::UnexpectedToken {
|
||
expected: "module, import, asset, contract, or function".to_string(),
|
||
actual: format!("{:?}", self.peek()),
|
||
}),
|
||
}
|
||
}
|
||
|
||
fn parse_asset_definition(&mut self) -> Result<AssetDefinition, ParseError> {
|
||
self.expect(Token::Asset)?;
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::LeftBrace)?;
|
||
|
||
// 解析GNACS声明（必须）
|
||
self.expect(Token::Gnacs)?;
|
||
self.expect(Token::Colon)?;
|
||
let gnacs_hex = self.parse_hex_number()?;
|
||
// 使用NAC UDM的GNACSCode::from_hex创建
|
||
let gnacs_code = GNACSCode::from_hex(&gnacs_hex)
|
||
.map_err(|e| ParseError::InvalidGNACSCode(e))?;
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
// 解析主权声明（可选）
|
||
let sovereignty = if matches!(self.peek(), Some(Token::Sovereignty)) {
|
||
self.advance();
|
||
self.expect(Token::Colon)?;
|
||
let sov = self.parse_sovereignty_type()?;
|
||
self.expect(Token::Semicolon)?;
|
||
Some(sov)
|
||
} else {
|
||
None
|
||
};
|
||
|
||
// 解析字段
|
||
let mut fields = Vec::new();
|
||
while !matches!(self.peek(), Some(Token::RightBrace) | Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
|
||
fields.push(self.parse_field_declaration()?);
|
||
self.expect(Token::Semicolon)?;
|
||
}
|
||
|
||
// 解析方法
|
||
let mut methods = Vec::new();
|
||
while matches!(self.peek(), Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
|
||
methods.push(self.parse_method_declaration()?);
|
||
}
|
||
|
||
self.expect(Token::RightBrace)?;
|
||
|
||
Ok(AssetDefinition {
|
||
name,
|
||
gnacs_code,
|
||
sovereignty,
|
||
fields,
|
||
methods,
|
||
})
|
||
}
|
||
|
||
fn parse_contract_definition(&mut self) -> Result<ContractDefinition, ParseError> {
|
||
self.expect(Token::Contract)?;
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::LeftBrace)?;
|
||
|
||
// 解析字段
|
||
let mut fields = Vec::new();
|
||
while !matches!(self.peek(), Some(Token::RightBrace) | Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
|
||
fields.push(self.parse_field_declaration()?);
|
||
self.expect(Token::Semicolon)?;
|
||
}
|
||
|
||
// 解析方法
|
||
let mut methods = Vec::new();
|
||
while matches!(self.peek(), Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
|
||
methods.push(self.parse_method_declaration()?);
|
||
}
|
||
|
||
self.expect(Token::RightBrace)?;
|
||
|
||
Ok(ContractDefinition {
|
||
name,
|
||
fields,
|
||
methods,
|
||
})
|
||
}
|
||
|
||
fn parse_field_declaration(&mut self) -> Result<FieldDeclaration, ParseError> {
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::Colon)?;
|
||
let type_annotation = self.parse_type_annotation()?;
|
||
|
||
Ok(FieldDeclaration {
|
||
name,
|
||
type_annotation,
|
||
})
|
||
}
|
||
|
||
fn parse_function_declaration(&mut self) -> Result<FunctionDeclaration, ParseError> {
|
||
// 解析修饰符
|
||
let mut modifiers = Vec::new();
|
||
while let Some(modifier) = self.parse_method_modifier() {
|
||
modifiers.push(modifier);
|
||
}
|
||
|
||
self.expect(Token::Fn)?;
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::LeftParen)?;
|
||
|
||
// 解析参数
|
||
let mut parameters = Vec::new();
|
||
if !matches!(self.peek(), Some(Token::RightParen)) {
|
||
loop {
|
||
parameters.push(self.parse_parameter()?);
|
||
if matches!(self.peek(), Some(Token::Comma)) {
|
||
self.advance();
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
self.expect(Token::RightParen)?;
|
||
|
||
// 解析返回类型
|
||
let return_type = if matches!(self.peek(), Some(Token::Arrow)) {
|
||
self.advance();
|
||
Some(self.parse_type_annotation()?)
|
||
} else {
|
||
None
|
||
};
|
||
|
||
// 解析函数体
|
||
let body = self.parse_block()?;
|
||
|
||
Ok(FunctionDeclaration {
|
||
modifiers,
|
||
name,
|
||
parameters,
|
||
return_type,
|
||
body,
|
||
})
|
||
}
|
||
|
||
fn parse_method_declaration(&mut self) -> Result<MethodDeclaration, ParseError> {
|
||
// 解析修饰符
|
||
let mut modifiers = Vec::new();
|
||
while let Some(modifier) = self.parse_method_modifier() {
|
||
modifiers.push(modifier);
|
||
}
|
||
|
||
self.expect(Token::Fn)?;
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::LeftParen)?;
|
||
|
||
// 解析参数
|
||
let mut parameters = Vec::new();
|
||
if !matches!(self.peek(), Some(Token::RightParen)) {
|
||
loop {
|
||
parameters.push(self.parse_parameter()?);
|
||
if matches!(self.peek(), Some(Token::Comma)) {
|
||
self.advance();
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
self.expect(Token::RightParen)?;
|
||
|
||
// 解析返回类型
|
||
let return_type = if matches!(self.peek(), Some(Token::Arrow)) {
|
||
self.advance();
|
||
Some(self.parse_type_annotation()?)
|
||
} else {
|
||
None
|
||
};
|
||
|
||
// 解析requires子句
|
||
let requires = if matches!(self.peek(), Some(Token::Requires)) {
|
||
self.advance();
|
||
self.expect(Token::LeftBrace)?;
|
||
let mut exprs = Vec::new();
|
||
while !matches!(self.peek(), Some(Token::RightBrace)) {
|
||
exprs.push(self.parse_expression()?);
|
||
self.expect(Token::Semicolon)?;
|
||
}
|
||
self.expect(Token::RightBrace)?;
|
||
exprs
|
||
} else {
|
||
Vec::new()
|
||
};
|
||
|
||
// 解析ensures子句
|
||
let ensures = if matches!(self.peek(), Some(Token::Ensures)) {
|
||
self.advance();
|
||
self.expect(Token::LeftBrace)?;
|
||
let mut exprs = Vec::new();
|
||
while !matches!(self.peek(), Some(Token::RightBrace)) {
|
||
exprs.push(self.parse_expression()?);
|
||
self.expect(Token::Semicolon)?;
|
||
}
|
||
self.expect(Token::RightBrace)?;
|
||
exprs
|
||
} else {
|
||
Vec::new()
|
||
};
|
||
|
||
// 解析方法体
|
||
let body = self.parse_block()?;
|
||
|
||
Ok(MethodDeclaration {
|
||
modifiers,
|
||
name,
|
||
parameters,
|
||
return_type,
|
||
requires,
|
||
ensures,
|
||
body,
|
||
})
|
||
}
|
||
|
||
fn parse_method_modifier(&mut self) -> Option<MethodModifier> {
|
||
match self.peek() {
|
||
Some(Token::Pub) | Some(Token::Public) => {
|
||
self.advance();
|
||
Some(MethodModifier::Public)
|
||
}
|
||
Some(Token::Private) => {
|
||
self.advance();
|
||
Some(MethodModifier::Private)
|
||
}
|
||
Some(Token::Internal) => {
|
||
self.advance();
|
||
Some(MethodModifier::Internal)
|
||
}
|
||
Some(Token::Payable) => {
|
||
self.advance();
|
||
Some(MethodModifier::Payable)
|
||
}
|
||
Some(Token::View) => {
|
||
self.advance();
|
||
Some(MethodModifier::View)
|
||
}
|
||
Some(Token::Pure) => {
|
||
self.advance();
|
||
Some(MethodModifier::Pure)
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
fn parse_parameter(&mut self) -> Result<Parameter, ParseError> {
|
||
let name = self.parse_identifier()?;
|
||
self.expect(Token::Colon)?;
|
||
let type_annotation = self.parse_type_annotation()?;
|
||
|
||
Ok(Parameter {
|
||
name,
|
||
type_annotation,
|
||
})
|
||
}
|
||
|
||
fn parse_type_annotation(&mut self) -> Result<TypeAnnotation, ParseError> {
|
||
// 检查是否是引用类型
|
||
if matches!(self.peek(), Some(Token::Ampersand)) {
|
||
self.advance();
|
||
let inner_type = self.parse_type_annotation()?;
|
||
return Ok(TypeAnnotation::Reference(Box::new(inner_type)));
|
||
}
|
||
|
||
let base_type = match self.peek() {
|
||
Some(Token::Uint8) => { self.advance(); TypeAnnotation::Uint8 }
|
||
Some(Token::Uint16) => { self.advance(); TypeAnnotation::Uint16 }
|
||
Some(Token::Uint32) => { self.advance(); TypeAnnotation::Uint32 }
|
||
Some(Token::Uint64) => { self.advance(); TypeAnnotation::Uint64 }
|
||
Some(Token::Uint128) => { self.advance(); TypeAnnotation::Uint128 }
|
||
Some(Token::Uint256) => { self.advance(); TypeAnnotation::Uint256 }
|
||
Some(Token::Int8) => { self.advance(); TypeAnnotation::Int8 }
|
||
Some(Token::Int16) => { self.advance(); TypeAnnotation::Int16 }
|
||
Some(Token::Int32) => { self.advance(); TypeAnnotation::Int32 }
|
||
Some(Token::Int64) => { self.advance(); TypeAnnotation::Int64 }
|
||
Some(Token::Int128) => { self.advance(); TypeAnnotation::Int128 }
|
||
Some(Token::Int256) => { self.advance(); TypeAnnotation::Int256 }
|
||
Some(Token::Bool) => { self.advance(); TypeAnnotation::Bool }
|
||
Some(Token::String) => { self.advance(); TypeAnnotation::String }
|
||
Some(Token::Bytes) => { self.advance(); TypeAnnotation::Bytes }
|
||
Some(Token::Address) => { self.advance(); TypeAnnotation::Address }
|
||
Some(Token::Hash) => { self.advance(); TypeAnnotation::Hash }
|
||
Some(Token::Timestamp) => { self.advance(); TypeAnnotation::Timestamp }
|
||
Some(Token::DID) => { self.advance(); TypeAnnotation::DID }
|
||
Some(Token::GNACSCode) => { self.advance(); TypeAnnotation::GNACSCode }
|
||
Some(Token::ConstitutionalReceipt) => { self.advance(); TypeAnnotation::ConstitutionalReceipt }
|
||
Some(Token::AssetInstance) => { self.advance(); TypeAnnotation::AssetInstance }
|
||
Some(Token::ACC20) => { self.advance(); TypeAnnotation::ACC20 }
|
||
Some(Token::ACC721) => { self.advance(); TypeAnnotation::ACC721 }
|
||
Some(Token::ACC1155) => { self.advance(); TypeAnnotation::ACC1155 }
|
||
Some(Token::ACCRWA) => { self.advance(); TypeAnnotation::ACCRWA }
|
||
Some(Token::Identifier(name)) if name == "Vec" => {
|
||
self.advance();
|
||
self.expect(Token::Less)?;
|
||
let inner_type = self.parse_type_annotation()?;
|
||
self.expect(Token::Greater)?;
|
||
TypeAnnotation::Vec(Box::new(inner_type))
|
||
}
|
||
_ => return Err(ParseError::InvalidTypeAnnotation),
|
||
};
|
||
|
||
// 检查是否是数组类型
|
||
if matches!(self.peek(), Some(Token::LeftBracket)) {
|
||
self.advance();
|
||
let size = if let Some(Token::Integer(n)) = self.peek() {
|
||
let size = *n as usize;
|
||
self.advance();
|
||
Some(size)
|
||
} else {
|
||
None
|
||
};
|
||
self.expect(Token::RightBracket)?;
|
||
Ok(TypeAnnotation::Array(Box::new(base_type), size))
|
||
} else {
|
||
Ok(base_type)
|
||
}
|
||
}
|
||
|
||
fn parse_sovereignty_type(&mut self) -> Result<SovereigntyType, ParseError> {
|
||
match self.peek() {
|
||
Some(Token::A0) => { self.advance(); Ok(SovereigntyType::A0) }
|
||
Some(Token::C0) => { self.advance(); Ok(SovereigntyType::C0) }
|
||
Some(Token::C1) => { self.advance(); Ok(SovereigntyType::C1) }
|
||
Some(Token::C2) => { self.advance(); Ok(SovereigntyType::C2) }
|
||
Some(Token::D0) => { self.advance(); Ok(SovereigntyType::D0) }
|
||
Some(Token::D1) => { self.advance(); Ok(SovereigntyType::D1) }
|
||
Some(Token::D2) => { self.advance(); Ok(SovereigntyType::D2) }
|
||
_ => Err(ParseError::UnexpectedToken {
|
||
expected: "sovereignty type (A0, C0, C1, C2, D0, D1, D2)".to_string(),
|
||
actual: format!("{:?}", self.peek()),
|
||
}),
|
||
}
|
||
}
|
||
|
||
fn parse_block(&mut self) -> Result<Block, ParseError> {
|
||
self.expect(Token::LeftBrace)?;
|
||
let mut statements = Vec::new();
|
||
|
||
while !matches!(self.peek(), Some(Token::RightBrace)) {
|
||
statements.push(self.parse_statement()?);
|
||
}
|
||
|
||
self.expect(Token::RightBrace)?;
|
||
Ok(Block { statements })
|
||
}
|
||
|
||
fn parse_statement(&mut self) -> Result<Statement, ParseError> {
|
||
match self.peek() {
|
||
Some(Token::Let) => {
|
||
self.advance();
|
||
|
||
// 检查是否有mut关键字
|
||
let mutable = if matches!(self.peek(), Some(Token::Mut)) {
|
||
self.advance();
|
||
true
|
||
} else {
|
||
false
|
||
};
|
||
|
||
let name = self.parse_identifier()?;
|
||
|
||
let type_annotation = if matches!(self.peek(), Some(Token::Colon)) {
|
||
self.advance();
|
||
Some(self.parse_type_annotation()?)
|
||
} else {
|
||
None
|
||
};
|
||
|
||
self.expect(Token::Assign)?;
|
||
let value = self.parse_expression()?;
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
Ok(Statement::Let(LetStatement {
|
||
mutable,
|
||
name,
|
||
type_annotation,
|
||
value,
|
||
}))
|
||
}
|
||
Some(Token::If) => {
|
||
self.advance();
|
||
let condition = self.parse_expression()?;
|
||
let then_block = self.parse_block()?;
|
||
|
||
let else_block = if matches!(self.peek(), Some(Token::Else)) {
|
||
self.advance();
|
||
Some(self.parse_block()?)
|
||
} else {
|
||
None
|
||
};
|
||
|
||
Ok(Statement::If(IfStatement {
|
||
condition,
|
||
then_block,
|
||
else_block,
|
||
}))
|
||
}
|
||
Some(Token::For) => {
|
||
self.advance();
|
||
let variable = self.parse_identifier()?;
|
||
self.expect(Token::In)?;
|
||
let iterable = self.parse_expression()?;
|
||
let body = self.parse_block()?;
|
||
|
||
Ok(Statement::For(ForStatement {
|
||
variable,
|
||
iterable,
|
||
body,
|
||
}))
|
||
}
|
||
Some(Token::While) => {
|
||
self.advance();
|
||
let condition = self.parse_expression()?;
|
||
let body = self.parse_block()?;
|
||
|
||
Ok(Statement::While(WhileStatement {
|
||
condition,
|
||
body,
|
||
}))
|
||
}
|
||
Some(Token::Return) => {
|
||
self.advance();
|
||
let value = if matches!(self.peek(), Some(Token::Semicolon)) {
|
||
None
|
||
} else {
|
||
Some(self.parse_expression()?)
|
||
};
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
Ok(Statement::Return(ReturnStatement { value }))
|
||
}
|
||
Some(Token::Emit) => {
|
||
self.advance();
|
||
let event_name = self.parse_identifier()?;
|
||
self.expect(Token::LeftParen)?;
|
||
|
||
let mut arguments = Vec::new();
|
||
if !matches!(self.peek(), Some(Token::RightParen)) {
|
||
loop {
|
||
arguments.push(self.parse_expression()?);
|
||
if matches!(self.peek(), Some(Token::Comma)) {
|
||
self.advance();
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
self.expect(Token::RightParen)?;
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
Ok(Statement::Emit(EmitStatement {
|
||
event_name,
|
||
arguments,
|
||
}))
|
||
}
|
||
Some(Token::RequireCR) => {
|
||
self.advance();
|
||
self.expect(Token::LeftParen)?;
|
||
let expr = self.parse_expression()?;
|
||
self.expect(Token::RightParen)?;
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
Ok(Statement::RequireCR(expr))
|
||
}
|
||
Some(Token::VerifyCR) => {
|
||
self.advance();
|
||
self.expect(Token::LeftParen)?;
|
||
let expr = self.parse_expression()?;
|
||
self.expect(Token::RightParen)?;
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
Ok(Statement::VerifyCR(expr))
|
||
}
|
||
Some(Token::Identifier(_)) => {
|
||
// 可能是赋值或表达式语句
|
||
let start_pos = self.current;
|
||
let name = self.parse_identifier()?;
|
||
|
||
if matches!(self.peek(), Some(Token::Assign)) {
|
||
self.advance();
|
||
let value = self.parse_expression()?;
|
||
self.expect(Token::Semicolon)?;
|
||
|
||
Ok(Statement::Assign(AssignStatement {
|
||
target: name,
|
||
value,
|
||
}))
|
||
} else {
|
||
// 回退并解析为表达式语句
|
||
self.current = start_pos;
|
||
let expr = self.parse_expression()?;
|
||
self.expect(Token::Semicolon)?;
|
||
Ok(Statement::Expression(expr))
|
||
}
|
||
}
|
||
_ => {
|
||
let expr = self.parse_expression()?;
|
||
self.expect(Token::Semicolon)?;
|
||
Ok(Statement::Expression(expr))
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_expression(&mut self) -> Result<Expression, ParseError> {
|
||
self.parse_logical_or()
|
||
}
|
||
|
||
fn parse_logical_or(&mut self) -> Result<Expression, ParseError> {
|
||
let mut left = self.parse_logical_and()?;
|
||
|
||
while matches!(self.peek(), Some(Token::Or)) {
|
||
self.advance();
|
||
let right = self.parse_logical_and()?;
|
||
left = Expression::Binary(BinaryOp::Or, Box::new(left), Box::new(right));
|
||
}
|
||
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_logical_and(&mut self) -> Result<Expression, ParseError> {
|
||
let mut left = self.parse_equality()?;
|
||
|
||
while matches!(self.peek(), Some(Token::And)) {
|
||
self.advance();
|
||
let right = self.parse_equality()?;
|
||
left = Expression::Binary(BinaryOp::And, Box::new(left), Box::new(right));
|
||
}
|
||
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_equality(&mut self) -> Result<Expression, ParseError> {
|
||
let mut left = self.parse_relational()?;
|
||
|
||
while let Some(token) = self.peek() {
|
||
let op = match token {
|
||
Token::Equal => BinaryOp::Equal,
|
||
Token::NotEqual => BinaryOp::NotEqual,
|
||
_ => break,
|
||
};
|
||
self.advance();
|
||
let right = self.parse_relational()?;
|
||
left = Expression::Binary(op, Box::new(left), Box::new(right));
|
||
}
|
||
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_relational(&mut self) -> Result<Expression, ParseError> {
|
||
let mut left = self.parse_additive()?;
|
||
|
||
while let Some(token) = self.peek() {
|
||
let op = match token {
|
||
Token::Less => BinaryOp::Less,
|
||
Token::Greater => BinaryOp::Greater,
|
||
Token::LessEqual => BinaryOp::LessEqual,
|
||
Token::GreaterEqual => BinaryOp::GreaterEqual,
|
||
_ => break,
|
||
};
|
||
self.advance();
|
||
let right = self.parse_additive()?;
|
||
left = Expression::Binary(op, Box::new(left), Box::new(right));
|
||
}
|
||
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_additive(&mut self) -> Result<Expression, ParseError> {
|
||
let mut left = self.parse_multiplicative()?;
|
||
|
||
while let Some(token) = self.peek() {
|
||
let op = match token {
|
||
Token::Plus => BinaryOp::Add,
|
||
Token::Minus => BinaryOp::Sub,
|
||
_ => break,
|
||
};
|
||
self.advance();
|
||
let right = self.parse_multiplicative()?;
|
||
left = Expression::Binary(op, Box::new(left), Box::new(right));
|
||
}
|
||
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_multiplicative(&mut self) -> Result<Expression, ParseError> {
|
||
let mut left = self.parse_unary()?;
|
||
|
||
while let Some(token) = self.peek() {
|
||
let op = match token {
|
||
Token::Star => BinaryOp::Mul,
|
||
Token::Slash => BinaryOp::Div,
|
||
Token::Percent => BinaryOp::Mod,
|
||
_ => break,
|
||
};
|
||
self.advance();
|
||
let right = self.parse_unary()?;
|
||
left = Expression::Binary(op, Box::new(left), Box::new(right));
|
||
}
|
||
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_unary(&mut self) -> Result<Expression, ParseError> {
|
||
match self.peek() {
|
||
Some(Token::Not) => {
|
||
self.advance();
|
||
let expr = self.parse_unary()?;
|
||
Ok(Expression::Unary(UnaryOp::Not, Box::new(expr)))
|
||
}
|
||
Some(Token::Minus) => {
|
||
self.advance();
|
||
let expr = self.parse_unary()?;
|
||
Ok(Expression::Unary(UnaryOp::Neg, Box::new(expr)))
|
||
}
|
||
_ => self.parse_postfix(),
|
||
}
|
||
}
|
||
|
||
fn parse_postfix(&mut self) -> Result<Expression, ParseError> {
|
||
let mut expr = self.parse_primary()?;
|
||
|
||
loop {
|
||
match self.peek() {
|
||
Some(Token::Dot) => {
|
||
self.advance();
|
||
let member = self.parse_identifier()?;
|
||
expr = Expression::MemberAccess(Box::new(expr), member);
|
||
}
|
||
Some(Token::LeftBracket) => {
|
||
self.advance();
|
||
let index = self.parse_expression()?;
|
||
self.expect(Token::RightBracket)?;
|
||
expr = Expression::ArrayAccess(Box::new(expr), Box::new(index));
|
||
}
|
||
Some(Token::LeftParen) => {
|
||
// 函数调用
|
||
if let Expression::Identifier(name) = expr {
|
||
self.advance();
|
||
let mut arguments = Vec::new();
|
||
|
||
if !matches!(self.peek(), Some(Token::RightParen)) {
|
||
loop {
|
||
arguments.push(self.parse_expression()?);
|
||
if matches!(self.peek(), Some(Token::Comma)) {
|
||
self.advance();
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
self.expect(Token::RightParen)?;
|
||
expr = Expression::FunctionCall(name, arguments);
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
Some(Token::As) => {
|
||
self.advance();
|
||
let target_type = self.parse_type_annotation()?;
|
||
expr = Expression::Cast(Box::new(expr), target_type);
|
||
}
|
||
_ => break,
|
||
}
|
||
}
|
||
|
||
Ok(expr)
|
||
}
|
||
|
||
fn parse_primary(&mut self) -> Result<Expression, ParseError> {
|
||
match self.peek() {
|
||
Some(Token::Integer(n)) => {
|
||
let value = *n;
|
||
self.advance();
|
||
Ok(Expression::Integer(value))
|
||
}
|
||
Some(Token::HexNumber(s)) => {
|
||
// 检查是否是GNACS编码（48位十六进制）
|
||
let value = s.clone();
|
||
self.advance();
|
||
if value.len() == 26 { // 0x + 24位十六进制 = 48位bit
|
||
Ok(Expression::GNACSCode(value))
|
||
} else {
|
||
Ok(Expression::HexNumber(value))
|
||
}
|
||
}
|
||
Some(Token::StringLiteral(s)) => {
|
||
let value = s.clone();
|
||
self.advance();
|
||
Ok(Expression::String(value))
|
||
}
|
||
Some(Token::True) => {
|
||
self.advance();
|
||
Ok(Expression::Boolean(true))
|
||
}
|
||
Some(Token::False) => {
|
||
self.advance();
|
||
Ok(Expression::Boolean(false))
|
||
}
|
||
Some(Token::DIDLiteral(s)) => {
|
||
let value = s.clone();
|
||
self.advance();
|
||
Ok(Expression::DID(value))
|
||
}
|
||
Some(Token::If) => {
|
||
self.advance();
|
||
let condition = self.parse_expression()?;
|
||
self.expect(Token::LeftBrace)?;
|
||
let then_expr = self.parse_expression()?;
|
||
self.expect(Token::RightBrace)?;
|
||
self.expect(Token::Else)?;
|
||
self.expect(Token::LeftBrace)?;
|
||
let else_expr = self.parse_expression()?;
|
||
self.expect(Token::RightBrace)?;
|
||
Ok(Expression::If(Box::new(condition), Box::new(then_expr), Box::new(else_expr)))
|
||
}
|
||
Some(Token::Require) => {
|
||
self.advance();
|
||
Ok(Expression::Identifier("require".to_string()))
|
||
}
|
||
Some(Token::Identifier(s)) => {
|
||
let name = s.clone();
|
||
self.advance();
|
||
Ok(Expression::Identifier(name))
|
||
}
|
||
Some(Token::LeftParen) => {
|
||
self.advance();
|
||
let expr = self.parse_expression()?;
|
||
self.expect(Token::RightParen)?;
|
||
Ok(expr)
|
||
}
|
||
_ => {
|
||
// 提供更详细的错误信息
|
||
Err(ParseError::InvalidExpression)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_identifier(&mut self) -> Result<String, ParseError> {
|
||
if let Some(Token::Identifier(s)) = self.peek() {
|
||
let name = s.clone();
|
||
self.advance();
|
||
Ok(name)
|
||
} else {
|
||
Err(ParseError::UnexpectedToken {
|
||
expected: "identifier".to_string(),
|
||
actual: format!("{:?}", self.peek()),
|
||
})
|
||
}
|
||
}
|
||
|
||
fn parse_string_literal(&mut self) -> Result<String, ParseError> {
|
||
if let Some(Token::StringLiteral(s)) = self.peek() {
|
||
let value = s.clone();
|
||
self.advance();
|
||
Ok(value)
|
||
} else {
|
||
Err(ParseError::UnexpectedToken {
|
||
expected: "string literal".to_string(),
|
||
actual: format!("{:?}", self.peek()),
|
||
})
|
||
}
|
||
}
|
||
|
||
fn parse_hex_number(&mut self) -> Result<String, ParseError> {
|
||
if let Some(Token::HexNumber(s)) = self.peek() {
|
||
let value = s.clone();
|
||
self.advance();
|
||
Ok(value)
|
||
} else {
|
||
Err(ParseError::UnexpectedToken {
|
||
expected: "hex number".to_string(),
|
||
actual: format!("{:?}", self.peek()),
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 解析Token流为AST
|
||
pub fn parse(tokens: &[Token]) -> anyhow::Result<Program> {
|
||
let mut parser = Parser::new(tokens.to_vec());
|
||
Ok(parser.parse_program()?)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::lexer::tokenize;
|
||
|
||
#[test]
|
||
fn test_parse_empty() {
|
||
let tokens = vec![];
|
||
let program = parse(&tokens).unwrap();
|
||
assert_eq!(program.items.len(), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_module() {
|
||
let source = "module test;";
|
||
let tokens = tokenize(source).unwrap();
|
||
let program = parse(&tokens).unwrap();
|
||
|
||
assert_eq!(program.items.len(), 1);
|
||
assert!(matches!(program.items[0], TopLevelItem::Module(_)));
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_asset() {
|
||
let source = r#"
|
||
asset TestAsset {
|
||
gnacs: 0x940101120187;
|
||
sovereignty: C2;
|
||
owner: DID;
|
||
amount: uint256;
|
||
}
|
||
"#;
|
||
|
||
let tokens = tokenize(source).unwrap();
|
||
let program = parse(&tokens).unwrap();
|
||
|
||
assert_eq!(program.items.len(), 1);
|
||
if let TopLevelItem::Asset(asset) = &program.items[0] {
|
||
assert_eq!(asset.name, "TestAsset");
|
||
// 验证GNACS编码（使用to_hex方法）
|
||
assert_eq!(asset.gnacs_code.to_hex(), "940101120187");
|
||
assert!(matches!(asset.sovereignty, Some(SovereigntyType::C2)));
|
||
assert_eq!(asset.fields.len(), 2);
|
||
} else {
|
||
panic!("Expected asset definition");
|
||
}
|
||
}
|
||
}
|