moritz
/
shulkerscript-lang
mirror of https://github.com/moritz-hoelting/shulkerscript-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

change conditional to use expression instead of individual condition

This commit is contained in:
Moritz Hölting 2025-03-11 19:43:26 +01:00
parent 79a6455d8f
commit 09dd19508d
8 changed files with 218 additions and 745 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
src/semantic/mod.rs
View File

@ -13,11 +13,8 @@ use crate::{
base::{self, source_file::SourceElement as _, Handler},
lexical::token::{MacroStringLiteral, MacroStringLiteralPart},
syntax::syntax_tree::{
condition::{
BinaryCondition, Condition, ParenthesizedCondition, PrimaryCondition, UnaryCondition,
},
declaration::{Declaration, Function, ImportItems},
expression::{Expression, FunctionCall, Primary},
expression::{Expression, FunctionCall, Parenthesized, Primary},
program::{Namespace, ProgramFile},
statement::{
execute_block::{
@ -360,7 +357,7 @@ impl Conditional {
}
}
impl ParenthesizedCondition {
impl Parenthesized {
/// Analyzes the semantics of the parenthesized condition.
pub fn analyze_semantics(
&self,
@ -368,26 +365,11 @@ impl ParenthesizedCondition {
macro_names: &HashSet<String>,
handler: &impl Handler<base::Error>,
) -> Result<(), error::Error> {
self.condition
self.expression()
.analyze_semantics(function_names, macro_names, handler)
}
}
impl Condition {
/// Analyzes the semantics of the condition.
pub fn analyze_semantics(
&self,
function_names: &HashSet<String>,
macro_names: &HashSet<String>,
handler: &impl Handler<base::Error>,
) -> Result<(), error::Error> {
match self {
Self::Primary(prim) => prim.analyze_semantics(function_names, macro_names, handler),
Self::Binary(bin) => bin.analyze_semantics(function_names, macro_names, handler),
}
}
}
impl Else {
/// Analyzes the semantics of the else block.
pub fn analyze_semantics(
@ -618,62 +600,3 @@ impl VariableDeclaration {
Ok(())
}
}
impl PrimaryCondition {
/// Analyzes the semantics of a primary condition.
pub fn analyze_semantics(
&self,
function_names: &HashSet<String>,
macro_names: &HashSet<String>,
handler: &impl Handler<base::Error>,
) -> Result<(), error::Error> {
match self {
Self::Parenthesized(paren) => {
paren.analyze_semantics(function_names, macro_names, handler)
}
Self::StringLiteral(_) => Ok(()),
Self::Unary(unary) => unary.analyze_semantics(function_names, macro_names, handler),
}
}
}
impl UnaryCondition {
/// Analyzes the semantics of an unary condition.
pub fn analyze_semantics(
&self,
function_names: &HashSet<String>,
macro_names: &HashSet<String>,
handler: &impl Handler<base::Error>,
) -> Result<(), error::Error> {
self.operand()
.analyze_semantics(function_names, macro_names, handler)
}
}
impl BinaryCondition {
/// Analyzes the semantics of a binary condition.
pub fn analyze_semantics(
&self,
function_names: &HashSet<String>,
macro_names: &HashSet<String>,
handler: &impl Handler<base::Error>,
) -> Result<(), error::Error> {
let a = self
.left_operand()
.analyze_semantics(function_names, macro_names, handler)
.inspect_err(|err| {
handler.receive(err.clone());
});
let b = self
.right_operand()
.analyze_semantics(function_names, macro_names, handler)
.inspect_err(|err| {
handler.receive(err.clone());
});
if a.is_err() {
a
} else {
b
}
}
}

451
src/syntax/syntax_tree/condition.rs
View File

@ -1,451 +0,0 @@
//! Syntax tree nodes for conditions.
#![allow(clippy::missing_errors_doc)]
use std::{cmp::Ordering, collections::VecDeque};
use enum_as_inner::EnumAsInner;
use getset::Getters;
use crate::{
base::{
self,
source_file::{SourceElement, Span},
Handler, VoidHandler,
},
lexical::{
token::{Punctuation, Token},
token_stream::Delimiter,
},
syntax::{
error::{Error, ParseResult, SyntaxKind, UnexpectedSyntax},
parser::{Parser, Reading},
},
};
use super::AnyStringLiteral;
/// Condition that is viewed as a single entity during precedence parsing.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// PrimaryCondition:
/// UnaryCondition
/// | ParenthesizedCondition
/// | AnyStringLiteral
/// ```
#[allow(missing_docs)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)]
pub enum PrimaryCondition {
Unary(UnaryCondition),
Parenthesized(ParenthesizedCondition),
StringLiteral(AnyStringLiteral),
}
impl SourceElement for PrimaryCondition {
fn span(&self) -> Span {
match self {
Self::Unary(unary) => unary.span(),
Self::Parenthesized(parenthesized) => parenthesized.span(),
Self::StringLiteral(literal) => literal.span(),
}
}
}
/// Condition that is composed of two conditions and a binary operator.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// BinaryCondition:
/// Condition ConditionalBinaryOperator Condition
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct BinaryCondition {
/// The left operand of the binary condition.
#[get = "pub"]
left_operand: Box<Condition>,
/// The operator of the binary condition.
#[get = "pub"]
operator: ConditionalBinaryOperator,
/// The right operand of the binary condition.
#[get = "pub"]
right_operand: Box<Condition>,
}
impl SourceElement for BinaryCondition {
fn span(&self) -> Span {
self.left_operand
.span()
.join(&self.right_operand.span())
.unwrap()
}
}
impl BinaryCondition {
/// Dissolves the binary condition into its components
#[must_use]
pub fn dissolve(self) -> (Condition, ConditionalBinaryOperator, Condition) {
(*self.left_operand, self.operator, *self.right_operand)
}
}
/// Operator that is used to combine two conditions.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// ConditionalBinaryOperator:
/// '&&'
/// | '||'
/// ;
/// ```
#[allow(missing_docs)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)]
pub enum ConditionalBinaryOperator {
LogicalAnd(Punctuation, Punctuation),
LogicalOr(Punctuation, Punctuation),
}
impl ConditionalBinaryOperator {
/// Gets the precedence of the operator (the higher the number, the first it will be evaluated)
///
/// The least operator has precedence 1.
#[must_use]
pub fn get_precedence(&self) -> u8 {
match self {
Self::LogicalOr(..) => 1,
Self::LogicalAnd(..) => 2,
}
}
}
impl SourceElement for ConditionalBinaryOperator {
fn span(&self) -> Span {
match self {
Self::LogicalAnd(a, b) | Self::LogicalOr(a, b) => a
.span
.join(&b.span)
.expect("Invalid tokens for ConditionalBinaryOperator"),
}
}
}
/// Condition that is enclosed in parentheses.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// ParenthesizedCondition:
/// '(' Condition ')';
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct ParenthesizedCondition {
/// The opening parenthesis.
#[get = "pub"]
pub open_paren: Punctuation,
/// The condition within the parenthesis.
#[get = "pub"]
pub condition: Box<Condition>,
/// The closing parenthesis.
#[get = "pub"]
pub close_paren: Punctuation,
}
impl ParenthesizedCondition {
/// Dissolves the parenthesized condition into its components
#[must_use]
pub fn dissolve(self) -> (Punctuation, Condition, Punctuation) {
(self.open_paren, *self.condition, self.close_paren)
}
}
impl SourceElement for ParenthesizedCondition {
fn span(&self) -> Span {
self.open_paren
.span()
.join(&self.close_paren.span())
.expect("The span of the parenthesis is invalid.")
}
}
/// Operator that is used to prefix a condition.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// ConditionalPrefixOperator: '!';
/// ```
#[allow(missing_docs)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)]
pub enum ConditionalPrefixOperator {
LogicalNot(Punctuation),
}
impl SourceElement for ConditionalPrefixOperator {
fn span(&self) -> Span {
match self {
Self::LogicalNot(token) => token.span.clone(),
}
}
}
/// Condition that is prefixed by an operator.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// UnaryCondition:
/// ConditionalPrefixOperator PrimaryCondition
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct UnaryCondition {
/// The operator of the prefix.
#[get = "pub"]
operator: ConditionalPrefixOperator,
/// The operand of the prefix.
#[get = "pub"]
operand: Box<PrimaryCondition>,
}
impl SourceElement for UnaryCondition {
fn span(&self) -> Span {
self.operator.span().join(&self.operand.span()).unwrap()
}
}
impl UnaryCondition {
/// Dissolves the conditional prefix into its components
#[must_use]
pub fn dissolve(self) -> (ConditionalPrefixOperator, PrimaryCondition) {
(self.operator, *self.operand)
}
}
/// Represents a condition in the syntax tree.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// Condition:
/// PrimaryCondition
/// | BinaryCondition
/// ;
/// ```
#[allow(missing_docs)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)]
pub enum Condition {
Primary(PrimaryCondition),
Binary(BinaryCondition),
}
impl SourceElement for Condition {
fn span(&self) -> Span {
match self {
Self::Primary(primary) => primary.span(),
Self::Binary(binary) => binary.span(),
}
}
}
impl<'a> Parser<'a> {
/// Parses a [`Condition`].
///
/// # Precedence of the operators
/// 1. `!`
/// 2. `&&`
/// 3. `||`
pub fn parse_condition(
&mut self,
handler: &impl Handler<base::Error>,
) -> ParseResult<Condition> {
let mut lhs = Condition::Primary(self.parse_primary_condition(handler)?);
let mut expressions = VecDeque::new();
// Parses a list of binary operators and expressions
while let Ok(binary_operator) = self.try_parse_conditional_binary_operator() {
expressions.push_back((
binary_operator,
Some(Condition::Primary(self.parse_primary_condition(handler)?)),
));
}
let mut candidate_index = 0;
let mut current_precedence;
while !expressions.is_empty() {
// reset precedence
current_precedence = 0;
for (index, (binary_op, _)) in expressions.iter().enumerate() {
let new_precedence = binary_op.get_precedence();
match new_precedence.cmp(&current_precedence) {
// Clear the candidate indices and set the current precedence to the
// precedence of the current binary operator.
Ordering::Greater => {
current_precedence = new_precedence;
candidate_index = index;
}
Ordering::Less | Ordering::Equal => (),
}
}
// ASSUMPTION: The assignments have 1 precedence and are right associative.
assert!(current_precedence > 0);
if candidate_index == 0 {
let (binary_op, rhs) = expressions.pop_front().expect("No binary operator found");
// fold the first expression
lhs = Condition::Binary(BinaryCondition {
left_operand: Box::new(lhs),
operator: binary_op,
right_operand: Box::new(rhs.unwrap()),
});
} else {
let (binary_op, rhs) = expressions
.remove(candidate_index)
.expect("No binary operator found");
// fold the expression at candidate_index
expressions[candidate_index - 1].1 = Some(Condition::Binary(BinaryCondition {
left_operand: Box::new(expressions[candidate_index - 1].1.take().unwrap()),
operator: binary_op,
right_operand: Box::new(rhs.unwrap()),
}));
}
}
Ok(lhs)
}
/// Parses a [`PrimaryCondition`].
pub fn parse_primary_condition(
&mut self,
handler: &impl Handler<base::Error>,
) -> ParseResult<PrimaryCondition> {
match self.stop_at_significant() {
// prefixed expression
Reading::Atomic(Token::Punctuation(punc)) if punc.punctuation == '!' => {
// eat prefix operator
self.forward();
let operator = match punc.punctuation {
'!' => ConditionalPrefixOperator::LogicalNot(punc),
_ => unreachable!(),
};
let operand = Box::new(self.parse_primary_condition(handler)?);
Ok(PrimaryCondition::Unary(UnaryCondition {
operator,
operand,
}))
}
// string literal
Reading::Atomic(Token::StringLiteral(literal)) => {
self.forward();
Ok(PrimaryCondition::StringLiteral(literal.into()))
}
// macro string literal
Reading::Atomic(Token::MacroStringLiteral(literal)) => {
self.forward();
Ok(PrimaryCondition::StringLiteral(literal.into()))
}
// parenthesized condition
Reading::IntoDelimited(punc) if punc.punctuation == '(' => self
.parse_parenthesized_condition(handler)
.map(PrimaryCondition::Parenthesized),
unexpected => {
// make progress
self.forward();
let err = Error::UnexpectedSyntax(UnexpectedSyntax {
expected: SyntaxKind::Either(&[
SyntaxKind::Punctuation('!'),
SyntaxKind::StringLiteral,
SyntaxKind::Punctuation('('),
]),
found: unexpected.into_token(),
});
handler.receive(err.clone());
Err(err)
}
}
}
/// Parses a [`ParenthesizedCondition`].
pub fn parse_parenthesized_condition(
&mut self,
handler: &impl Handler<base::Error>,
) -> ParseResult<ParenthesizedCondition> {
let token_tree = self.step_into(
Delimiter::Parenthesis,
|parser| {
let cond = parser.parse_condition(handler)?;
parser.stop_at_significant();
Ok(cond)
},
handler,
)?;
Ok(ParenthesizedCondition {
open_paren: token_tree.open,
condition: Box::new(token_tree.tree?),
close_paren: token_tree.close,
})
}
fn try_parse_conditional_binary_operator(&mut self) -> ParseResult<ConditionalBinaryOperator> {
self.try_parse(|parser| match parser.next_significant_token() {
Reading::Atomic(token) => match token.clone() {
Token::Punctuation(punc) => match punc.punctuation {
'&' => {
let b = parser.parse_punctuation('&', false, &VoidHandler)?;
Ok(ConditionalBinaryOperator::LogicalAnd(punc, b))
}
'|' => {
let b = parser.parse_punctuation('|', false, &VoidHandler)?;
Ok(ConditionalBinaryOperator::LogicalOr(punc, b))
}
_ => Err(Error::UnexpectedSyntax(UnexpectedSyntax {
expected: SyntaxKind::Either(&[
SyntaxKind::Punctuation('&'),
SyntaxKind::Punctuation('|'),
]),
found: Some(token),
})),
},
unexpected => Err(Error::UnexpectedSyntax(UnexpectedSyntax {
expected: SyntaxKind::Either(&[
SyntaxKind::Punctuation('&'),
SyntaxKind::Punctuation('|'),
]),
found: Some(unexpected),
})),
},
unexpected => Err(Error::UnexpectedSyntax(UnexpectedSyntax {
expected: SyntaxKind::Either(&[
SyntaxKind::Punctuation('&'),
SyntaxKind::Punctuation('|'),
]),
found: unexpected.into_token(),
})),
})
}
}

2
src/syntax/syntax_tree/expression.rs
View File

@ -620,7 +620,7 @@ impl<'a> Parser<'a> {
}
}
fn parse_parenthesized(
pub(super) fn parse_parenthesized(
&mut self,
handler: &impl Handler<base::Error>,
) -> ParseResult<Parenthesized> {

1
src/syntax/syntax_tree/mod.rs
View File

@ -23,7 +23,6 @@ use super::{
parser::Parser,
};
pub mod condition;
pub mod declaration;
pub mod expression;
pub mod program;

10
src/syntax/syntax_tree/statement/execute_block.rs
View File

@ -19,7 +19,7 @@ use crate::{
syntax::{
error::{Error, ParseResult, SyntaxKind, UnexpectedSyntax},
parser::{DelimitedTree, Parser, Reading},
syntax_tree::{condition::ParenthesizedCondition, AnyStringLiteral},
syntax_tree::{expression::Parenthesized, AnyStringLiteral},
},
};
@ -148,7 +148,7 @@ impl SourceElement for ExecuteBlockTail {
///
/// ``` ebnf
/// Conditional:
/// 'if' ParenthizedCondition
/// 'if' Parenthized
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@ -159,13 +159,13 @@ pub struct Conditional {
if_keyword: Keyword,
/// The condition of the conditional.
#[get = "pub"]
condition: ParenthesizedCondition,
condition: Parenthesized,
}
impl Conditional {
/// Dissolves the [`Conditional`] into its components.
#[must_use]
pub fn dissolve(self) -> (Keyword, ParenthesizedCondition) {
pub fn dissolve(self) -> (Keyword, Parenthesized) {
(self.if_keyword, self.condition)
}
}
@ -773,7 +773,7 @@ impl<'a> Parser<'a> {
// eat the if keyword
self.forward();
let condition = self.parse_parenthesized_condition(handler)?;
let condition = self.parse_parenthesized(handler)?;
let conditional = Conditional {
if_keyword,

50
src/transpile/conversions.rs
View File

@ -1,44 +1,12 @@
//! Conversion functions for converting between tokens/ast-nodes and [`shulkerbox`] types
use shulkerbox::{
datapack::Condition as DpCondition,
util::{MacroString, MacroStringPart},
};
use shulkerbox::util::{MacroString, MacroStringPart};
use crate::{
lexical::token::{MacroStringLiteral, MacroStringLiteralPart},
syntax::syntax_tree::{
condition::{
BinaryCondition, Condition, ConditionalBinaryOperator, ConditionalPrefixOperator,
PrimaryCondition,
},
AnyStringLiteral,
},
syntax::syntax_tree::AnyStringLiteral,
};
impl From<Condition> for DpCondition {
fn from(value: Condition) -> Self {
match value {
Condition::Primary(primary) => primary.into(),
Condition::Binary(binary) => binary.into(),
}
}
}
impl From<PrimaryCondition> for DpCondition {
fn from(value: PrimaryCondition) -> Self {
match value {
PrimaryCondition::StringLiteral(literal) => Self::Atom(literal.into()),
PrimaryCondition::Parenthesized(cond) => cond.dissolve().1.into(),
PrimaryCondition::Unary(prefix) => match prefix.operator() {
ConditionalPrefixOperator::LogicalNot(_) => {
Self::Not(Box::new(prefix.dissolve().1.into()))
}
},
}
}
}
impl From<&AnyStringLiteral> for MacroString {
fn from(value: &AnyStringLiteral) -> Self {
match value {
@ -88,17 +56,3 @@ impl From<MacroStringLiteral> for MacroString {
Self::from(&value)
}
}
impl From<BinaryCondition> for DpCondition {
fn from(value: BinaryCondition) -> Self {
let (lhs, op, rhs) = value.dissolve();
match op {
ConditionalBinaryOperator::LogicalAnd(_, _) => {
Self::And(Box::new(lhs.into()), Box::new(rhs.into()))
}
ConditionalBinaryOperator::LogicalOr(_, _) => {
Self::Or(Box::new(lhs.into()), Box::new(rhs.into()))
}
}
}
}

45
src/transpile/expression.rs
View File

@ -266,6 +266,26 @@ impl Binary {
let right = self.right_operand().comptime_eval(scope)?;
match (left, right) {
(ComptimeValue::Boolean(true), _) | (_, ComptimeValue::Boolean(true)) if matches!(self.operator(), BinaryOperator::LogicalOr(..))
// TODO: re-enable if can_yield_type works properly
/*&& self
.left_operand()
.can_yield_type(ValueType::Boolean, scope)
&& self
.right_operand()
.can_yield_type(ValueType::Boolean, scope)*/ => {
Some(ComptimeValue::Boolean(true))
}
(ComptimeValue::Boolean(false), _) | (_, ComptimeValue::Boolean(false)) if matches!(self.operator(), BinaryOperator::LogicalAnd(..))
// TODO: re-enable if can_yield_type works properly
/*&& self
.left_operand()
.can_yield_type(ValueType::Boolean, scope)
&& self
.right_operand()
.can_yield_type(ValueType::Boolean, scope)*/ => {
Some(ComptimeValue::Boolean(false))
}
(ComptimeValue::Boolean(left), ComptimeValue::Boolean(right)) => {
match self.operator() {
BinaryOperator::Equal(..) => Some(ComptimeValue::Boolean(left == right)),
@ -275,27 +295,6 @@ impl Binary {
_ => None,
}
}
(ComptimeValue::Boolean(true), _) | (_, ComptimeValue::Boolean(true)) => {
if matches!(self.operator(), BinaryOperator::LogicalOr(..))
&& self
.left_operand()
.can_yield_type(ValueType::Boolean, scope)
&& self
.right_operand()
.can_yield_type(ValueType::Boolean, scope)
{
Some(ComptimeValue::Boolean(true))
} else {
None
}
}
(ComptimeValue::Boolean(false), _) | (_, ComptimeValue::Boolean(false)) => {
if matches!(self.operator(), BinaryOperator::LogicalAnd(..)) {
Some(ComptimeValue::Boolean(false))
} else {
None
}
}
(ComptimeValue::Integer(left), ComptimeValue::Integer(right)) => {
match self.operator() {
BinaryOperator::Add(..) => left.checked_add(right).map(ComptimeValue::Integer),
@ -744,7 +743,7 @@ impl Transpiler {
}
}
fn transpile_expression_as_condition(
pub(super) fn transpile_expression_as_condition(
&mut self,
expression: &Expression,
scope: &Arc<super::Scope>,
@ -767,7 +766,7 @@ impl Transpiler {
handler: &impl Handler<base::Error>,
) -> TranspileResult<(Vec<Command>, Condition)> {
match primary {
Primary::Boolean(_) => unreachable!("boolean literal would have been catched in comptime evaluation of binary expression"),
Primary::Boolean(_) => todo!("handle boolean literal if not catched by comptime eval"),
Primary::Integer(_) => {
let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean,

115
src/transpile/transpiler.rs
View File

@ -31,6 +31,7 @@ use crate::{
use super::{
error::{TranspileError, TranspileResult},
expression::ComptimeValue,
variables::{Scope, VariableData},
FunctionData, TranspileAnnotationValue,
};
@ -508,9 +509,12 @@ impl Transpiler {
}
Statement::ExecuteBlock(execute) => {
let child_scope = Scope::with_parent(scope);
Ok(self
.transpile_execute_block(execute, program_identifier, &child_scope, handler)?
.map_or_else(Vec::new, |cmd| vec![cmd]))
Ok(self.transpile_execute_block(
execute,
program_identifier,
&child_scope,
handler,
)?)
}
Statement::DocComment(doccomment) => {
let content = doccomment.content();
@ -654,9 +658,15 @@ impl Transpiler {
program_identifier: &str,
scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Command>> {
) -> TranspileResult<Vec<Command>> {
self.transpile_execute_block_internal(execute, program_identifier, scope, handler)
.map(|ex| ex.map(Command::Execute))
.map(|ex| {
ex.map(|(mut pre_cmds, exec)| {
pre_cmds.push(exec.into());
pre_cmds
})
.unwrap_or_default()
})
}
fn transpile_execute_block_internal(
@ -665,7 +675,7 @@ impl Transpiler {
program_identifier: &str,
scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Execute>> {
) -> TranspileResult<Option<(Vec<Command>, Execute)>> {
match execute {
ExecuteBlock::HeadTail(head, tail) => {
let tail = match tail {
@ -689,7 +699,7 @@ impl Transpiler {
if commands.is_empty() {
Ok(None)
} else {
Ok(Some(Execute::Runs(commands)))
Ok(Some((Vec::new(), Execute::Runs(commands))))
}
}
ExecuteBlockTail::ExecuteBlock(_, execute_block) => self
@ -764,13 +774,12 @@ impl Transpiler {
program_identifier: &str,
scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Execute>> {
let (_, cond) = cond.clone().dissolve();
let (_, cond, _) = cond.dissolve();
) -> TranspileResult<Option<(Vec<Command>, Execute)>> {
let cond_expression = cond.condition().expression().as_ref();
let mut errors = Vec::new();
let el = el
.and_then(|el| {
let el = el.and_then(|el| {
let (_, block) = el.clone().dissolve();
let statements = block.statements();
let cmds = statements
@ -791,31 +800,40 @@ impl Transpiler {
))),
_ => Some(Execute::Runs(cmds)),
}
})
.map(Box::new);
});
if let Some(ComptimeValue::Boolean(value)) = cond_expression.comptime_eval(scope) {
if value {
Ok(Some((Vec::new(), then)))
} else {
Ok(el.map(|el| (Vec::new(), el)))
}
} else {
if !errors.is_empty() {
return Err(errors.remove(0));
}
Ok(Some(Execute::If(
datapack::Condition::from(cond),
Box::new(then),
el,
let (pre_cond_cmds, cond) =
self.transpile_expression_as_condition(cond_expression, scope, handler)?;
Ok(Some((
pre_cond_cmds,
Execute::If(cond, Box::new(then), el.map(Box::new)),
)))
}
}
fn combine_execute_head_tail(
&mut self,
head: &ExecuteBlockHead,
tail: Option<Execute>,
tail: Option<(Vec<Command>, Execute)>,
program_identifier: &str,
scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Execute>> {
) -> TranspileResult<Option<(Vec<Command>, Execute)>> {
Ok(match head {
ExecuteBlockHead::Conditional(cond) => {
if let Some(tail) = tail {
if let Some((mut pre_cmds, tail)) = tail {
self.transpile_conditional(
cond,
tail,
@ -824,57 +842,88 @@ impl Transpiler {
scope,
handler,
)?
.map(|(pre_cond_cmds, cond)| {
pre_cmds.extend(pre_cond_cmds);
(pre_cmds, cond)
})
} else {
None
}
}
ExecuteBlockHead::As(r#as) => {
let selector = r#as.as_selector();
tail.map(|tail| Execute::As(selector.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::As(selector.into(), Box::new(tail)))
})
}
ExecuteBlockHead::At(at) => {
let selector = at.at_selector();
tail.map(|tail| Execute::At(selector.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::At(selector.into(), Box::new(tail)))
})
}
ExecuteBlockHead::Align(align) => {
let align = align.align_selector();
tail.map(|tail| Execute::Align(align.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::Align(align.into(), Box::new(tail)))
})
}
ExecuteBlockHead::Anchored(anchored) => {
let anchor = anchored.anchored_selector();
tail.map(|tail| Execute::Anchored(anchor.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::Anchored(anchor.into(), Box::new(tail)))
})
}
ExecuteBlockHead::In(r#in) => {
let dimension = r#in.in_selector();
tail.map(|tail| Execute::In(dimension.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::In(dimension.into(), Box::new(tail)))
})
}
ExecuteBlockHead::Positioned(positioned) => {
let position = positioned.positioned_selector();
tail.map(|tail| Execute::Positioned(position.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(
pre_cmds,
Execute::Positioned(position.into(), Box::new(tail)),
)
})
}
ExecuteBlockHead::Rotated(rotated) => {
let rotation = rotated.rotated_selector();
tail.map(|tail| Execute::Rotated(rotation.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::Rotated(rotation.into(), Box::new(tail)))
})
}
ExecuteBlockHead::Facing(facing) => {
let facing = facing.facing_selector();
tail.map(|tail| Execute::Facing(facing.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::Facing(facing.into(), Box::new(tail)))
})
}
ExecuteBlockHead::AsAt(as_at) => {
let selector = as_at.asat_selector();
tail.map(|tail| Execute::AsAt(selector.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::AsAt(selector.into(), Box::new(tail)))
})
}
ExecuteBlockHead::On(on) => {
let dimension = on.on_selector();
tail.map(|tail| Execute::On(dimension.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::On(dimension.into(), Box::new(tail)))
})
}
ExecuteBlockHead::Store(store) => {
let store = store.store_selector();
tail.map(|tail| Execute::Store(store.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::Store(store.into(), Box::new(tail)))
})
}
ExecuteBlockHead::Summon(summon) => {
let entity = summon.summon_selector();
tail.map(|tail| Execute::Summon(entity.into(), Box::new(tail)))
tail.map(|(pre_cmds, tail)| {
(pre_cmds, Execute::Summon(entity.into(), Box::new(tail)))
})
}
})
}