CSY/reowolf Changeset - 622cf123a4e6 · Centrum Wiskunde & Informatica (CWI)

Changeset - 622cf123a4e6

Parent rev.

Child rev.

[Not reviewed]

0 9 0

MH - 4 years ago 2021-05-27 18:56:55
contact@maxhenger.nl

Add concatenation assignment

9 files changed with 69 insertions and 12 deletions:

src/protocol/ast.rs

src/protocol/eval/executor.rs

src/protocol/eval/value.rs

src/protocol/parser/mod.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_tokenizer.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/tokens.rs

src/protocol/tests/eval_binding.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1276,12 +1276,13 @@ impl Expression { @@
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum AssignmentOperator {
     Set,
     Concatenated,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -726,13 +726,13 @@ impl Prompt { @@
                 debug_log!("  [{:03}] {:?}", _stack_idx, _stack_val);
+            }
             debug_log!("Heap:");
             for (_heap_idx, _heap_region) in self.store.heap_regions.iter().enumerate() {
                 let _is_free = self.store.free_regions.iter().any(|idx| *idx as usize == _heap_idx);
-                debug_log!("  [{:03}] in_use: {}, len: {}, vals: {:?}", _heap_idx, !_is_free, heap_region.values.len(), &_heap_region.values);
+                debug_log!("  [{:03}] in_use: {}, len: {}, vals: {:?}", _heap_idx, !_is_free, _heap_region.values.len(), &_heap_region.values);
+            }
+        }
         // No (more) expressions to evaluate. So evaluate statement (that may
         // depend on the result on the last evaluated expression(s))
         let stmt = &heap[cur_frame.position];
         let return_value = match stmt {

src/protocol/eval/value.rs

➞

Show inline comments

@@ @@ -258,12 +258,14 @@ impl Default for ValueGroup { @@
     /// Returns an empty ValueGroup
     fn default() -> Self {
         Self { values: Vec::new(), regions: Vec::new() }
+    }
+}
 enum ValueKind { Message, String, Array }
 pub(crate) fn apply_assignment_operator(store: &mut Store, lhs: ValueId, op: AssignmentOperator, rhs: Value) {
     use AssignmentOperator as AO;
     macro_rules! apply_int_op {
         ($lhs:ident, $assignment_tokens:tt, $operator:ident, $rhs:ident) => {
             match $lhs {
                 Value::SInt64(v) => { *v $assignment_tokens $rhs.as_sint64(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs),
+            }
+        }
+    }
     // let rhs = store.maybe_read_ref(&rhs).clone(); // we don't own this thing, so don't drop it
     let lhs = store.read_mut_ref(lhs);
     let mut to_dealloc = None;
     match op {
         AO::Set => {
             match lhs {
                     *lhs_heap_pos = rhs_heap_pos;
+                }
                 Value::Struct(v) => { to_dealloc = Some(*v); *v = rhs.as_struct(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", op, lhs, rhs),
+            }
         },
         AO::Concatenated => {
             let lhs_heap_pos = lhs.get_heap_pos().unwrap() as usize;
             let rhs_heap_pos = rhs.get_heap_pos().unwrap() as usize;
             // To prevent borrowing crap, swap out heap region with a temp empty array
             let mut total = Vec::new();
             std::mem::swap(&mut total, &mut store.heap_regions[lhs_heap_pos].values);
             // Push everything onto the swapped vector
             let rhs_len = store.heap_regions[rhs_heap_pos].values.len();
             total.reserve(rhs_len);
             for value_idx in 0..rhs_len {
                 total.push(store.clone_value(store.heap_regions[rhs_heap_pos].values[value_idx].clone()));
+            }
             // Swap back in place
             std::mem::swap(&mut total, &mut store.heap_regions[lhs_heap_pos].values);
             // We took ownership of the RHS, but we copied it into the LHS, so
             // different form assignment we need to drop the RHS heap pos.
             to_dealloc = Some(rhs_heap_pos as u32);
         },
         AO::Multiplied =>   { apply_int_op!(lhs, *=,  op, rhs) },
         AO::Divided =>      { apply_int_op!(lhs, /=,  op, rhs) },
         AO::Remained =>     { apply_int_op!(lhs, %=,  op, rhs) },
         AO::Added =>        { apply_int_op!(lhs, +=,  op, rhs) },
         AO::Subtracted =>   { apply_int_op!(lhs, -=,  op, rhs) },
         AO::ShiftedLeft =>  { apply_int_op!(lhs, <<=, op, rhs) },
         let lhs_heap_pos;
         let rhs_heap_pos;
         let lhs = store.maybe_read_ref(lhs);
         let rhs = store.maybe_read_ref(rhs);
         enum ValueKind { Message, String, Array }
         let value_kind;
         match lhs {
             Value::Message(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_message();

src/protocol/parser/mod.rs

➞

Show inline comments

@@ @@ -184,15 +184,12 @@ impl Parser { @@
         // Add every known type to the type table
         self.type_table.build_base_types(&mut self.modules, &mut pass_ctx)?;
         // Continue compilation with the remaining phases now that the types
         // are all in the type table
         for module_idx in 0..self.modules.len() {
             // TODO: Remove the entire Visitor abstraction. It really doesn't
             //  make sense considering the amount of special handling we do
             //  in each pass.
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &mut self.modules[module_idx],
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -913,12 +913,13 @@ impl PassDefinitions { @@
             if token.is_none() {
                 return None
+            }
             match token.unwrap() {
                 TK::Equal               => Some(AO::Set),
                 TK::AtEquals            => Some(AO::Concatenated),
                 TK::StarEquals          => Some(AO::Multiplied),
                 TK::SlashEquals         => Some(AO::Divided),
                 TK::PercentEquals       => Some(AO::Remained),
                 TK::PlusEquals          => Some(AO::Added),
                 TK::MinusEquals         => Some(AO::Subtracted),
                 TK::ShiftLeftEquals     => Some(AO::ShiftedLeft),

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

@@ @@ -352,13 +352,18 @@ impl PassTokenizer { @@
+            }
         } else if first_char == b'?' {
             source.consume();
             token_kind = TokenKind::Question;
         } else if first_char == b'@' {
             source.consume();
             token_kind = TokenKind::At;
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::AtEquals;
             } else {
                 token_kind = TokenKind::At;
+            }
         } else if first_char == b'[' {
             source.consume();
             token_kind = TokenKind::OpenSquare;
         } else if first_char == b']' {
             source.consume();
             token_kind = TokenKind::CloseSquare;

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -1628,23 +1628,24 @@ impl PassTyping { @@
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;
         // Apply forced constraint to LHS value
         let progress_forced = match expr.operation {
             AO::Set =>
                 false,
             AO::Concatenated =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &ARRAYLIKE_TEMPLATE)?,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(
             ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0
         )?;
         debug_assert!(if progress_forced { progress_arg2 } else { true });
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.debug_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.debug_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));

src/protocol/parser/tokens.rs

➞

Show inline comments

@@ @@ -46,12 +46,13 @@ pub enum TokenKind { @@
     Equal,          // =
     // Punctuation (two characters)
     ColonColon,     // ::
     DotDot,         // ..
     ArrowRight,     // ->
     // Operator-like (two characters)
     AtEquals,       // @=
     PlusPlus,       // ++
     PlusEquals,     // +=
     MinusMinus,     // --
     MinusEquals,    // -=
     StarEquals,     // *=
     SlashEquals,    // /=
@@ @@ -84,13 +85,13 @@ impl TokenKind { @@
     /// Returns the number of characters associated with the token. May only be called on tokens
     /// that do not have a variable length.
     fn num_characters(&self) -> u32 {
         debug_assert!(!self.has_span_end() && *self != TokenKind::SpanEnd);
         if *self <= TokenKind::Equal {
-        } else if *self <= TokenKind::ShiftRight {
+        } else if *self <= TokenKind::GreaterEquals {
         } else {
+        }
+    }
@@ @@ -126,12 +127,13 @@ impl TokenKind { @@
             TK::Or => "|",
             TK::Tilde => "~",
             TK::Equal => "=",
             TK::ColonColon => "::",
             TK::DotDot => "..",
             TK::ArrowRight => "->",
             TK::AtEquals => "@=",
             TK::PlusPlus => "++",
             TK::PlusEquals => "+=",
             TK::MinusMinus => "--",
             TK::MinusEquals => "-=",
             TK::StarEquals => "*=",
             TK::SlashEquals => "/=",

src/protocol/tests/eval_binding.rs

➞

Show inline comments

@@ @@ -131,13 +131,13 @@ fn test_binding_from_union() { @@
 #[test]
 fn test_binding_fizz_buzz() {
     Tester::new_single_source_expect_ok("am I employable?", "
         union Fizzable { Number(u32), FizzBuzz, Fizz, Buzz }
-        func construct_fizz_buzz(u32 num) -> Fizzable[] {
+        func construct_fizz_buzz_very_slow(u32 num) -> Fizzable[] {
             u32 counter = 1;
             auto result = {};
             while (counter <= num) {
                 auto value = Fizzable::Number(counter);
                 if (counter % 5 == 0) {
                     if (counter % 3 == 0) {
@@ @@ -153,12 +153,34 @@ fn test_binding_fizz_buzz() { @@
                 counter += 1;
+            }
             return result;
+        }
         func construct_fizz_buzz_slightly_less_slow(u32 num) -> Fizzable[] {
             u32 counter = 1;
             auto result = {};
             while (counter <= num) {
                 auto value = Fizzable::Number(counter);
                 if (counter % 5 == 0) {
                     if (counter % 3 == 0) {
                         value = Fizzable::FizzBuzz;
                     } else {
                         value = Fizzable::Buzz;
+                    }
                 } else if (counter % 3 == 0) {
                     value = Fizzable::Fizz;
+                }
                 result @= { value }; // woohoo, no array builtins!
                 counter += 1;
+            }
             return result;
+        }
         func test_fizz_buzz(Fizzable[] fizzoid) -> bool {
             u32 idx = 0;
             bool valid = true;
             while (idx < length(fizzoid)) {
                 auto number = idx + 1;
                 auto is_div3 = number % 3 == 0;
@@ @@ -181,13 +203,19 @@ fn test_binding_fizz_buzz() { @@
+            }
             return valid;
+        }
         func fizz_buzz() -> bool {
             auto fizz = construct_fizz_buzz(100);
             return test_fizz_buzz(fizz);
             // auto fizz_more_slow = construct_fizz_buzz_very_slow(100);
             // return test_fizz_buzz(fizz_more_slow);
             // auto fizz_less_slow = construct_fizz_buzz_slightly_less_slow(100);
             // return test_fizz_buzz(fizz_less_slow);
             auto fizz_more_slow2 = construct_fizz_buzz_very_slow(100);
             auto fizz_less_slow2 = construct_fizz_buzz_slightly_less_slow(100);
             return test_fizz_buzz(fizz_more_slow2) && test_fizz_buzz(fizz_less_slow2);
+        }
     ").for_function("fizz_buzz", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)