rowan.a.tl/rush
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: rowan.a.tl:5298941bb9cf49f84cf6dcbc426125a8dcc777f1
Branches Tags
rowan.a.tl:main
rowan.a.tl:dev
..
compare: rowan.a.tl:748e96639a2c2c2b64e28283f4f9aa0e06452b1c
Branches Tags
rowan.a.tl:main
rowan.a.tl:dev

No commits in common. "5298941bb9cf49f84cf6dcbc426125a8dcc777f1" and "748e96639a2c2c2b64e28283f4f9aa0e06452b1c" have entirely different histories.
5298941bb9 ... 748e96639a

9 changed files with 291 additions and 577 deletions
Show Stats Expand all files Collapse all files

227
src/instructions/code.rs
View File

@ -63,7 +63,7 @@ fn _rest(vals: Vec<Gene>) -> Option<Gene> {
match &vals[0] { match &vals[0] {
Gene::Block(x) => { Gene::Block(x) => {
if x.len() > 1 { if x.len() > 1 {
Some(Gene::Block(x[1..].to_vec())) Some(Gene::Block(Box::new(x[1..].to_vec())))
} else { } else {
None None
} }
@ -79,7 +79,7 @@ fn _but_last(vals: Vec<Gene>) -> Option<Gene> {
Gene::Block(x) => { Gene::Block(x) => {
let x_len = x.len(); let x_len = x.len();
if x_len > 1 { if x_len > 1 {
Some(Gene::Block(x[..x_len - 1].to_vec())) Some(Gene::Block(Box::new(x[..x_len - 1].to_vec())))
} else { } else {
None None
} }
@ -91,7 +91,7 @@ make_instruction_clone!(code, code, _but_last, Gene, 1);
/// Returns all the vals wrapped in a code block /// Returns all the vals wrapped in a code block
fn _wrap_block(vals: Vec<Gene>) -> Option<Gene> { fn _wrap_block(vals: Vec<Gene>) -> Option<Gene> {
Some(Gene::Block(vals)) Some(Gene::Block(Box::new(vals)))
} }
make_instruction_clone!(code, code, _wrap_block, Gene, 1); make_instruction_clone!(code, code, _wrap_block, Gene, 1);
@ -116,7 +116,7 @@ fn _combine(vals: Vec<Gene>) -> Option<Gene> {
y_clone.push(x.clone()); y_clone.push(x.clone());
Some(Gene::Block(y_clone)) Some(Gene::Block(y_clone))
} }
(x, y) => Some(Gene::Block(vec![x.clone(), y.clone()])), (x, y) => Some(Gene::Block(Box::new(vec![x.clone(), y.clone()]))),
} }
} }
make_instruction_clone!(code, code, _combine, Gene, 2); make_instruction_clone!(code, code, _combine, Gene, 2);
@ -150,13 +150,13 @@ pub fn code_do_range(state: &mut PushState) {
} }
if increment != 0 { if increment != 0 {
state.exec.push(Gene::Block(vec![ state.exec.push(Gene::Block(Box::new(vec![
Gene::GeneInt(current_idx + increment), Gene::GeneInt(current_idx + increment),
Gene::GeneInt(dest_idx), Gene::GeneInt(dest_idx),
Gene::StateFunc(code_from_exec), Gene::StateFunc(code_from_exec),
to_do.clone(), to_do.clone(),
Gene::StateFunc(code_do_range), Gene::StateFunc(code_do_range),
])); ])));
} }
state.int.push(current_idx); state.int.push(current_idx);
state.exec.push(to_do); state.exec.push(to_do);
@ -180,12 +180,12 @@ pub fn exec_do_range(state: &mut PushState) {
} }
if increment != 0 { if increment != 0 {
state.exec.push(Gene::Block(vec![ state.exec.push(Gene::Block(Box::new(vec![
Gene::GeneInt(current_idx + increment), Gene::GeneInt(current_idx + increment),
Gene::GeneInt(dest_idx), Gene::GeneInt(dest_idx),
Gene::StateFunc(exec_do_range), Gene::StateFunc(exec_do_range),
to_do.clone(), to_do.clone(),
])); ])));
} }
state.int.push(current_idx); state.int.push(current_idx);
state.exec.push(to_do); state.exec.push(to_do);
@ -202,13 +202,13 @@ pub fn code_do_count(state: &mut PushState) {
} }
let code = state.code.pop().unwrap(); let code = state.code.pop().unwrap();
let count = state.int.pop().unwrap(); let count = state.int.pop().unwrap();
state.exec.push(Gene::Block(vec![ state.exec.push(Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(count - 1), Gene::GeneInt(count - 1),
Gene::StateFunc(code_from_exec), Gene::StateFunc(code_from_exec),
code, code,
Gene::StateFunc(code_do_range), Gene::StateFunc(code_do_range),
])); ])));
} }
/// Evaluates the top item on the exec stack n times. N pulled from top /// Evaluates the top item on the exec stack n times. N pulled from top
@ -222,12 +222,12 @@ pub fn exec_do_count(state: &mut PushState) {
} }
let code = state.exec.pop().unwrap(); let code = state.exec.pop().unwrap();
let count = state.int.pop().unwrap(); let count = state.int.pop().unwrap();
state.exec.push(Gene::Block(vec![ state.exec.push(Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(count - 1), Gene::GeneInt(count - 1),
Gene::StateFunc(exec_do_range), Gene::StateFunc(exec_do_range),
code, code,
])); ])));
} }
/// Evaluates the top item on the code stack n times but differently that /// Evaluates the top item on the code stack n times but differently that
@ -241,17 +241,17 @@ pub fn code_do_times(state: &mut PushState) {
} }
let code = state.code.pop().unwrap(); let code = state.code.pop().unwrap();
let times = state.int.pop().unwrap(); let times = state.int.pop().unwrap();
let nested_block = Gene::Block(vec![Gene::StateFunc(int_pop), code]); let nested_block = Gene::Block(Box::new(vec![Gene::StateFunc(int_pop), code]));
state.exec.push(Gene::Block(vec![ state.exec.push(Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(times - 1), Gene::GeneInt(times - 1),
Gene::StateFunc(code_from_exec), Gene::StateFunc(code_from_exec),
nested_block, nested_block,
Gene::StateFunc(code_do_range), Gene::StateFunc(code_do_range),
])); ])));
} }
/// Evaluates the top item on the code stack n times, also different :shrug: /// Evalutes the top item on the code stack n times. Also different :shrug:
pub fn exec_do_times(state: &mut PushState) { pub fn exec_do_times(state: &mut PushState) {
if state.exec.is_empty() || state.int.is_empty() { if state.exec.is_empty() || state.int.is_empty() {
return; return;
@ -261,13 +261,13 @@ pub fn exec_do_times(state: &mut PushState) {
} }
let code = state.exec.pop().unwrap(); let code = state.exec.pop().unwrap();
let times = state.int.pop().unwrap(); let times = state.int.pop().unwrap();
let nested_block = Gene::Block(vec![Gene::StateFunc(int_pop), code]); let nested_block = Gene::Block(Box::new(vec![Gene::StateFunc(int_pop), code]));
state.exec.push(Gene::Block(vec![ state.exec.push(Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(times - 1), Gene::GeneInt(times - 1),
Gene::StateFunc(exec_do_range), Gene::StateFunc(exec_do_range),
nested_block, nested_block,
])); ])));
} }
/// Evaluates the top item on the exec stack until the top bool isn't true /// Evaluates the top item on the exec stack until the top bool isn't true
@ -308,7 +308,7 @@ pub fn code_map(state: &mut PushState) {
let e = state.exec.pop().unwrap(); let e = state.exec.pop().unwrap();
let c = state.code.pop().unwrap(); let c = state.code.pop().unwrap();
let c_vec = match c { let c_vec = match c {
Gene::Block(val) => val, Gene::Block(val) => *val,
val => vec![val], val => vec![val],
}; };
@ -316,7 +316,7 @@ pub fn code_map(state: &mut PushState) {
for item in c_vec.clone().into_iter() { for item in c_vec.clone().into_iter() {
let code_block = vec![Gene::StateFunc(code_from_exec), item, e.clone()]; let code_block = vec![Gene::StateFunc(code_from_exec), item, e.clone()];
contents.push(Gene::Block(code_block)); contents.push(Gene::Block(Box::new(code_block)));
} }
contents.push(Gene::StateFunc(code_wrap_block)); contents.push(Gene::StateFunc(code_wrap_block));
@ -325,7 +325,7 @@ pub fn code_map(state: &mut PushState) {
contents.push(Gene::StateFunc(code_combine)); contents.push(Gene::StateFunc(code_combine));
} }
state.exec.push(Gene::Block(contents)); state.exec.push(Gene::Block(Box::new(contents)));
} }
/// If top bool is true, execute top element of code/exec stack and skip the second. /// If top bool is true, execute top element of code/exec stack and skip the second.
@ -366,7 +366,7 @@ pub fn exec_when(state: &mut PushState) {
/// If the first item isn't a block, coerced into one. /// If the first item isn't a block, coerced into one.
pub fn _member(vals: Vec<Gene>) -> Option<bool> { pub fn _member(vals: Vec<Gene>) -> Option<bool> {
let block = match vals[0].clone() { let block = match vals[0].clone() {
Gene::Block(val) => val, Gene::Block(val) => *val,
val => vec![val], val => vec![val],
}; };
@ -378,7 +378,7 @@ make_instruction_clone!(code, boolean, _member, Gene, 2);
/// If top code item isn't a block, wrap one around it. /// If top code item isn't a block, wrap one around it.
pub fn _nth(vals: Vec<Gene>, auxs: Vec<i128>) -> Option<Gene> { pub fn _nth(vals: Vec<Gene>, auxs: Vec<i128>) -> Option<Gene> {
let gene_vec = match vals[0].clone() { let gene_vec = match vals[0].clone() {
Gene::Block(val) => val, Gene::Block(val) => *val,
val => vec![val], val => vec![val],
}; };
let gene_vec_len = gene_vec.len(); let gene_vec_len = gene_vec.len();
@ -392,7 +392,7 @@ make_instruction_aux!(code, code, _nth, Gene, 1, int, 1, i128);
/// Pushes an empty block to the top of a stack. /// Pushes an empty block to the top of a stack.
pub fn _make_empty_block<T>(_: Vec<T>) -> Option<Gene> { pub fn _make_empty_block<T>(_: Vec<T>) -> Option<Gene> {
Some(Gene::Block(vec![])) Some(Gene::Block(Box::new(vec![])))
} }
make_instruction_clone!(code, code, _make_empty_block, Gene, 0); make_instruction_clone!(code, code, _make_empty_block, Gene, 0);
make_instruction_clone!(exec, exec, _make_empty_block, Gene, 0); make_instruction_clone!(exec, exec, _make_empty_block, Gene, 0);
@ -430,7 +430,7 @@ pub fn _extract(vals: Vec<Gene>, auxs: Vec<i128>) -> Option<Gene> {
block @ Gene::Block(_) => { block @ Gene::Block(_) => {
let block_len = block.rec_len(); let block_len = block.rec_len();
if block_len == 0 { if block_len == 0 {
None return None;
} else { } else {
let ndx = (auxs[0] % block_len as i128).abs() as usize; let ndx = (auxs[0] % block_len as i128).abs() as usize;
Some(vals[0].clone().code_at_point(ndx)?) Some(vals[0].clone().code_at_point(ndx)?)
@ -447,7 +447,7 @@ make_instruction_aux!(code, code, _extract, Gene, 1, int, 1, i128);
pub fn _insert(vals: Vec<Gene>, auxs: Vec<i128>) -> Option<Gene> { pub fn _insert(vals: Vec<Gene>, auxs: Vec<i128>) -> Option<Gene> {
let mut block = match vals[0].clone() { let mut block = match vals[0].clone() {
iblock @ Gene::Block(_) => iblock, iblock @ Gene::Block(_) => iblock,
val => Gene::Block(vec![val]), val => Gene::Block(Box::new(vec![val])),
}; };
if block.rec_len() == 0 { if block.rec_len() == 0 {
return _combine(vec![block, vals[1].clone()]); return _combine(vec![block, vals[1].clone()]);
@ -514,12 +514,12 @@ mod tests {
fn is_block_test() { fn is_block_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![])]; test_state.code = vec![Gene::Block(Box::new(vec![]))];
code_is_block(&mut test_state); code_is_block(&mut test_state);
assert_eq!(vec![true], test_state.boolean); assert_eq!(vec![true], test_state.boolean);
test_state.boolean.clear(); test_state.boolean.clear();
test_state.code = vec![Gene::GeneInt(1)]; test_state.code = vec![(Gene::GeneInt(1))];
code_is_block(&mut test_state); code_is_block(&mut test_state);
assert_eq!(vec![false], test_state.boolean); assert_eq!(vec![false], test_state.boolean);
} }
@ -528,12 +528,12 @@ mod tests {
fn is_singular_test() { fn is_singular_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![])]; test_state.code = vec![Gene::Block(Box::new(vec![]))];
code_is_singular(&mut test_state); code_is_singular(&mut test_state);
assert_eq!(vec![false], test_state.boolean); assert_eq!(vec![false], test_state.boolean);
test_state.boolean.clear(); test_state.boolean.clear();
test_state.code = vec![Gene::GeneInt(1)]; test_state.code = vec![(Gene::GeneInt(1))];
code_is_singular(&mut test_state); code_is_singular(&mut test_state);
assert_eq!(vec![true], test_state.boolean); assert_eq!(vec![true], test_state.boolean);
} }
@ -542,15 +542,15 @@ mod tests {
fn length_test() { fn length_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
])]; ]))];
code_length(&mut test_state); code_length(&mut test_state);
assert_eq!(vec![2], test_state.int); assert_eq!(vec![2], test_state.int);
test_state.int.clear(); test_state.int.clear();
test_state.code = vec![Gene::Block(vec![])]; test_state.code = vec![Gene::Block(Box::new(vec![]))];
code_length(&mut test_state); code_length(&mut test_state);
assert_eq!(vec![0], test_state.int); assert_eq!(vec![0], test_state.int);
test_state.int.clear(); test_state.int.clear();
@ -564,10 +564,10 @@ mod tests {
fn first_test() { fn first_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
])]; ]))];
code_first(&mut test_state); code_first(&mut test_state);
assert_eq!(vec![Gene::GeneInt(1)], test_state.code); assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
@ -586,10 +586,10 @@ mod tests {
fn last_test() { fn last_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
])]; ]))];
code_last(&mut test_state); code_last(&mut test_state);
assert_eq!(vec![Gene::GeneFloat(dec!(3.8))], test_state.code); assert_eq!(vec![Gene::GeneFloat(dec!(3.8))], test_state.code);
@ -608,17 +608,17 @@ mod tests {
fn rest_test() { fn rest_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
])]; ]))];
code_rest(&mut test_state); code_rest(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
Gene::GeneBoolean(true) Gene::GeneBoolean(true)
])], ]))],
test_state.code test_state.code
); );
@ -637,17 +637,17 @@ mod tests {
fn but_last_test() { fn but_last_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
])]; ]))];
code_but_last(&mut test_state); code_but_last(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
])], ]))],
test_state.code test_state.code
); );
@ -668,49 +668,58 @@ mod tests {
test_state.code = vec![Gene::GeneInt(1)]; test_state.code = vec![Gene::GeneInt(1)];
code_wrap_block(&mut test_state); code_wrap_block(&mut test_state);
assert_eq!(vec![Gene::Block(vec![Gene::GeneInt(1)])], test_state.code); assert_eq!(
vec![Gene::Block(Box::new(vec![Gene::GeneInt(1)]))],
test_state.code
);
} }
#[test] #[test]
fn combine_test() { fn combine_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code.push(Gene::Block(vec![Gene::GeneInt(1)])); test_state
test_state.code.push(Gene::Block(vec![ .code
.push(Gene::Block(Box::new(vec![Gene::GeneInt(1)])));
test_state.code.push(Gene::Block(Box::new(vec![
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
])); ])));
code_combine(&mut test_state); code_combine(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(3.8)), Gene::GeneFloat(dec!(3.8)),
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
])], ]))],
test_state.code test_state.code
); );
test_state.code.clear(); test_state.code.clear();
test_state.code.push(Gene::Block(vec![Gene::GeneInt(1)])); test_state
.code
.push(Gene::Block(Box::new(vec![Gene::GeneInt(1)])));
test_state.code.push(Gene::GeneFloat(dec!(4.0))); test_state.code.push(Gene::GeneFloat(dec!(4.0)));
code_combine(&mut test_state); code_combine(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(4.0)), Gene::GeneFloat(dec!(4.0)),
])], ]))],
test_state.code test_state.code
); );
test_state.code.clear(); test_state.code.clear();
test_state.code.push(Gene::GeneFloat(dec!(4.0))); test_state.code.push(Gene::GeneFloat(dec!(4.0)));
test_state.code.push(Gene::Block(vec![Gene::GeneInt(1)])); test_state
.code
.push(Gene::Block(Box::new(vec![Gene::GeneInt(1)])));
code_combine(&mut test_state); code_combine(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(4.0)), Gene::GeneFloat(dec!(4.0)),
])], ]))],
test_state.code test_state.code
); );
test_state.code.clear(); test_state.code.clear();
@ -719,10 +728,10 @@ mod tests {
test_state.code.push(Gene::GeneChar('z')); test_state.code.push(Gene::GeneChar('z'));
code_combine(&mut test_state); code_combine(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneChar('z'), Gene::GeneChar('z'),
Gene::GeneFloat(dec!(4.0)), Gene::GeneFloat(dec!(4.0)),
])], ]))],
test_state.code test_state.code
); );
} }
@ -870,12 +879,12 @@ mod tests {
test_state.code = vec![Gene::GeneInt(5)]; test_state.code = vec![Gene::GeneInt(5)];
test_state.exec = vec![Gene::GeneInt(-1)]; test_state.exec = vec![Gene::GeneInt(-1)];
code_map(&mut test_state); code_map(&mut test_state);
test_state.exec = vec![Gene::Block(vec![Gene::Block(vec![ test_state.exec = vec![Gene::Block(Box::new(vec![Gene::Block(Box::new(vec![
Gene::StateFunc(code_from_exec), Gene::StateFunc(code_from_exec),
Gene::GeneInt(5), Gene::GeneInt(5),
Gene::GeneInt(-1), Gene::GeneInt(-1),
Gene::StateFunc(code_wrap_block), Gene::StateFunc(code_wrap_block),
])])] ]))]))]
} }
#[test] #[test]
@ -951,11 +960,11 @@ mod tests {
test_state.code = vec![ test_state.code = vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::StateFunc(exec_do_range), Gene::StateFunc(exec_do_range),
]), ])),
]; ];
code_member(&mut test_state); code_member(&mut test_state);
assert_eq!(vec![true], test_state.boolean); assert_eq!(vec![true], test_state.boolean);
@ -963,11 +972,11 @@ mod tests {
test_state.code = vec![ test_state.code = vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(5), Gene::GeneInt(5),
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::StateFunc(exec_do_range), Gene::StateFunc(exec_do_range),
]), ])),
]; ];
code_member(&mut test_state); code_member(&mut test_state);
assert_eq!(vec![false], test_state.boolean); assert_eq!(vec![false], test_state.boolean);
@ -987,11 +996,11 @@ mod tests {
fn code_exec_nth_test() { fn code_exec_nth_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(2), Gene::GeneInt(2),
])]; ]))];
test_state.int = vec![1]; test_state.int = vec![1];
code_nth(&mut test_state); code_nth(&mut test_state);
assert_eq!(vec![Gene::GeneInt(1)], test_state.code); assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
@ -1001,11 +1010,11 @@ mod tests {
code_nth(&mut test_state); code_nth(&mut test_state);
assert_eq!(vec![Gene::GeneInt(1)], test_state.code); assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(0), Gene::GeneInt(0),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(2), Gene::GeneInt(2),
])]; ]))];
test_state.int = vec![4]; test_state.int = vec![4];
code_nth(&mut test_state); code_nth(&mut test_state);
assert_eq!(vec![Gene::GeneInt(1)], test_state.code); assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
@ -1019,7 +1028,7 @@ mod tests {
code_make_empty_block(&mut test_state); code_make_empty_block(&mut test_state);
let empty_vec: Vec<Gene> = Vec::new(); let empty_vec: Vec<Gene> = Vec::new();
assert_eq!( assert_eq!(
vec![Gene::GeneInt(0), Gene::Block(empty_vec.clone())], vec![Gene::GeneInt(0), Gene::Block(Box::new(empty_vec.clone()))],
test_state.code test_state.code
); );
test_state.code.clear(); test_state.code.clear();
@ -1039,12 +1048,12 @@ mod tests {
test_state.boolean.clear(); test_state.boolean.clear();
let empty_vec: Vec<Gene> = Vec::new(); let empty_vec: Vec<Gene> = Vec::new();
test_state.code = vec![Gene::Block(empty_vec.clone())]; test_state.code = vec![Gene::Block(Box::new(empty_vec.clone()))];
code_is_empty_block(&mut test_state); code_is_empty_block(&mut test_state);
assert_eq!(vec![true], test_state.boolean); assert_eq!(vec![true], test_state.boolean);
test_state.boolean.clear(); test_state.boolean.clear();
test_state.code = vec![Gene::Block(vec![Gene::GeneBoolean(false)])]; test_state.code = vec![Gene::Block(Box::new(vec![Gene::GeneBoolean(false)]))];
code_is_empty_block(&mut test_state); code_is_empty_block(&mut test_state);
assert_eq!(vec![false], test_state.boolean); assert_eq!(vec![false], test_state.boolean);
test_state.boolean.clear(); test_state.boolean.clear();
@ -1056,7 +1065,7 @@ mod tests {
test_state.boolean.clear(); test_state.boolean.clear();
let empty_vec: Vec<Gene> = Vec::new(); let empty_vec: Vec<Gene> = Vec::new();
test_state.exec = vec![Gene::Block(empty_vec.clone())]; test_state.exec = vec![Gene::Block(Box::new(empty_vec.clone()))];
exec_is_empty_block(&mut test_state); exec_is_empty_block(&mut test_state);
assert_eq!(vec![true], test_state.boolean); assert_eq!(vec![true], test_state.boolean);
} }
@ -1070,10 +1079,10 @@ mod tests {
assert_eq!(vec![1], test_state.int); assert_eq!(vec![1], test_state.int);
test_state.int.clear(); test_state.int.clear();
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneBoolean(false), Gene::GeneBoolean(false),
Gene::GeneInt(42), Gene::GeneInt(42),
])]; ]))];
code_size(&mut test_state); code_size(&mut test_state);
assert_eq!(vec![2], test_state.int); assert_eq!(vec![2], test_state.int);
} }
@ -1082,17 +1091,17 @@ mod tests {
fn extract_test() { fn extract_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
let test_code = vec![Gene::Block(vec![ let test_code = vec![Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
Gene::Block(vec![Gene::GeneString(vec!['t'])]), Gene::Block(Box::new(vec![Gene::GeneString(vec!['t'])])),
]), ])),
Gene::GeneInt(10), Gene::GeneInt(10),
Gene::Block(vec![Gene::GeneBoolean(false)]), Gene::Block(Box::new(vec![Gene::GeneBoolean(false)])),
])]; ]))];
test_state.code = test_code.clone(); test_state.code = test_code.clone();
test_state.int = vec![0]; test_state.int = vec![0];
@ -1113,7 +1122,7 @@ mod tests {
test_state.int = vec![9]; test_state.int = vec![9];
code_extract(&mut test_state); code_extract(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![Gene::GeneBoolean(false)])], vec![Gene::Block(Box::new(vec![Gene::GeneBoolean(false)]))],
test_state.code test_state.code
); );
} }
@ -1124,47 +1133,47 @@ mod tests {
test_state.code = vec![ test_state.code = vec![
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![Gene::GeneInt(1), Gene::GeneInt(1)]), Gene::Block(Box::new(vec![Gene::GeneInt(1), Gene::GeneInt(1)])),
]), ])),
]; ];
test_state.int = vec![1]; test_state.int = vec![1];
let inserted_block = vec![Gene::Block(vec![ let inserted_block = vec![Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::Block(vec![Gene::GeneInt(1), Gene::GeneInt(1)]), Gene::Block(Box::new(vec![Gene::GeneInt(1), Gene::GeneInt(1)])),
])]; ]))];
code_insert(&mut test_state); code_insert(&mut test_state);
assert_eq!(inserted_block, test_state.code); assert_eq!(inserted_block, test_state.code);
test_state.code = vec![ test_state.code = vec![
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
Gene::Block(vec![Gene::GeneString(vec!['t'])]), Gene::Block(Box::new(vec![Gene::GeneString(vec!['t'])])),
]), ])),
Gene::GeneInt(10), Gene::GeneInt(10),
Gene::Block(vec![Gene::GeneBoolean(false)]), Gene::Block(Box::new(vec![Gene::GeneBoolean(false)])),
]), ])),
]; ];
test_state.int = vec![4]; test_state.int = vec![4];
let inserted_block = vec![Gene::Block(vec![ let inserted_block = vec![Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
Gene::Block(vec![Gene::GeneString(vec!['t'])]), Gene::Block(Box::new(vec![Gene::GeneString(vec!['t'])])),
]), ])),
Gene::GeneInt(10), Gene::GeneInt(10),
Gene::Block(vec![Gene::GeneBoolean(false)]), Gene::Block(Box::new(vec![Gene::GeneBoolean(false)])),
])]; ]))];
code_insert(&mut test_state); code_insert(&mut test_state);
assert_eq!(inserted_block, test_state.code); assert_eq!(inserted_block, test_state.code);
} }
@ -1175,12 +1184,12 @@ mod tests {
test_state.code = vec![ test_state.code = vec![
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
]), ])),
]; ];
code_first_position(&mut test_state); code_first_position(&mut test_state);
assert_eq!(vec![2], test_state.int); assert_eq!(vec![2], test_state.int);
@ -1198,12 +1207,12 @@ mod tests {
test_state.code = vec![ test_state.code = vec![
Gene::GeneInt(-6), Gene::GeneInt(-6),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
]), ])),
]; ];
code_first_position(&mut test_state); code_first_position(&mut test_state);
assert_eq!(vec![-1], test_state.int); assert_eq!(vec![-1], test_state.int);
@ -1218,18 +1227,18 @@ mod tests {
code_reverse(&mut test_state); code_reverse(&mut test_state);
assert_eq!(vec![Gene::GeneInt(1)], test_state.code); assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
test_state.code = vec![Gene::Block(vec![ test_state.code = vec![Gene::Block(Box::new(vec![
Gene::GeneBoolean(false), Gene::GeneBoolean(false),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(20), Gene::GeneInt(20),
])]; ]))];
code_reverse(&mut test_state); code_reverse(&mut test_state);
assert_eq!( assert_eq!(
vec![Gene::Block(vec![ vec![Gene::Block(Box::new(vec![
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneBoolean(false), Gene::GeneBoolean(false),
])], ]))],
test_state.code test_state.code
); );
} }

