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

implement todos in scoreboard variable

This commit is contained in:
Moritz Hölting 2025-03-16 19:25:25 +01:00
parent 0885665baf
commit b119ca33c7
4 changed files with 358 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/transpile/error.rs
View File

@ -42,6 +42,8 @@ pub enum TranspileError {
UnknownIdentifier(#[from] UnknownIdentifier),
#[error(transparent)]
MissingValue(#[from] MissingValue),
#[error(transparent)]
IllegalIndexing(#[from] IllegalIndexing),
}
/// The result of a transpilation operation.
@ -309,3 +311,54 @@ impl Display for MissingValue {
}
impl std::error::Error for MissingValue {}
/// An error that occurs when an indexing operation is not permitted.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IllegalIndexing {
pub reason: IllegalIndexingReason,
pub expression: Span,
}
impl Display for IllegalIndexing {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", Message::new(Severity::Error, &self.reason))?;
write!(
f,
"\n{}",
SourceCodeDisplay::new(&self.expression, Option::<u8>::None)
)
}
}
impl std::error::Error for IllegalIndexing {}
/// The reason why an indexing operation is not permitted.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum IllegalIndexingReason {
NotIdentifier,
InvalidComptimeType { expected: ExpectedType },
IndexOutOfBounds { index: usize, length: usize },
}
impl Display for IllegalIndexingReason {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NotIdentifier => {
write!(f, "The expression is not an identifier.")
}
Self::InvalidComptimeType { expected } => {
write!(
f,
"The expression can only be indexed with type {expected} that can be evaluated at compile time."
)
}
Self::IndexOutOfBounds { index, length } => {
write!(
f,
"The index {index} is out of bounds for the expression with length {length}."
)
}
}
}
}

105
src/transpile/expression.rs
View File

