dbidwell/stationeers_lang
1
0
Fork 0
Code Issues 2 Pull Requests 1 Actions Packages Projects 1 Releases 10 Wiki Activity

bitwise #15

Open
dbidwell wants to merge 17 commits from bitwise into master
pull from: bitwise
merge into: dbidwell:master
Conversation 0 Commits 17 Files Changed 64 +218 -18
5 changed files with 218 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit e56414c251 - Show all commits

67
rust_compiler/libs/compiler/src/v1.rs
View File

@@ -525,6 +525,28 @@ impl<'a> Compiler<'a> {
temp_name: Some(result_name),
}))
}
Expression::BitwiseNot(inner_expr) => {
// Compile bitwise NOT using the NOT instruction
let (inner_str, cleanup) = self.compile_operand(*inner_expr, scope)?;
let result_name = self.next_temp_name();
let result_loc =
scope.add_variable(result_name.clone(), LocationRequest::Temp, None)?;
let result_reg = self.resolve_register(&result_loc)?;
self.write_instruction(
Instruction::Not(Operand::Register(result_reg), inner_str),
Some(expr.span),
)?;
if let Some(name) = cleanup {
scope.free_temp(name, None)?;
}
Ok(Some(CompileLocation {
location: result_loc,
temp_name: Some(result_name),
}))
}
Expression::TupleDeclaration(tuple_decl) => {
self.expression_tuple_declaration(tuple_decl.node, scope)?;
Ok(None)
@@ -889,6 +911,32 @@ impl<'a> Compiler<'a> {
}
(var_loc, None)
}
Expression::BitwiseNot(_) => {
// Compile the bitwise NOT expression
let result = self.expression(expr, scope)?;
let var_loc = scope.add_variable(
name_str.clone(),
LocationRequest::Persist,
Some(name_span),
)?;
if let Some(res) = result {
// Move result from temp to new persistent variable
let result_reg = self.resolve_register(&res.location)?;
self.emit_variable_assignment(&var_loc, Operand::Register(result_reg))?;
// Free the temp result
if let Some(name) = res.temp_name {
scope.free_temp(name, None)?;
}
} else {
return Err(Error::Unknown(
format!("`{name_str}` bitwise NOT expression did not produce a value"),
Some(name_span),
));
}
(var_loc, None)
}
_ => {
return Err(Error::Unknown(
format!("`{name_str}` declaration of this type is not supported/implemented."),
@@ -2121,6 +2169,7 @@ impl<'a> Compiler<'a> {
| BinaryExpression::Divide(l, r)
| BinaryExpression::Exponent(l, r)
| BinaryExpression::Modulo(l, r) => (fold_expression(l)?, fold_expression(r)?),
_ => return None,
};
match expr {
@@ -2189,6 +2238,24 @@ impl<'a> Compiler<'a> {
BinaryExpression::Modulo(l, r) => {
(|into, lhs, rhs| Instruction::Mod(into, lhs, rhs), l, r)
}
BinaryExpression::BitwiseAnd(l, r) => {
(|into, lhs, rhs| Instruction::And(into, lhs, rhs), l, r)
}
BinaryExpression::BitwiseOr(l, r) => {
(|into, lhs, rhs| Instruction::Or(into, lhs, rhs), l, r)
}
BinaryExpression::BitwiseXor(l, r) => {
(|into, lhs, rhs| Instruction::Xor(into, lhs, rhs), l, r)
}
BinaryExpression::LeftShift(l, r) => {
(|into, lhs, rhs| Instruction::Sll(into, lhs, rhs), l, r)
}
BinaryExpression::RightShiftArithmetic(l, r) => {
(|into, lhs, rhs| Instruction::Sra(into, lhs, rhs), l, r)
}
BinaryExpression::RightShiftLogical(l, r) => {
(|into, lhs, rhs| Instruction::Srl(into, lhs, rhs), l, r)
}
};
let span = Self::merge_spans(left_expr.span, right_expr.span);

21
rust_compiler/libs/il/src/lib.rs
View File

@@ -232,12 +232,22 @@ pub enum Instruction<'a> {
/// `sle dst a b` - Set if Less or Equal
SetLe(Operand<'a>, Operand<'a>, Operand<'a>),
/// `and dst a b` - Logical AND
/// `and dst a b` - Bitwise AND
And(Operand<'a>, Operand<'a>, Operand<'a>),
/// `or dst a b` - Logical OR
/// `or dst a b` - Bitwise OR
Or(Operand<'a>, Operand<'a>, Operand<'a>),
/// `xor dst a b` - Logical XOR
/// `xor dst a b` - Bitwise XOR
Xor(Operand<'a>, Operand<'a>, Operand<'a>),
/// `nor dst a b` - Bitwise NOR
Nor(Operand<'a>, Operand<'a>, Operand<'a>),
/// `not dst a` - Bitwise NOT
Not(Operand<'a>, Operand<'a>),
/// `sll dst a b` - Logical Left Shift
Sll(Operand<'a>, Operand<'a>, Operand<'a>),
/// `sra dst a b` - Arithmetic Right Shift
Sra(Operand<'a>, Operand<'a>, Operand<'a>),
/// `srl dst a b` - Logical Right Shift
Srl(Operand<'a>, Operand<'a>, Operand<'a>),
/// `push val` - Push to Stack
Push(Operand<'a>),
@@ -338,6 +348,11 @@ impl<'a> fmt::Display for Instruction<'a> {
Instruction::And(dst, a, b) => write!(f, "and {} {} {}", dst, a, b),
Instruction::Or(dst, a, b) => write!(f, "or {} {} {}", dst, a, b),
Instruction::Xor(dst, a, b) => write!(f, "xor {} {} {}", dst, a, b),
Instruction::Nor(dst, a, b) => write!(f, "nor {} {} {}", dst, a, b),
Instruction::Not(dst, a) => write!(f, "not {} {}", dst, a),
Instruction::Sll(dst, a, b) => write!(f, "sll {} {} {}", dst, a, b),
Instruction::Sra(dst, a, b) => write!(f, "sra {} {} {}", dst, a, b),
Instruction::Srl(dst, a, b) => write!(f, "srl {} {} {}", dst, a, b),
Instruction::Push(val) => write!(f, "push {}", val),
Instruction::Pop(dst) => write!(f, "pop {}", dst),
Instruction::Peek(dst) => write!(f, "peek {}", dst),

73
rust_compiler/libs/parser/src/lib.rs
View File

@@ -294,12 +294,12 @@ impl<'a> Parser<'a> {
// Handle Infix operators (Binary, Logical, Assignment)
if self_matches_peek!(
self,
TokenType::Symbol(s) if s.is_operator() || s.is_comparison() || s.is_logical() || matches!(s, Symbol::Assign | Symbol::Question)
TokenType::Symbol(s) if s.is_operator() || s.is_comparison() || s.is_logical() || s.is_bitwise() || matches!(s, Symbol::Assign | Symbol::Question)
) {
return Ok(Some(self.infix(lhs)?));
} else if self_matches_current!(
self,
TokenType::Symbol(s) if s.is_operator() || s.is_comparison() || s.is_logical() || matches!(s, Symbol::Assign | Symbol::Question)
TokenType::Symbol(s) if s.is_operator() || s.is_comparison() || s.is_logical() || s.is_bitwise() || matches!(s, Symbol::Assign | Symbol::Question)
) {
self.tokenizer.seek(SeekFrom::Current(-1))?;
return Ok(Some(self.infix(lhs)?));
@@ -608,6 +608,23 @@ impl<'a> Parser<'a> {
})
}
TokenType::Symbol(Symbol::BitwiseNot) => {
let start_span = self.current_span();
self.assign_next()?;
let inner_expr = self.unary()?.ok_or(Error::UnexpectedEOF)?;
let inner_with_postfix = self.parse_postfix(inner_expr)?;
let combined_span = Span {
start_line: start_span.start_line,
start_col: start_span.start_col,
end_line: inner_with_postfix.span.end_line,
end_col: inner_with_postfix.span.end_col,
};
Some(Spanned {
span: combined_span,
node: Expression::BitwiseNot(boxed!(inner_with_postfix)),
})
}
_ => {
return Err(Error::UnexpectedToken(
self.current_span(),
@@ -699,6 +716,20 @@ impl<'a> Parser<'a> {
}),
}
}
TokenType::Symbol(Symbol::BitwiseNot) => {
self.assign_next()?;
let inner = self.get_infix_child_node()?;
let span = Span {
start_line: start_span.start_line,
start_col: start_span.start_col,
end_line: inner.span.end_line,
end_col: inner.span.end_col,
};
Spanned {
span,
node: Expression::BitwiseNot(boxed!(inner)),
}
}
_ => {
return Err(Error::UnexpectedToken(
self.current_span(),
@@ -777,6 +808,7 @@ impl<'a> Parser<'a> {
| Expression::Variable(_)
| Expression::Ternary(_)
| Expression::Negation(_)
| Expression::BitwiseNot(_)
| Expression::MemberAccess(_)
| Expression::MethodCall(_)
| Expression::Tuple(_) => {}
@@ -796,7 +828,7 @@ impl<'a> Parser<'a> {
// Include Assign in the operator loop
while token_matches!(
temp_token,
TokenType::Symbol(s) if s.is_operator() || s.is_comparison() || s.is_logical() || matches!(s, Symbol::Assign | Symbol::Question | Symbol::Colon)
TokenType::Symbol(s) if s.is_operator() || s.is_comparison() || s.is_logical() || s.is_bitwise() || matches!(s, Symbol::Assign | Symbol::Question | Symbol::Colon)
) {
let operator = match temp_token.token_type {
TokenType::Symbol(s) => s,
@@ -869,6 +901,24 @@ impl<'a> Parser<'a> {
Symbol::Minus => {
BinaryExpression::Subtract(boxed!(left), boxed!(right))
}
Symbol::LeftShift => {
BinaryExpression::LeftShift(boxed!(left), boxed!(right))
}
Symbol::RightShiftArithmetic => {
BinaryExpression::RightShiftArithmetic(boxed!(left), boxed!(right))
}
Symbol::RightShiftLogical => {
BinaryExpression::RightShiftLogical(boxed!(left), boxed!(right))
}
Symbol::BitwiseAnd => {
BinaryExpression::BitwiseAnd(boxed!(left), boxed!(right))
}
Symbol::BitwiseOr => {
BinaryExpression::BitwiseOr(boxed!(left), boxed!(right))
}
Symbol::Caret => {
BinaryExpression::BitwiseXor(boxed!(left), boxed!(right))
}
_ => unreachable!(),
};
@@ -895,7 +945,22 @@ impl<'a> Parser<'a> {
// --- PRECEDENCE LEVEL 3: Additive (+, -) ---
process_binary_ops!(Symbol::Plus | Symbol::Minus, BinaryExpression);
// --- PRECEDENCE LEVEL 4: Comparison (<, >, <=, >=) ---
// --- PRECEDENCE LEVEL 4: Shift Operations (<<, >>, >>>) ---
process_binary_ops!(
Symbol::LeftShift | Symbol::RightShiftArithmetic | Symbol::RightShiftLogical,
BinaryExpression
);
// --- PRECEDENCE LEVEL 5: Bitwise AND (&) ---
process_binary_ops!(Symbol::BitwiseAnd, BinaryExpression);
// --- PRECEDENCE LEVEL 6: Bitwise XOR (^) ---
process_binary_ops!(Symbol::Caret, BinaryExpression);
// --- PRECEDENCE LEVEL 7: Bitwise OR (|) ---
process_binary_ops!(Symbol::BitwiseOr, BinaryExpression);
// --- PRECEDENCE LEVEL 8: Comparison (<, >, <=, >=) ---
let mut current_iteration = 0;
for (i, operator) in operators.iter().enumerate() {
if operator.is_comparison() && !matches!(operator, Symbol::Equal | Symbol::NotEqual) {

15
rust_compiler/libs/parser/src/tree_node.rs
View File

@@ -45,6 +45,12 @@ pub enum BinaryExpression<'a> {
Subtract(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
Exponent(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
Modulo(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
BitwiseAnd(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
BitwiseOr(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
BitwiseXor(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
LeftShift(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
RightShiftArithmetic(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
RightShiftLogical(Box<Spanned<Expression<'a>>>, Box<Spanned<Expression<'a>>>),
}
impl<'a> std::fmt::Display for BinaryExpression<'a> {
@@ -56,6 +62,12 @@ impl<'a> std::fmt::Display for BinaryExpression<'a> {
BinaryExpression::Subtract(l, r) => write!(f, "({} - {})", l, r),
BinaryExpression::Exponent(l, r) => write!(f, "({} ** {})", l, r),
BinaryExpression::Modulo(l, r) => write!(f, "({} % {})", l, r),
BinaryExpression::BitwiseAnd(l, r) => write!(f, "({} & {})", l, r),
BinaryExpression::BitwiseOr(l, r) => write!(f, "({} | {})", l, r),
BinaryExpression::BitwiseXor(l, r) => write!(f, "({} ^ {})", l, r),
BinaryExpression::LeftShift(l, r) => write!(f, "({} << {})", l, r),
BinaryExpression::RightShiftArithmetic(l, r) => write!(f, "({} >> {})", l, r),
BinaryExpression::RightShiftLogical(l, r) => write!(f, "({} >>> {})", l, r),
}
}
}
@@ -367,6 +379,7 @@ pub enum Expression<'a> {
Binary(Spanned<BinaryExpression<'a>>),
Block(Spanned<BlockExpression<'a>>),
Break(Span),
BitwiseNot(Box<Spanned<Expression<'a>>>),
ConstDeclaration(Spanned<ConstDeclarationExpression<'a>>),
Continue(Span),
Declaration(Spanned<Cow<'a, str>>, Box<Spanned<Expression<'a>>>),
@@ -398,6 +411,7 @@ impl<'a> std::fmt::Display for Expression<'a> {
Expression::Binary(e) => write!(f, "{}", e),
Expression::Block(e) => write!(f, "{}", e),
Expression::Break(_) => write!(f, "break"),
Expression::BitwiseNot(e) => write!(f, "(~{})", e),
Expression::ConstDeclaration(e) => write!(f, "{}", e),
Expression::Continue(_) => write!(f, "continue"),
Expression::Declaration(id, e) => write!(f, "(let {} = {})", id, e),
@@ -439,4 +453,3 @@ impl<'a> std::fmt::Display for Expression<'a> {
}
}
}

60
rust_compiler/libs/tokenizer/src/token.rs
View File

@@ -172,6 +172,23 @@ pub enum TokenType<'a> {
#[token(";", symbol!(Semicolon))]
#[token(":", symbol!(Colon))]
#[token(",", symbol!(Comma))]
#[token("?", symbol!(Question))]
#[token(".", symbol!(Dot))]
#[token("%", symbol!(Percent))]
#[token("~", symbol!(BitwiseNot))]
// Multi-character tokens must be defined before their single-character prefixes
// For tokens like >> and >>>, define >>> before >> to ensure correct matching
#[token(">>>", symbol!(RightShiftLogical))]
#[token(">>", symbol!(RightShiftArithmetic))]
#[token("<<", symbol!(LeftShift))]
#[token("==", symbol!(Equal))]
#[token("!=", symbol!(NotEqual))]
#[token("&&", symbol!(LogicalAnd))]
#[token("||", symbol!(LogicalOr))]
#[token("<=", symbol!(LessThanOrEqual))]
#[token(">=", symbol!(GreaterThanOrEqual))]
#[token("**", symbol!(Exp))]
// Single-character tokens
#[token("+", symbol!(Plus))]
#[token("-", symbol!(Minus))]
#[token("*", symbol!(Asterisk))]
@@ -180,17 +197,9 @@ pub enum TokenType<'a> {
#[token(">", symbol!(GreaterThan))]
#[token("=", symbol!(Assign))]
#[token("!", symbol!(LogicalNot))]
#[token(".", symbol!(Dot))]
#[token("^", symbol!(Caret))]
#[token("%", symbol!(Percent))]
#[token("?", symbol!(Question))]
#[token("==", symbol!(Equal))]
#[token("!=", symbol!(NotEqual))]
#[token("&&", symbol!(LogicalAnd))]
#[token("||", symbol!(LogicalOr))]
#[token("<=", symbol!(LessThanOrEqual))]
#[token(">=", symbol!(GreaterThanOrEqual))]
#[token("**", symbol!(Exp))]
#[token("&", symbol!(BitwiseAnd))]
#[token("|", symbol!(BitwiseOr))]
/// Represents a symbol token
Symbol(Symbol),
@@ -615,6 +624,12 @@ pub enum Symbol {
Percent,
/// Represents the `?` symbol
Question,
/// Represents the `&` symbol (bitwise AND)
BitwiseAnd,
/// Represents the `|` symbol (bitwise OR)
BitwiseOr,
/// Represents the `~` symbol (bitwise NOT)
BitwiseNot,
// Double Character Symbols
/// Represents the `==` symbol
@@ -629,6 +644,12 @@ pub enum Symbol {
LessThanOrEqual,
/// Represents the `>=` symbol
GreaterThanOrEqual,
/// Represents the `<<` symbol (left shift)
LeftShift,
/// Represents the `>>` symbol (arithmetic right shift)
RightShiftArithmetic,
/// Represents the `>>>` symbol (logical right shift)
RightShiftLogical,
/// Represents the `**` symbol
Exp,
}
@@ -643,6 +664,19 @@ impl Symbol {
| Symbol::Slash
| Symbol::Exp
| Symbol::Percent
| Symbol::Caret
)
}
pub fn is_bitwise(&self) -> bool {
matches!(
self,
Symbol::BitwiseAnd
| Symbol::BitwiseOr
| Symbol::BitwiseNot
| Symbol::LeftShift
| Symbol::RightShiftArithmetic
| Symbol::RightShiftLogical
)
}
@@ -693,6 +727,12 @@ impl std::fmt::Display for Symbol {
Self::NotEqual => write!(f, "!="),
Self::Dot => write!(f, "."),
Self::Caret => write!(f, "^"),
Self::BitwiseAnd => write!(f, "&"),
Self::BitwiseOr => write!(f, "|"),
Self::BitwiseNot => write!(f, "~"),
Self::LeftShift => write!(f, "<<"),
Self::RightShiftArithmetic => write!(f, ">>"),
Self::RightShiftLogical => write!(f, ">>>"),
Self::Exp => write!(f, "**"),
}
}