6
src/instructions/common.rs
View File

@ -9,12 +9,6 @@ fn _noop<T>(_: Vec<T>) -> Option<T> {
make_instruction_clone!(code, code, _noop, Gene, 0); make_instruction_clone!(code, code, _noop, Gene, 0);
make_instruction_clone!(exec, exec, _noop, Gene, 0); make_instruction_clone!(exec, exec, _noop, Gene, 0);
fn _noop_block<T>(_: Vec<T>) -> Option<T> {
None
}
make_instruction_clone!(code, code, _noop_block, Gene, 0);
make_instruction_clone!(exec, exec, _noop_block, Gene, 0);
/// Pops the top value from the stack /// Pops the top value from the stack
fn _pop<T>(vals: Vec<T>) -> Option<T> fn _pop<T>(vals: Vec<T>) -> Option<T>
where where

13
src/instructions/logical.rs
View File

@ -76,6 +76,19 @@ where
} }
make_instruction_out!(float, boolean, _from_float, Decimal, 1); make_instruction_out!(float, boolean, _from_float, Decimal, 1);
pub fn boolean_instructions() -> Vec<fn(&mut PushState)> {
vec![
boolean_and,
boolean_or,
boolean_not,
boolean_xor,
boolean_invert_first_then_and,
boolean_invert_second_then_and,
boolean_from_int,
boolean_from_float,
]
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

366
src/instructions/mod.rs
View File

@ -1,10 +1,3 @@
use crate::instructions::code::*;
use crate::instructions::common::*;
use crate::instructions::logical::*;
use crate::instructions::numeric::*;
use crate::instructions::vector::*;
use crate::push::state::PushState;
#[macro_use] #[macro_use]
pub mod macros { pub mod macros {
/// A macro that makes a push instruction given: the name of the input stack to use, /// A macro that makes a push instruction given: the name of the input stack to use,
@ -89,7 +82,7 @@ pub mod macros {
paste::item! { paste::item! {
/// Runs the $fn_name function on the top $fn_arity items from /// Runs the $fn_name function on the top $fn_arity items from
/// the $in_stack and places the calculated value on the $out_stack. /// the $in_stack and places the calculated value on the $out_stack.
#[allow(clippy::reversed_empty_ranges, unused_comparisons)] #[allow(clippy::reversed_empty_ranges)]
pub fn [< $in_stack $fn_name >] (state: &mut PushState) { pub fn [< $in_stack $fn_name >] (state: &mut PushState) {
let in_stack_len = state.$in_stack.len(); let in_stack_len = state.$in_stack.len();
if in_stack_len < $fn_arity { if in_stack_len < $fn_arity {
@ -144,7 +137,6 @@ pub mod macros {
paste::item! { paste::item! {
/// Runs the $fn_name function on the top $fn_arity items from /// Runs the $fn_name function on the top $fn_arity items from
/// the $in_stack and places the calculated value on the $out_stack. /// the $in_stack and places the calculated value on the $out_stack.
#[allow(unused_comparisons)]
pub fn [< $in_stack $fn_name >] (state: &mut PushState) { pub fn [< $in_stack $fn_name >] (state: &mut PushState) {
let in_stack_len = state.$in_stack.len(); let in_stack_len = state.$in_stack.len();
if in_stack_len < $fn_arity { if in_stack_len < $fn_arity {
@ -272,359 +264,3 @@ pub mod logical;
pub mod numeric; pub mod numeric;
pub mod utils; pub mod utils;
pub mod vector; pub mod vector;
// unsure how to procedurally read a file and put all functions
// into a vector. Probably need to use procedural macros, but I'm not there yet.
pub fn int_instructions() -> Vec<fn(&mut PushState)> {
vec![
// numeric.rs
int_add,
int_sub,
int_mult,
int_div,
int_rem,
int_max,
int_min,
int_inc,
int_dec,
int_lt,
int_gt,
int_lte,
int_gte,
int_sin,
int_arcsin,
int_cos,
int_arccos,
int_tan,
int_arctan,
int_from_float,
int_from_boolean,
int_log,
int_exp,
int_sqrt,
int_inv,
int_abs,
int_sign_reverse,
int_square,
// common.rs
int_pop,
]
}
pub fn float_instructions() -> Vec<fn(&mut PushState)> {
vec![
// numeric
float_add,
float_sub,
float_mult,
float_div,
float_rem,
float_max,
float_min,
float_inc,
float_dec,
float_lt,
float_gt,
float_lte,
float_gte,
float_sin,
float_arcsin,
float_cos,
float_arccos,
float_tan,
float_arctan,
float_from_int,
float_from_boolean,
float_log,
float_exp,
float_sqrt,
float_inv,
float_abs,
float_sign_reverse,
float_square,
// common.rs
float_pop,
]
}
pub fn string_instructions() -> Vec<fn(&mut PushState)> {
vec![
// numeric.rs
string_concat,
string_conj,
string_conj_end,
string_take_n,
string_take_last_n,
string_sub,
string_first,
string_from_first_prim,
string_from_prim,
string_last,
string_from_last_prim,
string_nth,
string_from_nth_prim,
string_rest,
string_but_last,
string_drop,
string_length,
string_reverse,
string_push_all,
string_make_empty,
string_is_empty,
string_contains,
string_index_of,
string_occurrences_of,
string_set_nth,
string_replace,
// common.rs
string_pop,
]
}
pub fn boolean_instructions() -> Vec<fn(&mut PushState)> {
vec![
// logical.rs
boolean_and,
boolean_or,
boolean_not,
boolean_xor,
boolean_invert_first_then_and,
boolean_invert_second_then_and,
boolean_from_int,
boolean_from_float,
// common.rs
boolean_pop,
]
}
pub fn char_instructions() -> Vec<fn(&mut PushState)> {
vec![
// common.rs
char_pop,
]
}
pub fn vector_int_instructions() -> Vec<fn(&mut PushState)> {
vec![
// vector.rs
vector_int_concat,
vector_int_conj,
vector_int_conj_end,
vector_int_take_n,
vector_int_take_last_n,
vector_int_sub,
vector_int_first,
vector_int_from_first_prim,
vector_int_from_prim,
vector_int_last,
vector_int_from_last_prim,
vector_int_nth,
vector_int_from_nth_prim,
vector_int_rest,
vector_int_but_last,
vector_int_drop,
vector_int_length,
vector_int_reverse,
vector_int_push_all,
vector_int_make_empty,
vector_int_is_empty,
vector_int_contains,
vector_int_index_of,
vector_int_occurrences_of,
vector_int_set_nth,
vector_int_replace,
// common.rs
vector_int_pop,
]
}
pub fn vector_float_instructions() -> Vec<fn(&mut PushState)> {
vec![
// vector.rs
vector_float_concat,
vector_float_conj,
vector_float_conj_end,
vector_float_take_n,
vector_float_take_last_n,
vector_float_sub,
vector_float_first,
vector_float_from_first_prim,
vector_float_from_prim,
vector_float_last,
vector_float_from_last_prim,
vector_float_nth,
vector_float_from_nth_prim,
vector_float_rest,
vector_float_but_last,
vector_float_drop,
vector_float_length,
vector_float_reverse,
vector_float_push_all,
vector_float_make_empty,
vector_float_is_empty,
vector_float_contains,
vector_float_index_of,
vector_float_occurrences_of,
vector_float_set_nth,
vector_float_replace,
// common.rs
vector_float_pop,
]
}
pub fn vector_string_instructions() -> Vec<fn(&mut PushState)> {
vec![
// vector.rs
vector_string_concat,
vector_string_conj,
vector_string_conj_end,
vector_string_take_n,
vector_string_take_last_n,
vector_string_sub,
vector_string_first,
vector_string_from_first_prim,
vector_string_from_prim,
vector_string_last,
vector_string_from_last_prim,
vector_string_nth,
vector_string_from_nth_prim,
vector_string_rest,
vector_string_but_last,
vector_string_drop,
vector_string_length,
vector_string_reverse,
vector_string_make_empty,
vector_string_is_empty,
vector_string_contains,
vector_string_index_of,
vector_string_occurrences_of,
vector_string_set_nth,
vector_string_replace,
// common.rs
vector_string_pop,
]
}
pub fn vector_boolean_instructions() -> Vec<fn(&mut PushState)> {
vec![
// vector.rs
vector_boolean_concat,
vector_boolean_conj,
vector_boolean_conj_end,
vector_boolean_take_n,
vector_boolean_take_last_n,
vector_boolean_sub,
vector_boolean_first,
vector_boolean_from_first_prim,
vector_boolean_from_prim,
vector_boolean_last,
vector_boolean_from_last_prim,
vector_boolean_nth,
vector_boolean_from_nth_prim,
vector_boolean_rest,
vector_boolean_but_last,
vector_boolean_drop,
vector_boolean_length,
vector_boolean_reverse,
vector_boolean_push_all,
vector_boolean_make_empty,
vector_boolean_is_empty,
vector_boolean_contains,
vector_boolean_index_of,
vector_boolean_occurrences_of,
vector_boolean_set_nth,
vector_boolean_replace,
// common.rs
vector_boolean_pop,
]
}
pub fn vector_char_instructions() -> Vec<fn(&mut PushState)> {
vec![
// vector.rs
vector_char_concat,
vector_char_conj,
vector_char_conj_end,
vector_char_take_n,
vector_char_take_last_n,
vector_char_sub,
vector_char_first,
vector_char_from_first_prim,
vector_char_from_prim,
vector_char_last,
vector_char_from_last_prim,
vector_char_nth,
vector_char_from_nth_prim,
vector_char_rest,
vector_char_but_last,
vector_char_drop,
vector_char_length,
vector_char_reverse,
vector_char_push_all,
vector_char_make_empty,
vector_char_is_empty,
vector_char_contains,
vector_char_index_of,
vector_char_occurrences_of,
vector_char_set_nth,
vector_char_replace,
// common.rs
vector_char_pop,
]
}
pub fn exec_instructions() -> Vec<fn(&mut PushState)> {
vec![
// code.rs
exec_do_range,
exec_do_count,
exec_do_times,
exec_while,
exec_do_while,
exec_if,
exec_when,
exec_make_empty_block,
exec_is_empty_block,
exec_size,
// common.rs
exec_noop,
exec_noop_block,
exec_pop,
]
}
pub fn code_instructions() -> Vec<fn(&mut PushState)> {
vec![
// code.rs
code_is_block,
code_is_singular,
code_length,
code_first,
code_last,
code_rest,
code_but_last,
code_wrap_block,
code_combine,
code_do_then_pop,
code_do_range,
code_do_count,
code_do_times,
code_map,
code_if,
code_when,
code_member,
code_nth,
code_make_empty_block,
code_is_empty_block,
code_size,
code_extract,
code_insert,
code_insert,
code_first_position,
code_reverse,
// common.rs
code_noop,
code_noop_block,
code_pop,
code_from_int,
code_from_float,
code_from_string,
code_from_boolean,
code_from_char,
code_from_vector_int,
code_from_vector_float,
code_from_vector_string,
code_from_vector_boolean,
code_from_vector_char,
code_from_exec,
]
}

69
src/instructions/numeric.rs
View File

@ -303,6 +303,75 @@ where
make_instruction!(int, int, _square, i128, 1); make_instruction!(int, int, _square, i128, 1);
make_instruction!(float, float, _square, Decimal, 1); make_instruction!(float, float, _square, Decimal, 1);
/// A list of all of the defined int functions in this file.
/// Must manually register functions in this list if added.
pub fn int_instructions() -> Vec<fn(&mut PushState)> {
vec![
int_add,
int_sub,
int_mult,
int_div,
int_rem,
int_max,
int_min,
int_inc,
int_dec,
int_lt,
int_gt,
int_lte,
int_gte,
int_sin,
int_arcsin,
int_cos,
int_arccos,
int_tan,
int_arctan,
int_from_float,
int_from_boolean,
int_log,
int_exp,
int_sqrt,
int_inv,
int_abs,
int_sign_reverse,
int_square,
]
}
/// All of the float instructions declared in this file.
pub fn float_instructions() -> Vec<fn(&mut PushState)> {
vec![
float_add,
float_sub,
float_mult,
float_div,
float_rem,
float_max,
float_min,
float_inc,
float_dec,
float_lt,
float_gt,
float_lte,
float_gte,
float_sin,
float_arcsin,
float_cos,
float_arccos,
float_tan,
float_arctan,
float_from_int,
float_from_boolean,
float_log,
float_exp,
float_sqrt,
float_inv,
float_abs,
float_sign_reverse,
float_square,
]
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

1
src/instructions/vector.rs
View File

@ -1326,6 +1326,7 @@ mod tests {
#[test] #[test]
fn contains_test() { fn contains_test() {
let mut test_state = EMPTY_STATE; let mut test_state = EMPTY_STATE;
let empty_vec: Vec<i128> = vec![];
test_state.vector_int = vec![vec![0, 1, 2, 3, 4, 5]]; test_state.vector_int = vec![vec![0, 1, 2, 3, 4, 5]];
test_state.int = vec![2]; test_state.int = vec![2];

69
src/main.rs
View File

@ -1,24 +1,57 @@
use crate::instructions::*; use crate::instructions::vector::_replace;
use crate::push::interpreter::interpret_program; use crate::push::state::{EMPTY_STATE, PushState};
use crate::push::state::EMPTY_STATE; use instructions::utils::NumericTrait;
use rust_decimal::MathematicalOps;
use rust_decimal::prelude::*;
mod instructions; mod instructions;
mod push; mod push;
fn test_func() {}
fn another_test_func() {}
fn main() { fn main() {
// These need to stay so linter doesn't go crazy. // let sixth_pi = Decimal::PI / dec!(6.0);
int_instructions(); // let result = dec!(1).sin();
float_instructions(); // let result = Decimal::PI.sin().checked_div(Decimal::PI.cos());
string_instructions(); // let result = dec!(1.0) / Decimal::HALF_PI.sin();
boolean_instructions(); // let result = sixth_pi.sin();
char_instructions(); // let result = Decimal::HALF_PI.cos();
vector_int_instructions(); // let result = Decimal::PI.sin();
vector_float_instructions(); // let result = Decimal::PI.tan();
vector_string_instructions(); // let result = dec!(1.0) / Decimal::QUARTER_PI.tan();
vector_boolean_instructions(); // let result = dec!(1.0) / Decimal::QUARTER_PI.cos();
vector_char_instructions(); // let result = dec!(1.2).checked_exp();
exec_instructions(); // let result = dec!(2).log10();
code_instructions(); /*let result = vec![0, 1, 2];
let mut empty_state = EMPTY_STATE; let r_len = result.len();
interpret_program(&mut empty_state, 1000, 1000); let fin_result = &result[..r_len - 1];
println!("{fin_result:?}");*/
// println!("{result:?}");
// println!("{sixth_pi}");
// casting a function call to a usize is a way to
// test for function equality.
// let test_func_result = test_func as usize == test_func as usize;
// println!("{test_func_result}");
//let temp_vec = vec![0, 1, 2, 3];
//temp_vec[0..9].to_vec();
//let res = 3 % 2;
//println!("res is {res}");
//let mut test_vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
//test_vec.drain(..15);
//println!("{:?}", test_vec);
//let test_state = EMPTY_STATE;
//println!("{}", test_state.int == test_state.boolean);
/*println!(
"{}",
std::any::type_name::<PushState>() == std::any::type_name::<PushState>()
);*/
let temp: Option<Vec<i128>> = _replace(vec![vec![1, 2, 3]], vec![1, 2]);
} }

58
src/push/interpreter.rs
View File

@ -26,50 +26,15 @@ pub fn gene_to_stack(state: &mut PushState, gene: Gene) {
} }
} }
/// Ensures the stacks don't go over a set size. Removes the oldest values first.
/// Unsure how to make this function prettier yet.
macro_rules! ensure_boundaries {
($state:expr, $max_stack_size:expr, $stack:ident) => {
if $state.$stack.len() > $max_stack_size {
$state
.$stack
.drain(0..($state.$stack.len() - $max_stack_size));
}
};
($state:expr, $max_stack_size:expr, $stack:ident, $($other_stacks:ident), +) => {
if $state.$stack.len() > $max_stack_size {
$state
.$stack
.drain(0..($state.$stack.len() - $max_stack_size));
}
ensure_boundaries!($state, $max_stack_size, $($other_stacks), +);
};
}
/// Where a push program's exec stack is interpreted to completion. /// Where a push program's exec stack is interpreted to completion.
/// TODO: Decide where to place loading in a push program. /// TODO: Decide where to place loading in a push program.
pub fn interpret_program(state: &mut PushState, step_limit: usize, max_stack_size: usize) { pub fn interpret_program(state: &mut PushState, step_limit: usize, max_stack_size: usize) {
let mut steps: usize = 0; let mut steps: usize = 0;
while !state.exec.is_empty() && steps < step_limit { while state.exec.len() > 0 && steps < step_limit {
if let Some(gene) = state.exec.pop() { if let Some(gene) = state.exec.pop() {
gene_to_stack(state, gene); gene_to_stack(state, gene);
steps += 1; steps += 1;
} }
// If adding any more stacks in the future, must be added to this list
ensure_boundaries!(
state,
max_stack_size,
int,
float,
string,
boolean,
char,
vector_int,
vector_float,
vector_string,
vector_boolean,
vector_char
);
} }
} }
@ -161,14 +126,20 @@ mod tests {
); );
test_state.vector_char.clear(); test_state.vector_char.clear();
let test_block: Gene = Gene::Block(vec![ let test_block: Gene = Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneFloat(dec!(2.3)), Gene::GeneFloat(dec!(2.3)),
Gene::StateFunc(int_add), Gene::StateFunc(int_add),
]); ]));
test_state.exec.push(Gene::GeneInt(2)); test_state.exec.push(Gene::GeneInt(2));
gene_to_stack(&mut test_state, test_block); gene_to_stack(&mut test_state, test_block);
assert_eq!( assert_eq!(
//vec![
// Gene::GeneInt(2),
// Gene::GeneInt(1),
// Gene::GeneFloat(dec!(2.3)),
// Gene::StateFunc(int_add)
//],
vec![ vec![
Gene::GeneInt(2), Gene::GeneInt(2),
Gene::StateFunc(int_add), Gene::StateFunc(int_add),
@ -195,15 +166,4 @@ mod tests {
interpret_program(&mut test_state, 1000, 1000); interpret_program(&mut test_state, 1000, 1000);
assert_eq!(vec![9], test_state.int); assert_eq!(vec![9], test_state.int);
} }
#[test]
fn boundary_test() {
let mut test_state = EMPTY_STATE;
test_state.int = vec![1, 2, 3, 4, 5];
test_state.char = vec!['a', 'b', 'c', 'd', 'f', 'z', 'g'];
ensure_boundaries!(test_state, 3, int, char);
assert_eq!(vec!['f', 'z', 'g'], test_state.char);
assert_eq!(vec![3, 4, 5], test_state.int);
}
} }

59
src/push/state.rs
View File

@ -36,7 +36,6 @@ pub const EMPTY_STATE: PushState = PushState {
}; };
#[derive(PartialEq, Eq, Debug, Clone)] #[derive(PartialEq, Eq, Debug, Clone)]
#[allow(dead_code)] // remove this later. Is here bc Close, Skip, CrossoverPadding
pub enum Gene { pub enum Gene {
GeneInt(i128), GeneInt(i128),
GeneFloat(Decimal), GeneFloat(Decimal),
@ -52,7 +51,7 @@ pub enum Gene {
Close, Close,
Open(u8), Open(u8),
Skip, Skip,
Block(Vec<Gene>), Block(Box<Vec<Gene>>),
CrossoverPadding, CrossoverPadding,
} }
@ -158,66 +157,66 @@ mod tests {
#[test] #[test]
fn rec_len_test() { fn rec_len_test() {
let block = Gene::Block(vec![ let block = Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![Gene::GeneInt(1), Gene::GeneInt(1)]), Gene::Block(Box::new(vec![Gene::GeneInt(1), Gene::GeneInt(1)])),
]); ]));
assert_eq!(4, block.rec_len()); assert_eq!(4, block.rec_len());
let block = Gene::Block(vec![ let block = Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
Gene::Block(vec![Gene::GeneString(vec!['t'])]), Gene::Block(Box::new(vec![Gene::GeneString(vec!['t'])])),
]), ])),
Gene::GeneInt(10), Gene::GeneInt(10),
Gene::Block(vec![Gene::GeneBoolean(false)]), Gene::Block(Box::new(vec![Gene::GeneBoolean(false)])),
]); ]));
assert_eq!(10, block.rec_len()); assert_eq!(10, block.rec_len());
let block = Gene::Block(vec![]); let block = Gene::Block(Box::new(vec![]));
assert_eq!(0, block.rec_len()); assert_eq!(0, block.rec_len());
} }
#[test] #[test]
fn insert_test() { fn insert_test() {
let mut block = Gene::Block(vec![ let mut block = Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![Gene::GeneInt(1), Gene::GeneInt(1)]), Gene::Block(Box::new(vec![Gene::GeneInt(1), Gene::GeneInt(1)])),
]); ]));
let inserted_block = Gene::Block(vec![ let inserted_block = Gene::Block(Box::new(vec![
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::Block(vec![Gene::GeneInt(1), Gene::GeneInt(1)]), Gene::Block(Box::new(vec![Gene::GeneInt(1), Gene::GeneInt(1)])),
]); ]));
block.with_code_inserted_at_point(Gene::GeneInt(20), 1); block.with_code_inserted_at_point(Gene::GeneInt(20), 1);
assert_eq!(inserted_block, block); assert_eq!(inserted_block, block);
let mut block = Gene::Block(vec![ let mut block = Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
Gene::Block(vec![Gene::GeneString(vec!['t'])]), Gene::Block(Box::new(vec![Gene::GeneString(vec!['t'])])),
]), ])),
Gene::GeneInt(10), Gene::GeneInt(10),
Gene::Block(vec![Gene::GeneBoolean(false)]), Gene::Block(Box::new(vec![Gene::GeneBoolean(false)])),
]); ]));
let inserted_block = Gene::Block(vec![ let inserted_block = Gene::Block(Box::new(vec![
Gene::GeneBoolean(true), Gene::GeneBoolean(true),
Gene::GeneInt(1), Gene::GeneInt(1),
Gene::Block(vec![ Gene::Block(Box::new(vec![
Gene::GeneInt(4), Gene::GeneInt(4),
Gene::GeneInt(20), Gene::GeneInt(20),
Gene::GeneFloat(dec!(6.0)), Gene::GeneFloat(dec!(6.0)),
Gene::Block(vec![Gene::GeneString(vec!['t'])]), Gene::Block(Box::new(vec![Gene::GeneString(vec!['t'])])),
]), ])),
Gene::GeneInt(10), Gene::GeneInt(10),
Gene::Block(vec![Gene::GeneBoolean(false)]), Gene::Block(Box::new(vec![Gene::GeneBoolean(false)])),
]); ]));
block.with_code_inserted_at_point(Gene::GeneInt(20), 4); block.with_code_inserted_at_point(Gene::GeneInt(20), 4);
assert_eq!(inserted_block, block); assert_eq!(inserted_block, block);
} }