@ -19,7 +19,7 @@ use shulkerbox::prelude::{Command, Condition, Execute};
#[cfg(feature = "shulkerbox")]
use super::{
error::{MismatchedTypes, UnknownIdentifier},
error::{IllegalIndexing, IllegalIndexingReason, MismatchedTypes, UnknownIdentifier},
TranspileResult, Transpiler,
};
#[cfg(feature = "shulkerbox")]
@ -31,7 +31,6 @@ use crate::{
},
};
// TODO: fix this leading to compile errors without 'shulkerbox' feature
/// Compile-time evaluated value
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq)]
@ -287,16 +286,15 @@ impl Primary {
}
},
Self::Indexed(indexed) => {
let Self::Identifier(ident) = indexed.object().as_ref() else {
todo!("throw error: cannot index anything except identifiers")
};
if let Self::Identifier(ident) = indexed.object().as_ref() {
scope
.get_variable(ident.span.str())
.map_or(false, |variable| match r#type {
ValueType::Boolean => {
matches!(
variable.as_ref(),
VariableData::Tag { .. } | VariableData::BooleanStorageArray { .. }
VariableData::Tag { .. }
| VariableData::BooleanStorageArray { .. }
)
}
ValueType::Integer => {
@ -308,6 +306,9 @@ impl Primary {
}
ValueType::String => false,
})
} else {
false
}
}
#[cfg_attr(not(feature = "lua"), expect(unused_variables))]
Self::Lua(lua) => {
@ -785,9 +786,16 @@ impl Transpiler {
}
}
Primary::Indexed(indexed) => {
let Primary::Identifier(ident) = indexed.object().as_ref() else {
todo!("can only index identifier")
};
let ident = if let Primary::Identifier(ident) = indexed.object().as_ref() {
Ok(ident)
} else {
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::NotIdentifier,
expression: indexed.object().span(),
});
handler.receive(err.clone());
Err(err)
}?;
let variable = scope.get_variable(ident.span.str());
#[expect(clippy::option_if_let_else)]
if let Some(variable) = variable.as_deref() {
@ -801,7 +809,14 @@ impl Transpiler {
target,
})
} else {
todo!("can only index scoreboard with comptime string")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::String,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
}
VariableData::ScoreboardArray { objective, targets } => {
@ -818,10 +833,25 @@ impl Transpiler {
target,
})
} else {
todo!("index out of bounds")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::IndexOutOfBounds {
length: targets.len(),
index: usize::try_from(index).unwrap_or(usize::MAX),
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
} else {
todo!("can only index array with comptime integer")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::Integer,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
}
VariableData::BooleanStorageArray {
@ -842,10 +872,25 @@ impl Transpiler {
r#type: StorageType::Boolean,
})
} else {
todo!("index out of bounds")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::IndexOutOfBounds {
length: paths.len(),
index: usize::try_from(index).unwrap_or(usize::MAX),
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
} else {
todo!("can only index array with comptime integer")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::Integer,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
}
_ => {
@ -1022,9 +1067,16 @@ impl Transpiler {
self.transpile_expression_as_condition(parenthesized.expression(), scope, handler)
}
Primary::Indexed(indexed) => {
let Primary::Identifier(ident) = indexed.object().as_ref() else {
todo!("can only index identifier")
};
let ident = if let Primary::Identifier(ident) = indexed.object().as_ref() {
Ok(ident)
} else {
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::NotIdentifier,
expression: indexed.object().span(),
});
handler.receive(err.clone());
Err(err)
}?;
#[expect(clippy::option_if_let_else)]
if let Some(variable) = scope.get_variable(ident.span.str()).as_deref() {
#[expect(clippy::single_match_else)]
@ -1049,10 +1101,25 @@ impl Transpiler {
)),
))
} else {
todo!("index out of bounds")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::IndexOutOfBounds {
length: paths.len(),
index: usize::try_from(index).unwrap_or(usize::MAX),
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
} else {
todo!("can only index array with comptime integer")
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::Integer,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
}
}
_ => {

173
src/transpile/lua.rs
View File

@ -4,13 +4,17 @@
mod enabled {
use std::sync::Arc;
use mlua::{Lua, Value};
use mlua::{Lua, Table, Value};
use crate::{
base::{self, source_file::SourceElement, Handler},
lexical::token::Identifier,
syntax::syntax_tree::expression::LuaCode,
transpile::{
error::{LuaRuntimeError, MismatchedTypes, TranspileError, TranspileResult},
error::{
LuaRuntimeError, MismatchedTypes, TranspileError, TranspileResult,
UnknownIdentifier,
},
expression::{ComptimeValue, ExpectedType},
Scope, VariableData,
},
@ -53,14 +57,8 @@ mod enabled {
)
};
if let Err(err) = self.add_globals(&lua, scope) {
let err = TranspileError::LuaRuntimeError(LuaRuntimeError::from_lua_err(
&err,
self.span(),
));
handler.receive(crate::Error::from(err.clone()));
return Err(err);
}
self.add_globals(&lua, scope)
.inspect_err(|err| handler.receive(err.clone()))?;
let res = lua
.load(self.code())
@ -95,10 +93,30 @@ mod enabled {
self.handle_lua_result(lua_result, handler)
}
fn add_globals(&self, lua: &Lua, scope: &Arc<Scope>) -> mlua::Result<()> {
fn add_globals(&self, lua: &Lua, scope: &Arc<Scope>) -> TranspileResult<()> {
let globals = lua.globals();
let shulkerscript_globals = {
let shulkerscript_globals = self
.get_std_library(lua)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
if let Some(inputs) = self.inputs() {
for identifier in inputs.elements() {
let (name, value) = self.add_input_to_globals(identifier, lua, scope)?;
globals
.set(name, value)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
}
}
globals
.set("shulkerscript", shulkerscript_globals)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Ok(())
}
fn get_std_library(&self, lua: &Lua) -> mlua::Result<Table> {
let table = lua.create_table()?;
let (location_path, location_start, location_end) = {
@ -127,77 +145,134 @@ mod enabled {
table.set("version", crate::VERSION)?;
table
};
if let Some(inputs) = self.inputs() {
for x in inputs.elements() {
let name = x.span.str();
let value = match scope.get_variable(name).as_deref() {
Some(VariableData::MacroParameter { macro_name, .. }) => {
Value::String(lua.create_string(format!("$({macro_name})"))?)
Ok(table)
}
#[expect(clippy::too_many_lines)]
fn add_input_to_globals<'a>(
&self,
identifier: &'a Identifier,
lua: &Lua,
scope: &Arc<Scope>,
) -> TranspileResult<(&'a str, Value)> {
let name = identifier.span.str();
let value = match scope.get_variable(name).as_deref() {
Some(VariableData::MacroParameter { macro_name, .. }) => Value::String(
lua.create_string(format!("$({macro_name})"))
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
),
Some(VariableData::Scoreboard { objective }) => {
let table = lua.create_table()?;
table.set("objective", objective.as_str())?;
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("objective", objective.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::ScoreboardValue { objective, target }) => {
let table = lua.create_table()?;
table.set("objective", lua.create_string(objective)?)?;
table.set("target", lua.create_string(target)?)?;
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"objective",
lua.create_string(objective)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"target",
lua.create_string(target)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::ScoreboardArray { objective, targets }) => {
let table = lua.create_table()?;
table.set("objective", objective.as_str())?;
let values = lua.create_table_from(
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("objective", objective.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
let values = lua
.create_table_from(
targets
.iter()
.enumerate()
.map(|(i, target)| (i + 1, target.as_str())),
)?;
table.set("targets", values)?;
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("targets", values)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::BooleanStorage { storage_name, path }) => {
let table = lua.create_table()?;
table.set("storage", lua.create_string(storage_name)?)?;
table.set("path", lua.create_string(path)?)?;
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"storage",
lua.create_string(storage_name)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"path",
lua.create_string(path)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::BooleanStorageArray {
storage_name,
paths,
}) => {
let table = lua.create_table()?;
table.set("storage", storage_name.as_str())?;
let values = lua.create_table_from(
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("storage", storage_name.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
let values = lua
.create_table_from(
paths
.iter()
.enumerate()
.map(|(i, path)| (i + 1, path.as_str())),
)?;
table.set("paths", values)?;
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("paths", values)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::Tag { tag_name }) => {
let table = lua.create_table()?;
table.set("name", tag_name.as_str())?;
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("name", tag_name.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::Function { .. }) => {
todo!("allow function variable type")
todo!("functions are not supported yet");
}
None => {
return Err(TranspileError::UnknownIdentifier(UnknownIdentifier {
identifier: identifier.span(),
}));
}
None => todo!("throw correct error"),
};
globals.set(name, value)?;
}
}
globals.set("shulkerscript", shulkerscript_globals)?;
Ok(())
Ok((name, value))
}
fn handle_lua_result(

27
src/transpile/variables.rs
View File

@ -27,7 +27,10 @@ use crate::{
};
use super::{
error::{AssignmentError, IllegalAnnotationContent, MismatchedTypes},
error::{
AssignmentError, IllegalAnnotationContent, IllegalIndexing, IllegalIndexingReason,
MismatchedTypes,
},
expression::{ComptimeValue, DataLocation, ExpectedType, StorageType},
FunctionData, TranspileAnnotationValue, TranspileError, TranspileResult,
};
@ -244,7 +247,9 @@ impl Transpiler {
scope,
handler,
),
_ => todo!("declarations other than single not supported yet: {declaration:?}"),
_ => todo!(
"declarations other than single and scoreboard not supported yet: {declaration:?}"
),
}
}
@ -388,9 +393,23 @@ impl Transpiler {
Some(ComptimeValue::MacroString(s)) => {
todo!("indexing scoreboard with macro string: {s}")
}
Some(_) => todo!("invalid indexing value"),
Some(_) => {
let err = TranspileError::IllegalIndexing(IllegalIndexing {
expression: expression.span(),
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::String,
},
});
handler.receive(err.clone());
return Err(err);
}
None => {
todo!("cannot assign to scoreboard without indexing")
let err = TranspileError::AssignmentError(AssignmentError {
identifier: identifier.span(),
message: "Cannot assign to a scoreboard without indexing".to_string(),
});
handler.receive(err.clone());
return Err(err);
}
},
VariableData::Function { .. } | VariableData::MacroParameter { .. } => {