1use std::collections::VecDeque;
2use std::ops::Deref;
3use std::ptr;
4use gc::Gc;
5use crate::interpreter::data::{DataObject, DataObjectRef, DataType, DataValue, OptionDataObjectRef, StructObject};
6use crate::interpreter::{conversions, Interpreter, InterpretingError};
7use crate::interpreter::data::function::FunctionPointerObject;
8use crate::interpreter::data::object::LangObject;
9use crate::lexer::CodePosition;
10use crate::utils;
11use crate::utils::math::SpecialDiv;
12
13fn call_operator_method_1_arg(
14 interpreter: &mut Interpreter,
15 operator_name: &str,
16 operand: &DataObjectRef,
17 pos: CodePosition,
18) -> OptionDataObjectRef {
19 call_operator_method(
20 interpreter,
21 operand,
22 &("op:".to_string() + operator_name),
23 &[],
24 pos,
25 )
26}
27
28fn call_operator_method_2_arg(
29 interpreter: &mut Interpreter,
30 operator_name: &str,
31 has_reverse: bool,
32 left_side_operand: &DataObjectRef,
33 right_side_operand: &DataObjectRef,
34 pos: CodePosition,
35) -> OptionDataObjectRef {
36 let ret = call_operator_method(
37 interpreter,
38 left_side_operand,
39 &("op:".to_string() + operator_name),
40 std::slice::from_ref(right_side_operand),
41 pos,
42 );
43
44 if ret.is_some() || !has_reverse {
45 return ret;
46 }
47
48 call_operator_method(
49 interpreter,
50 right_side_operand,
51 &("op:r-".to_string() + operator_name),
52 std::slice::from_ref(left_side_operand),
53 pos,
54 )
55}
56
57fn call_operator_method_3_arg(
58 interpreter: &mut Interpreter,
59 operator_name: &str,
60 left_side_operand: &DataObjectRef,
61 middle_operand: &DataObjectRef,
62 right_side_operand: &DataObjectRef,
63 pos: CodePosition,
64) -> OptionDataObjectRef {
65 call_operator_method(
66 interpreter,
67 left_side_operand,
68 &("op:".to_string() + operator_name),
69 &utils::separate_arguments_with_argument_separators(&[
70 middle_operand.clone(),
71 right_side_operand.clone(),
72 ]),
73 pos,
74 )
75}
76
77fn call_operator_method(
78 interpreter: &mut Interpreter,
79 lang_object: &DataObjectRef,
80 method_name: &str,
81 argument_list: &[DataObjectRef],
82 pos: CodePosition,
83) -> OptionDataObjectRef {
84 let lang_object = lang_object.object_value()?;
85
86 if lang_object.borrow().is_class() {
87 return None;
88 }
89
90 let method = lang_object.borrow().methods().get(method_name)?.clone();
91
92 let ret = interpreter.call_function_pointer(&method, Some(method_name), argument_list, pos);
93
94 Some(ret.unwrap_or_else(|| DataObjectRef::new(DataObject::new_void())))
95}
96
97pub fn op_len(
103 interpreter: &mut Interpreter,
104 operand: &DataObjectRef,
105 pos: CodePosition,
106) -> OptionDataObjectRef {
107 let ret = call_operator_method_1_arg(
108 interpreter,
109 "len",
110 operand,
111 pos,
112 );
113 if let Some(ret) = ret {
114 return Some(ret);
115 }
116
117 match &operand.data_value() {
118 DataValue::ByteBuffer(value) => {
119 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
120 data_object.set_int(value.borrow().len() as i32)
121 }).unwrap()))
122 },
123
124 DataValue::Array(value) => {
125 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
126 data_object.set_int(value.borrow().len() as i32)
127 }).unwrap()))
128 },
129
130 DataValue::List(value) => {
131 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
132 data_object.set_int(value.borrow().len() as i32)
133 }).unwrap()))
134 },
135
136 DataValue::Text(value) => {
137 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
138 data_object.set_int(value.chars().count() as i32)
139 }).unwrap()))
140 },
141
142 DataValue::Char(_) => {
143 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
144 data_object.set_int(1)
145 }).unwrap()))
146 },
147
148 DataValue::Struct(value) => {
149 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
150 data_object.set_int(value.member_names().len() as i32)
151 }).unwrap()))
152 },
153
154 _ => None,
155 }
156}
157pub fn op_deep_copy(
161 interpreter: &mut Interpreter,
162 operand: &DataObjectRef,
163 pos: CodePosition,
164) -> OptionDataObjectRef {
165 let ret = call_operator_method_1_arg(
166 interpreter,
167 "deepCopy",
168 operand,
169 pos,
170 );
171 if let Some(ret) = ret {
172 return Some(ret);
173 }
174
175 match &operand.data_value() {
176 DataValue::ByteBuffer(value) => {
177 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
178 data_object.set_byte_buffer(value.borrow().clone())
179 }).unwrap()))
180 },
181
182 DataValue::Array(value) => {
183 let arr_copy = value.borrow().iter().
184 map(|data_object| op_deep_copy(interpreter, data_object, pos)).
185 collect::<Option<_>>()?;
186
187 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
188 data_object.set_array(arr_copy)
189 }).unwrap()))
190 },
191
192 DataValue::List(value) => {
193 let list_copy = value.borrow().iter().
194 map(|data_object| op_deep_copy(interpreter, data_object, pos)).
195 collect::<Option<_>>()?;
196
197 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
198 data_object.set_list(list_copy)
199 }).unwrap()))
200 },
201
202 DataValue::Struct(value) => {
203 if value.is_definition() {
204 let member_names = value.member_names();
205 let members = member_names.iter().
206 zip(value.type_constraints()).
207 map(|(name, type_constraint)|
208 (name.deref(), type_constraint.map(|type_constraint|
209 *type_constraint))).
210 collect::<Vec<_>>();
211
212 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
213 data_object.set_struct(Gc::new(StructObject::new_definition(&members)))
214 }).unwrap()))
215 }else {
216 let base_definition = value.base_definition()?;
217
218 let member_values_copy = value.member_names().into_iter().
219 map(|member| {
220 let member = value.get_member(&member);
221 match member {
222 Ok(member) => Ok(op_deep_copy(interpreter, &member, pos)),
223 Err(e) => Err(e),
224 }
225 }).
226 collect::<Result<Option<Box<_>>, _>>();
227 let member_values_copy = match member_values_copy {
228 Ok(member_values_copy) => member_values_copy?,
229 Err(e) => {
230 return Some(interpreter.set_errno_error_object(
231 InterpretingError::IncompatibleDataType,
232 Some(e.message()),
233 pos,
234 ));
235 },
236 };
237
238 let struct_copy = StructObject::new_instance(
239 base_definition,
240 &member_values_copy,
241 );
242 let struct_copy = match struct_copy {
243 Ok(struct_copy) => struct_copy,
244 Err(e) => {
245 return Some(interpreter.set_errno_error_object(
246 InterpretingError::IncompatibleDataType,
247 Some(e.message()),
248 pos,
249 ));
250 },
251 };
252
253 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
254 data_object.set_struct(Gc::new(struct_copy))
255 }).unwrap()))
256 }
257 },
258
259 DataValue::Object(_) => None,
260
261 _ => Some(DataObjectRef::new(DataObject::with_update(|data_object| {
262 data_object.set_data(&operand.borrow())
263 }).unwrap())),
264 }
265}
266pub fn op_concat(
270 interpreter: &mut Interpreter,
271 left_side_operand: &DataObjectRef,
272 right_side_operand: &DataObjectRef,
273 pos: CodePosition,
274) -> OptionDataObjectRef {
275 let ret = call_operator_method_2_arg(
276 interpreter,
277 "concat",
278 true,
279 left_side_operand,
280 right_side_operand,
281 pos,
282 );
283 if let Some(ret) = ret {
284 return Some(ret);
285 }
286
287 match &left_side_operand.data_value() {
288 DataValue::Int(left_value) => {
289 Some(DataObjectRef::new(DataObject::new_text(format!(
290 "{left_value}{}",
291 conversions::to_text(interpreter, right_side_operand, pos),
292 ))))
293 },
294
295 DataValue::Long(left_value) => {
296 Some(DataObjectRef::new(DataObject::new_text(format!(
297 "{left_value}{}",
298 conversions::to_text(interpreter, right_side_operand, pos),
299 ))))
300 },
301
302 DataValue::Float(left_value) => {
303 Some(DataObjectRef::new(DataObject::new_text(format!(
304 "{left_value}{}",
305 conversions::to_text(interpreter, right_side_operand, pos),
306 ))))
307 },
308
309 DataValue::Double(left_value) => {
310 Some(DataObjectRef::new(DataObject::new_text(format!(
311 "{left_value}{}",
312 conversions::to_text(interpreter, right_side_operand, pos),
313 ))))
314 },
315
316 DataValue::Char(left_value) => {
317 Some(DataObjectRef::new(DataObject::new_text(format!(
318 "{left_value}{}",
319 conversions::to_text(interpreter, right_side_operand, pos),
320 ))))
321 },
322
323 DataValue::Text(left_value) => {
324 Some(DataObjectRef::new(DataObject::new_text(format!(
325 "{left_value}{}",
326 conversions::to_text(interpreter, right_side_operand, pos),
327 ))))
328 },
329
330 DataValue::ByteBuffer(left_value) => {
331 let right_value = right_side_operand.byte_buffer_value()?;
332
333 let left_len = left_value.borrow().len();
334 let mut new_byte_buf = vec![0; left_len + right_value.borrow().len()];
335 new_byte_buf[..left_len].copy_from_slice(&left_value.borrow());
336 new_byte_buf[left_len..].copy_from_slice(&right_value.borrow());
337
338 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
339 data_object.set_byte_buffer(new_byte_buf.into_boxed_slice())
340 }).unwrap()))
341 },
342
343 DataValue::Array(left_value) => {
344 if let Some(right_value) = right_side_operand.array_value() {
345 let mut new_array = Vec::with_capacity(left_value.borrow().len() + right_value.borrow().len());
346 new_array.extend_from_slice(&left_value.borrow());
347 new_array.extend_from_slice(&right_value.borrow());
348
349 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
350 data_object.set_array(new_array.into_boxed_slice())
351 }).unwrap()))
352 }else if let Some(right_value) = right_side_operand.list_value() {
353 let mut new_array = Vec::with_capacity(left_value.borrow().len() + right_value.borrow().len());
354 new_array.extend_from_slice(&left_value.borrow());
355 {
356 let right_value = right_value.borrow();
357 let right_value_slices = right_value.as_slices();
358 new_array.extend_from_slice(right_value_slices.0);
359 new_array.extend_from_slice(right_value_slices.1);
360 }
361
362 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
363 data_object.set_array(new_array.into_boxed_slice())
364 }).unwrap()))
365 }else {
366 None
367 }
368 },
369
370 DataValue::List(left_value) => {
371 if let Some(right_value) = right_side_operand.array_value() {
372 let mut new_array = VecDeque::with_capacity(left_value.borrow().len() + right_value.borrow().len());
373 new_array.extend(left_value.borrow().iter().cloned());
374 new_array.extend(right_value.borrow().iter().cloned());
375
376 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
377 data_object.set_list(new_array)
378 }).unwrap()))
379 }else if let Some(right_value) = right_side_operand.list_value() {
380 let mut new_array = VecDeque::with_capacity(left_value.borrow().len() + right_value.borrow().len());
381 new_array.extend(left_value.borrow().iter().cloned());
382 new_array.extend(right_value.borrow().iter().cloned());
383
384 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
385 data_object.set_list(new_array)
386 }).unwrap()))
387 }else {
388 None
389 }
390 },
391
392 DataValue::FunctionPointer(left_value) => {
393 let left_value = left_value.clone();
394 let right_value = right_side_operand.function_pointer_value()?;
395
396 let function_name = format!("<concat-func({left_value}, {right_value})>");
397
398 let left_side_operand = left_side_operand.clone();
399 let right_side_operand = right_side_operand.clone();
400 let concat_func = {
401 let left_side_operand = left_side_operand.clone();
402 let right_side_operand = right_side_operand.clone();
403
404 move |interpreter: &mut Interpreter, args: Vec<DataObjectRef>| -> OptionDataObjectRef {
405 let ret_a = interpreter.call_function_pointer(
406 &left_value,
407 left_side_operand.variable_name().as_deref(),
408 &args,
409 CodePosition::EMPTY,
410 );
411
412 interpreter.call_function_pointer(
413 &right_value,
414 right_side_operand.variable_name().as_deref(),
415 &[utils::none_to_lang_void(ret_a)],
416 CodePosition::EMPTY,
417 )
418 }
419 };
420 let func = FunctionPointerObject::from(crate::lang_func!(
421 concat_func,
422 vec![
423 Box::new(left_side_operand),
424 Box::new(right_side_operand),
425 ],
426 crate::lang_func_metadata!(
427 name="concat-func",
428 parameter(
429 name="&args",
430 parameter_type(raw_var_args),
431 ),
432 ),
433 )).copy_with_function_name(&function_name);
434
435 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
436 data_object.set_function_pointer(Gc::new(func))
437 }).unwrap()))
438 },
439
440 _ => None,
441 }
442}
443pub fn op_spaceship(
447 interpreter: &mut Interpreter,
448 left_side_operand: &DataObjectRef,
449 right_side_operand: &DataObjectRef,
450 pos: CodePosition,
451) -> OptionDataObjectRef {
452 if is_less_than(interpreter, left_side_operand, right_side_operand, pos) {
453 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
454 data_object.set_int(-1)
455 }).unwrap()))
456 }else if is_equals(interpreter, left_side_operand, right_side_operand, pos) {
457 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
458 data_object.set_int(0)
459 }).unwrap()))
460 }else if is_greater_than(interpreter, left_side_operand, right_side_operand, pos) {
461 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
462 data_object.set_int(1)
463 }).unwrap()))
464 }else {
465 Some(DataObjectRef::new(DataObject::new()))
466 }
467}
468
469pub fn op_inc(
475 interpreter: &mut Interpreter,
476 operand: &DataObjectRef,
477 pos: CodePosition,
478) -> OptionDataObjectRef {
479 let ret = call_operator_method_1_arg(
480 interpreter,
481 "inc",
482 operand,
483 pos,
484 );
485 if let Some(ret) = ret {
486 return Some(ret);
487 }
488
489 match &operand.data_value() {
490 DataValue::Int(value) => {
491 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
492 data_object.set_int(value.wrapping_add(1))
493 }).unwrap()))
494 },
495
496 DataValue::Long(value) => {
497 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
498 data_object.set_long(value.wrapping_add(1))
499 }).unwrap()))
500 },
501
502 DataValue::Float(value) => {
503 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
504 data_object.set_float(value + 1.0)
505 }).unwrap()))
506 },
507
508 DataValue::Double(value) => {
509 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
510 data_object.set_double(value + 1.0)
511 }).unwrap()))
512 },
513
514 DataValue::Char(value) => {
515 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
516 data_object.set_char(char::from_u32((*value as u32).wrapping_add(1)).unwrap_or('\u{FFFD}'))
517 }).unwrap()))
518 },
519
520 DataValue::FunctionPointer(value) => {
521 let value = value.clone();
522 let function_name = format!("<auto-unpack-func({value}>");
523
524 let operand = operand.clone();
525 let auto_unpack_func = {
526 let operand = operand.clone();
527
528 move |interpreter: &mut Interpreter, array_object: DataObjectRef| -> OptionDataObjectRef {
529 let argument_list = array_object.array_value().unwrap().borrow().iter().
530 map(|ele| DataObjectRef::new(DataObject::with_update(|data_object| {
531 data_object.set_data(&ele.borrow())
532 }).unwrap())).
533 collect::<Box<_>>();
534
535 interpreter.call_function_pointer(
536 &value,
537 operand.variable_name().as_deref(),
538 &utils::separate_arguments_with_argument_separators(&argument_list),
539 CodePosition::EMPTY,
540 )
541 }
542 };
543 let func = FunctionPointerObject::from(crate::lang_func!(
544 auto_unpack_func,
545 vec![
546 Box::new(operand),
547 ],
548 crate::lang_func_metadata!(
549 name="auto-unpack-func",
550 parameter(
551 name="&array",
552 type_constraint(
553 allowed=["ARRAY"]
554 ),
555 ),
556 ),
557 )).copy_with_function_name(&function_name);
558
559 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
560 data_object.set_function_pointer(Gc::new(func))
561 }).unwrap()))
562 },
563
564 _ => None,
565 }
566}
567pub fn op_dec(
571 interpreter: &mut Interpreter,
572 operand: &DataObjectRef,
573 pos: CodePosition,
574) -> OptionDataObjectRef {
575 let ret = call_operator_method_1_arg(
576 interpreter,
577 "dec",
578 operand,
579 pos,
580 );
581 if let Some(ret) = ret {
582 return Some(ret);
583 }
584
585 match &operand.data_value() {
586 DataValue::Int(value) => {
587 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
588 data_object.set_int(value.wrapping_sub(1))
589 }).unwrap()))
590 },
591
592 DataValue::Long(value) => {
593 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
594 data_object.set_long(value.wrapping_sub(1))
595 }).unwrap()))
596 },
597
598 DataValue::Float(value) => {
599 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
600 data_object.set_float(value - 1.0)
601 }).unwrap()))
602 },
603
604 DataValue::Double(value) => {
605 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
606 data_object.set_double(value - 1.0)
607 }).unwrap()))
608 },
609
610 DataValue::Char(value) => {
611 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
612 data_object.set_char(char::from_u32((*value as u32).wrapping_sub(1)).unwrap_or('\u{FFFD}'))
613 }).unwrap()))
614 },
615
616 DataValue::FunctionPointer(value) => {
617 let value = value.clone();
618 let function_name = format!("<auto-pack-func({value}>");
619
620 let operand = operand.clone();
621 let auto_pack_func = {
622 let operand = operand.clone();
623
624 move |interpreter: &mut Interpreter, args: Vec<DataObjectRef>| -> OptionDataObjectRef {
625 let array = args.iter().
626 map(|ele| DataObjectRef::new(DataObject::with_update(|data_object| {
627 data_object.set_data(&ele.borrow())
628 }).unwrap())).
629 collect::<Box<_>>();
630
631 let array_value = DataObjectRef::new(DataObject::with_update(|data_object| {
632 data_object.set_array(array)
633 }).unwrap());
634
635 interpreter.call_function_pointer(
636 &value,
637 operand.variable_name().as_deref(),
638 &[array_value],
639 CodePosition::EMPTY,
640 )
641 }
642 };
643 let func = FunctionPointerObject::from(crate::lang_func!(
644 auto_pack_func,
645 vec![
646 Box::new(operand),
647 ],
648 crate::lang_func_metadata!(
649 name="auto-pack-func",
650 parameter(
651 name="&args",
652 parameter_type(var_args),
653 ),
654 ),
655 )).copy_with_function_name(&function_name);
656
657 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
658 data_object.set_function_pointer(Gc::new(func))
659 }).unwrap()))
660 },
661
662 _ => None,
663 }
664}
665pub fn op_pos(
669 interpreter: &mut Interpreter,
670 operand: &DataObjectRef,
671 pos: CodePosition,
672) -> OptionDataObjectRef {
673 let ret = call_operator_method_1_arg(
674 interpreter,
675 "pos",
676 operand,
677 pos,
678 );
679 if let Some(ret) = ret {
680 return Some(ret);
681 }
682
683 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
684 data_object.set_data(&operand.borrow())
685 }).unwrap()))
686}
687pub fn op_inv(
691 interpreter: &mut Interpreter,
692 operand: &DataObjectRef,
693 pos: CodePosition,
694) -> OptionDataObjectRef {
695 let ret = call_operator_method_1_arg(
696 interpreter,
697 "inv",
698 operand,
699 pos,
700 );
701 if let Some(ret) = ret {
702 return Some(ret);
703 }
704
705 match &operand.data_value() {
706 DataValue::Int(value) => {
707 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
708 data_object.set_int(value.wrapping_neg())
709 }).unwrap()))
710 },
711
712 DataValue::Long(value) => {
713 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
714 data_object.set_long(value.wrapping_neg())
715 }).unwrap()))
716 },
717
718 DataValue::Float(value) => {
719 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
720 data_object.set_float(-value)
721 }).unwrap()))
722 },
723
724 DataValue::Double(value) => {
725 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
726 data_object.set_double(-value)
727 }).unwrap()))
728 },
729
730 DataValue::Text(value) => {
731 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
732 data_object.set_text(value.chars().rev().collect::<Box<_>>())
733 }).unwrap()))
734 },
735
736 DataValue::ByteBuffer(value) => {
737 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
738 data_object.set_byte_buffer(value.borrow().iter().rev().copied().collect::<Box<_>>())
739 }).unwrap()))
740 },
741
742 DataValue::Array(value) => {
743 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
744 data_object.set_array(value.borrow().iter().rev().cloned().collect::<Box<_>>())
745 }).unwrap()))
746 },
747
748 DataValue::List(value) => {
749 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
750 data_object.set_list(value.borrow().iter().rev().cloned().collect::<VecDeque<_>>())
751 }).unwrap()))
752 },
753
754 _ => None,
755 }
756}
757pub fn op_add(
761 interpreter: &mut Interpreter,
762 left_side_operand: &DataObjectRef,
763 right_side_operand: &DataObjectRef,
764 pos: CodePosition,
765) -> OptionDataObjectRef {
766 let ret = call_operator_method_2_arg(
767 interpreter,
768 "add",
769 true,
770 left_side_operand,
771 right_side_operand,
772 pos,
773 );
774 if let Some(ret) = ret {
775 return Some(ret);
776 }
777
778 match &left_side_operand.data_value() {
779 DataValue::Int(left_value) => {
780 match right_side_operand.data_value() {
781 DataValue::Int(right_value) => {
782 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
783 data_object.set_int(left_value.wrapping_add(right_value))
784 }).unwrap()))
785 },
786
787 DataValue::Long(right_value) => {
788 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
789 data_object.set_long((*left_value as i64).wrapping_add(right_value))
790 }).unwrap()))
791 },
792
793 DataValue::Float(right_value) => {
794 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
795 data_object.set_float(*left_value as f32 + right_value)
796 }).unwrap()))
797 },
798
799 DataValue::Double(right_value) => {
800 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
801 data_object.set_double(*left_value as f64 + right_value)
802 }).unwrap()))
803 },
804
805 DataValue::Char(right_value) => {
806 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
807 data_object.set_int(left_value.wrapping_add(right_value as i32))
808 }).unwrap()))
809 },
810
811 _ => None,
812 }
813 },
814
815 DataValue::Long(left_value) => {
816 match right_side_operand.data_value() {
817 DataValue::Int(right_value) => {
818 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
819 data_object.set_long(left_value.wrapping_add(right_value as i64))
820 }).unwrap()))
821 },
822
823 DataValue::Long(right_value) => {
824 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
825 data_object.set_long(left_value.wrapping_add(right_value))
826 }).unwrap()))
827 },
828
829 DataValue::Float(right_value) => {
830 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
831 data_object.set_float(*left_value as f32 + right_value)
832 }).unwrap()))
833 },
834
835 DataValue::Double(right_value) => {
836 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
837 data_object.set_double(*left_value as f64 + right_value)
838 }).unwrap()))
839 },
840
841 DataValue::Char(right_value) => {
842 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
843 data_object.set_long(left_value.wrapping_add(right_value as i64))
844 }).unwrap()))
845 },
846
847 _ => None,
848 }
849 },
850
851 DataValue::Float(left_value) => {
852 match right_side_operand.data_value() {
853 DataValue::Int(right_value) => {
854 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
855 data_object.set_float(left_value + right_value as f32)
856 }).unwrap()))
857 },
858
859 DataValue::Long(right_value) => {
860 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
861 data_object.set_float(left_value + right_value as f32)
862 }).unwrap()))
863 },
864
865 DataValue::Float(right_value) => {
866 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
867 data_object.set_float(left_value + right_value)
868 }).unwrap()))
869 },
870
871 DataValue::Double(right_value) => {
872 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
873 data_object.set_double(*left_value as f64 + right_value)
874 }).unwrap()))
875 },
876
877 DataValue::Char(right_value) => {
878 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
879 data_object.set_float(left_value + right_value as i32 as f32)
880 }).unwrap()))
881 },
882
883 _ => None,
884 }
885 },
886
887 DataValue::Double(left_value) => {
888 match right_side_operand.data_value() {
889 DataValue::Int(right_value) => {
890 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
891 data_object.set_double(left_value + right_value as f64)
892 }).unwrap()))
893 },
894
895 DataValue::Long(right_value) => {
896 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
897 data_object.set_double(left_value + right_value as f64)
898 }).unwrap()))
899 },
900
901 DataValue::Float(right_value) => {
902 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
903 data_object.set_double(left_value + right_value as f64)
904 }).unwrap()))
905 },
906
907 DataValue::Double(right_value) => {
908 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
909 data_object.set_double(left_value + right_value)
910 }).unwrap()))
911 },
912
913 DataValue::Char(right_value) => {
914 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
915 data_object.set_double(left_value + right_value as i32 as f64)
916 }).unwrap()))
917 },
918
919 _ => None,
920 }
921 },
922
923 DataValue::Char(left_value) => {
924 match right_side_operand.data_value() {
925 DataValue::Int(right_value) => {
926 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
927 data_object.set_int((*left_value as i32).wrapping_add(right_value))
928 }).unwrap()))
929 },
930
931 DataValue::Long(right_value) => {
932 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
933 data_object.set_long((*left_value as i64).wrapping_add(right_value))
934 }).unwrap()))
935 },
936
937 DataValue::Float(right_value) => {
938 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
939 data_object.set_float(*left_value as i32 as f32 + right_value)
940 }).unwrap()))
941 },
942
943 DataValue::Double(right_value) => {
944 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
945 data_object.set_double(*left_value as i32 as f64 + right_value)
946 }).unwrap()))
947 },
948
949 DataValue::Char(right_value) => {
950 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
951 data_object.set_int((*left_value as i32).wrapping_add(right_value as i32))
952 }).unwrap()))
953 },
954
955 _ => None,
956 }
957 },
958
959 DataValue::Text(left_value) => {
960 Some(DataObjectRef::new(DataObject::new_text(format!(
961 "{left_value}{}",
962 conversions::to_text(interpreter, right_side_operand, pos),
963 ))))
964 },
965
966 DataValue::Array(left_value) => {
967 let mut arr_new = Vec::with_capacity(left_value.borrow().len() + 1);
968 arr_new.extend_from_slice(&left_value.borrow());
969 arr_new.push(DataObjectRef::new(DataObject::with_update(|data_object| {
970 data_object.set_data(&right_side_operand.borrow())
971 }).unwrap()));
972
973 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
974 data_object.set_array(arr_new.into_boxed_slice())
975 }).unwrap()))
976 },
977
978 DataValue::List(left_value) => {
979 let mut arr_new = VecDeque::with_capacity(left_value.borrow().len() + 1);
980 arr_new.extend(left_value.borrow().iter().cloned());
981 arr_new.push_back(DataObjectRef::new(DataObject::with_update(|data_object| {
982 data_object.set_data(&right_side_operand.borrow())
983 }).unwrap()));
984
985 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
986 data_object.set_list(arr_new)
987 }).unwrap()))
988 },
989
990 DataValue::FunctionPointer(left_value) => {
991 let right_value = right_side_operand.function_pointer_value()?;
992
993 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
994 data_object.set_function_pointer(Gc::new(left_value.
995 copy_with_added_functions(&right_value)))
996 }).unwrap()))
997 },
998
999 _ => None,
1000 }
1001}
1002pub fn op_sub(
1006 interpreter: &mut Interpreter,
1007 left_side_operand: &DataObjectRef,
1008 right_side_operand: &DataObjectRef,
1009 pos: CodePosition,
1010) -> OptionDataObjectRef {
1011 let ret = call_operator_method_2_arg(
1012 interpreter,
1013 "sub",
1014 true,
1015 left_side_operand,
1016 right_side_operand,
1017 pos,
1018 );
1019 if let Some(ret) = ret {
1020 return Some(ret);
1021 }
1022
1023 match left_side_operand.data_value() {
1024 DataValue::Int(left_value) => {
1025 match right_side_operand.data_value() {
1026 DataValue::Int(right_value) => {
1027 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1028 data_object.set_int(left_value.wrapping_sub(right_value))
1029 }).unwrap()))
1030 },
1031
1032 DataValue::Long(right_value) => {
1033 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1034 data_object.set_long((left_value as i64).wrapping_sub(right_value))
1035 }).unwrap()))
1036 },
1037
1038 DataValue::Float(right_value) => {
1039 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1040 data_object.set_float(left_value as f32 - right_value)
1041 }).unwrap()))
1042 },
1043
1044 DataValue::Double(right_value) => {
1045 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1046 data_object.set_double(left_value as f64 - right_value)
1047 }).unwrap()))
1048 },
1049
1050 DataValue::Char(right_value) => {
1051 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1052 data_object.set_int(left_value.wrapping_sub(right_value as i32))
1053 }).unwrap()))
1054 },
1055
1056 _ => None,
1057 }
1058 },
1059
1060 DataValue::Long(left_value) => {
1061 match right_side_operand.data_value() {
1062 DataValue::Int(right_value) => {
1063 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1064 data_object.set_long(left_value.wrapping_sub(right_value as i64))
1065 }).unwrap()))
1066 },
1067
1068 DataValue::Long(right_value) => {
1069 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1070 data_object.set_long(left_value.wrapping_sub(right_value))
1071 }).unwrap()))
1072 },
1073
1074 DataValue::Float(right_value) => {
1075 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1076 data_object.set_float(left_value as f32 - right_value)
1077 }).unwrap()))
1078 },
1079
1080 DataValue::Double(right_value) => {
1081 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1082 data_object.set_double(left_value as f64 - right_value)
1083 }).unwrap()))
1084 },
1085
1086 DataValue::Char(right_value) => {
1087 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1088 data_object.set_long(left_value.wrapping_sub(right_value as i64))
1089 }).unwrap()))
1090 },
1091
1092 _ => None,
1093 }
1094 },
1095
1096 DataValue::Float(left_value) => {
1097 match right_side_operand.data_value() {
1098 DataValue::Int(right_value) => {
1099 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1100 data_object.set_float(left_value - right_value as f32)
1101 }).unwrap()))
1102 },
1103
1104 DataValue::Long(right_value) => {
1105 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1106 data_object.set_float(left_value - right_value as f32)
1107 }).unwrap()))
1108 },
1109
1110 DataValue::Float(right_value) => {
1111 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1112 data_object.set_float(left_value - right_value)
1113 }).unwrap()))
1114 },
1115
1116 DataValue::Double(right_value) => {
1117 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1118 data_object.set_double(left_value as f64 - right_value)
1119 }).unwrap()))
1120 },
1121
1122 DataValue::Char(right_value) => {
1123 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1124 data_object.set_float(left_value - right_value as i32 as f32)
1125 }).unwrap()))
1126 },
1127
1128 _ => None,
1129 }
1130 },
1131
1132 DataValue::Double(left_value) => {
1133 match right_side_operand.data_value() {
1134 DataValue::Int(right_value) => {
1135 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1136 data_object.set_double(left_value - right_value as f64)
1137 }).unwrap()))
1138 },
1139
1140 DataValue::Long(right_value) => {
1141 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1142 data_object.set_double(left_value - right_value as f64)
1143 }).unwrap()))
1144 },
1145
1146 DataValue::Float(right_value) => {
1147 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1148 data_object.set_double(left_value - right_value as f64)
1149 }).unwrap()))
1150 },
1151
1152 DataValue::Double(right_value) => {
1153 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1154 data_object.set_double(left_value - right_value)
1155 }).unwrap()))
1156 },
1157
1158 DataValue::Char(right_value) => {
1159 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1160 data_object.set_double(left_value - right_value as i32 as f64)
1161 }).unwrap()))
1162 },
1163
1164 _ => None,
1165 }
1166 },
1167
1168 DataValue::Char(left_value) => {
1169 match right_side_operand.data_value() {
1170 DataValue::Int(right_value) => {
1171 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1172 data_object.set_int((left_value as i32).wrapping_sub(right_value))
1173 }).unwrap()))
1174 },
1175
1176 DataValue::Long(right_value) => {
1177 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1178 data_object.set_long((left_value as i64).wrapping_sub(right_value))
1179 }).unwrap()))
1180 },
1181
1182 DataValue::Float(right_value) => {
1183 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1184 data_object.set_float(left_value as i32 as f32 - right_value)
1185 }).unwrap()))
1186 },
1187
1188 DataValue::Double(right_value) => {
1189 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1190 data_object.set_double(left_value as i32 as f64 - right_value)
1191 }).unwrap()))
1192 },
1193
1194 DataValue::Char(right_value) => {
1195 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1196 data_object.set_int((left_value as i32).wrapping_sub(right_value as i32))
1197 }).unwrap()))
1198 },
1199
1200 _ => None,
1201 }
1202 },
1203
1204 _ => None,
1205 }
1206}
1207pub fn op_mul(
1211 interpreter: &mut Interpreter,
1212 left_side_operand: &DataObjectRef,
1213 right_side_operand: &DataObjectRef,
1214 pos: CodePosition,
1215) -> OptionDataObjectRef {
1216 let ret = call_operator_method_2_arg(
1217 interpreter,
1218 "mul",
1219 true,
1220 left_side_operand,
1221 right_side_operand,
1222 pos,
1223 );
1224 if let Some(ret) = ret {
1225 return Some(ret);
1226 }
1227
1228 match &left_side_operand.data_value() {
1229 DataValue::Int(left_value) => {
1230 match right_side_operand.data_value() {
1231 DataValue::Int(right_value) => {
1232 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1233 data_object.set_int(left_value.wrapping_mul(right_value))
1234 }).unwrap()))
1235 },
1236
1237 DataValue::Long(right_value) => {
1238 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1239 data_object.set_long((*left_value as i64).wrapping_mul(right_value))
1240 }).unwrap()))
1241 },
1242
1243 DataValue::Float(right_value) => {
1244 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1245 data_object.set_float(*left_value as f32 * right_value)
1246 }).unwrap()))
1247 },
1248
1249 DataValue::Double(right_value) => {
1250 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1251 data_object.set_double(*left_value as f64 * right_value)
1252 }).unwrap()))
1253 },
1254
1255 _ => None,
1256 }
1257 },
1258
1259 DataValue::Long(left_value) => {
1260 match right_side_operand.data_value() {
1261 DataValue::Int(right_value) => {
1262 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1263 data_object.set_long(left_value.wrapping_mul(right_value as i64))
1264 }).unwrap()))
1265 },
1266
1267 DataValue::Long(right_value) => {
1268 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1269 data_object.set_long(left_value.wrapping_mul(right_value))
1270 }).unwrap()))
1271 },
1272
1273 DataValue::Float(right_value) => {
1274 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1275 data_object.set_float(*left_value as f32 * right_value)
1276 }).unwrap()))
1277 },
1278
1279 DataValue::Double(right_value) => {
1280 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1281 data_object.set_double(*left_value as f64 * right_value)
1282 }).unwrap()))
1283 },
1284
1285 _ => None,
1286 }
1287 },
1288
1289 DataValue::Float(left_value) => {
1290 match right_side_operand.data_value() {
1291 DataValue::Int(right_value) => {
1292 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1293 data_object.set_float(left_value * right_value as f32)
1294 }).unwrap()))
1295 },
1296
1297 DataValue::Long(right_value) => {
1298 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1299 data_object.set_float(left_value * right_value as f32)
1300 }).unwrap()))
1301 },
1302
1303 DataValue::Float(right_value) => {
1304 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1305 data_object.set_float(left_value * right_value)
1306 }).unwrap()))
1307 },
1308
1309 DataValue::Double(right_value) => {
1310 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1311 data_object.set_double(*left_value as f64 * right_value)
1312 }).unwrap()))
1313 },
1314
1315 _ => None,
1316 }
1317 },
1318
1319 DataValue::Double(left_value) => {
1320 match right_side_operand.data_value() {
1321 DataValue::Int(right_value) => {
1322 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1323 data_object.set_double(left_value * right_value as f64)
1324 }).unwrap()))
1325 },
1326
1327 DataValue::Long(right_value) => {
1328 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1329 data_object.set_double(left_value * right_value as f64)
1330 }).unwrap()))
1331 },
1332
1333 DataValue::Float(right_value) => {
1334 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1335 data_object.set_double(left_value * right_value as f64)
1336 }).unwrap()))
1337 },
1338
1339 DataValue::Double(right_value) => {
1340 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1341 data_object.set_double(left_value * right_value)
1342 }).unwrap()))
1343 },
1344
1345 _ => None,
1346 }
1347 },
1348
1349 DataValue::Text(left_value) => {
1350 let right_value = right_side_operand.int_value()?;
1351 if right_value < 0 {
1352 return Some(interpreter.set_errno_error_object(
1353 InterpretingError::InvalidArguments,
1354 Some("Integer value must be larger than or equals to 0"),
1355 pos,
1356 ));
1357 }
1358
1359 let mut builder = String::with_capacity(left_value.len() * right_value as usize);
1360 for _ in 0..right_value {
1361 builder += left_value;
1362 }
1363
1364 Some(DataObjectRef::new(DataObject::new_text(builder)))
1365 },
1366
1367 _ => None,
1368 }
1369}
1370pub fn op_pow(
1374 interpreter: &mut Interpreter,
1375 left_side_operand: &DataObjectRef,
1376 right_side_operand: &DataObjectRef,
1377 pos: CodePosition,
1378) -> OptionDataObjectRef {
1379 let ret = call_operator_method_2_arg(
1380 interpreter,
1381 "pow",
1382 true,
1383 left_side_operand,
1384 right_side_operand,
1385 pos,
1386 );
1387 if let Some(ret) = ret {
1388 return Some(ret);
1389 }
1390
1391 match &left_side_operand.data_value() {
1392 DataValue::Int(left_value) => {
1393 match right_side_operand.data_value() {
1394 DataValue::Int(right_value) => {
1395 let pow_result = if right_value >= 0 {
1396 left_value.checked_pow(right_value as u32)
1397 }else {
1398 None
1399 };
1400
1401 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1402 if let Some(pow_result) = pow_result {
1403 data_object.set_int(pow_result)
1404 }else {
1405 data_object.set_double((*left_value as f64).powf(right_value as f64))
1406 }
1407 }).unwrap()))
1408 },
1409
1410 DataValue::Long(right_value) => {
1411 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1412 data_object.set_double((*left_value as f64).powf(right_value as f64))
1413 }).unwrap()))
1414 },
1415
1416 DataValue::Float(right_value) => {
1417 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1418 data_object.set_double((*left_value as f64).powf(right_value as f64))
1419 }).unwrap()))
1420 },
1421
1422 DataValue::Double(right_value) => {
1423 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1424 data_object.set_double((*left_value as f64).powf(right_value))
1425 }).unwrap()))
1426 },
1427
1428 _ => None,
1429 }
1430 },
1431
1432 DataValue::Long(left_value) => {
1433 match right_side_operand.data_value() {
1434 DataValue::Int(right_value) => {
1435 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1436 data_object.set_double((*left_value as f64).powf(right_value as f64))
1437 }).unwrap()))
1438 },
1439
1440 DataValue::Long(right_value) => {
1441 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1442 data_object.set_double((*left_value as f64).powf(right_value as f64))
1443 }).unwrap()))
1444 },
1445
1446 DataValue::Float(right_value) => {
1447 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1448 data_object.set_double((*left_value as f64).powf(right_value as f64))
1449 }).unwrap()))
1450 },
1451
1452 DataValue::Double(right_value) => {
1453 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1454 data_object.set_double((*left_value as f64).powf(right_value))
1455 }).unwrap()))
1456 },
1457
1458 _ => None,
1459 }
1460 },
1461
1462 DataValue::Float(left_value) => {
1463 match right_side_operand.data_value() {
1464 DataValue::Int(right_value) => {
1465 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1466 data_object.set_double((*left_value as f64).powf(right_value as f64))
1467 }).unwrap()))
1468 },
1469
1470 DataValue::Long(right_value) => {
1471 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1472 data_object.set_double((*left_value as f64).powf(right_value as f64))
1473 }).unwrap()))
1474 },
1475
1476 DataValue::Float(right_value) => {
1477 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1478 data_object.set_double((*left_value as f64).powf(right_value as f64))
1479 }).unwrap()))
1480 },
1481
1482 DataValue::Double(right_value) => {
1483 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1484 data_object.set_double((*left_value as f64).powf(right_value))
1485 }).unwrap()))
1486 },
1487
1488 _ => None,
1489 }
1490 },
1491
1492 DataValue::Double(left_value) => {
1493 match right_side_operand.data_value() {
1494 DataValue::Int(right_value) => {
1495 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1496 data_object.set_double(left_value.powf(right_value as f64))
1497 }).unwrap()))
1498 },
1499
1500 DataValue::Long(right_value) => {
1501 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1502 data_object.set_double(left_value.powf(right_value as f64))
1503 }).unwrap()))
1504 },
1505
1506 DataValue::Float(right_value) => {
1507 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1508 data_object.set_double(left_value.powf(right_value as f64))
1509 }).unwrap()))
1510 },
1511
1512 DataValue::Double(right_value) => {
1513 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1514 data_object.set_double(left_value.powf(right_value))
1515 }).unwrap()))
1516 },
1517
1518 _ => None,
1519 }
1520 },
1521
1522 DataValue::FunctionPointer(left_value) => {
1523 let left_value = left_value.clone();
1524 let count = right_side_operand.int_value()?;
1525 if count < 0 {
1526 return Some(interpreter.set_errno_error_object(
1527 InterpretingError::InvalidArguments,
1528 Some("Number must not be less than 0!"),
1529 pos,
1530 ));
1531 }
1532
1533 let function_name = format!("<{left_value} ** {count}>");
1534
1535 if count == 0 {
1536 let pow_func = {
1537 move |_: &mut Interpreter, _: Vec<DataObjectRef>| -> DataObjectRef {
1538 DataObjectRef::new(DataObject::new_void())
1539 }
1540 };
1541 let func = FunctionPointerObject::from(crate::lang_func!(
1542 pow_func,
1543 crate::lang_func_metadata!(
1544 name="pow-func",
1545 parameter(
1546 name="&args",
1547 parameter_type(raw_var_args),
1548 ),
1549 ),
1550 )).copy_with_function_name(&function_name);
1551
1552 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1553 data_object.set_function_pointer(Gc::new(func))
1554 }).unwrap()))
1555 }else {
1556 let left_side_operand = left_side_operand.clone();
1557
1558 let pow_func = {
1559 let left_side_operand = left_side_operand.clone();
1560
1561 move |interpreter: &mut Interpreter, args: Vec<DataObjectRef>| -> DataObjectRef {
1562 let mut ret = utils::none_to_lang_void(interpreter.call_function_pointer(
1563 &left_value,
1564 left_side_operand.variable_name().as_deref(),
1565 &args,
1566 CodePosition::EMPTY,
1567 ));
1568
1569 for _ in 1..count {
1570 ret = utils::none_to_lang_void(interpreter.call_function_pointer(
1571 &left_value,
1572 left_side_operand.variable_name().as_deref(),
1573 &[ret],
1574 CodePosition::EMPTY,
1575 ));
1576 }
1577
1578 ret
1579 }
1580 };
1581 let func = FunctionPointerObject::from(crate::lang_func!(
1582 pow_func,
1583 vec![
1584 Box::new(count),
1585 Box::new(left_side_operand),
1586 ],
1587 crate::lang_func_metadata!(
1588 name="pow-func",
1589 parameter(
1590 name="&args",
1591 parameter_type(raw_var_args),
1592 ),
1593 ),
1594 )).copy_with_function_name(&function_name);
1595
1596 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1597 data_object.set_function_pointer(Gc::new(func))
1598 }).unwrap()))
1599 }
1600 },
1601
1602 _ => None,
1603 }
1604}
1605pub fn op_div(
1609 interpreter: &mut Interpreter,
1610 left_side_operand: &DataObjectRef,
1611 right_side_operand: &DataObjectRef,
1612 pos: CodePosition,
1613) -> OptionDataObjectRef {
1614 let ret = call_operator_method_2_arg(
1615 interpreter,
1616 "div",
1617 true,
1618 left_side_operand,
1619 right_side_operand,
1620 pos,
1621 );
1622 if let Some(ret) = ret {
1623 return Some(ret);
1624 }
1625
1626 match left_side_operand.data_value() {
1627 DataValue::Int(left_value) => {
1628 match right_side_operand.data_value() {
1629 DataValue::Int(right_value) => {
1630 if right_value == 0 {
1631 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1632 data_object.set_double(left_value as f64 / 0.0)
1633 }).unwrap()))
1634 }else if left_value.wrapping_rem(right_value) != 0 {
1635 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1636 data_object.set_double(left_value as f64 / right_value as f64)
1637 }).unwrap()))
1638 }else {
1639 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1640 data_object.set_int(left_value.wrapping_div(right_value))
1641 }).unwrap()))
1642 }
1643 },
1644
1645 DataValue::Long(right_value) => {
1646 if right_value == 0 {
1647 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1648 data_object.set_double(left_value as f64 / 0.0)
1649 }).unwrap()))
1650 }else if (left_value as i64).wrapping_rem(right_value) != 0 {
1651 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1652 data_object.set_double(left_value as f64 / right_value as f64)
1653 }).unwrap()))
1654 }else {
1655 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1656 data_object.set_long((left_value as i64).wrapping_div(right_value))
1657 }).unwrap()))
1658 }
1659 },
1660
1661 DataValue::Float(right_value) => {
1662 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1663 data_object.set_float(left_value as f32 / right_value)
1664 }).unwrap()))
1665 },
1666
1667 DataValue::Double(right_value) => {
1668 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1669 data_object.set_double(left_value as f64 / right_value)
1670 }).unwrap()))
1671 },
1672
1673 _ => None,
1674 }
1675 },
1676
1677 DataValue::Long(left_value) => {
1678 match right_side_operand.data_value() {
1679 DataValue::Int(right_value) => {
1680 if right_value == 0 {
1681 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1682 data_object.set_double(left_value as f64 / 0.0)
1683 }).unwrap()))
1684 }else if left_value.wrapping_rem(right_value as i64) != 0 {
1685 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1686 data_object.set_double(left_value as f64 / right_value as f64)
1687 }).unwrap()))
1688 }else {
1689 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1690 data_object.set_long(left_value.wrapping_div(right_value as i64))
1691 }).unwrap()))
1692 }
1693 },
1694
1695 DataValue::Long(right_value) => {
1696 if right_value == 0 {
1697 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1698 data_object.set_double(left_value as f64 / 0.0)
1699 }).unwrap()))
1700 }else if left_value.wrapping_rem(right_value) != 0 {
1701 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1702 data_object.set_double(left_value as f64 / right_value as f64)
1703 }).unwrap()))
1704 }else {
1705 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1706 data_object.set_long(left_value.wrapping_div(right_value))
1707 }).unwrap()))
1708 }
1709 },
1710
1711 DataValue::Float(right_value) => {
1712 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1713 data_object.set_float(left_value as f32 / right_value)
1714 }).unwrap()))
1715 },
1716
1717 DataValue::Double(right_value) => {
1718 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1719 data_object.set_double(left_value as f64 / right_value)
1720 }).unwrap()))
1721 },
1722
1723 _ => None,
1724 }
1725 },
1726
1727 DataValue::Float(left_value) => {
1728 match right_side_operand.data_value() {
1729 DataValue::Int(right_value) => {
1730 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1731 data_object.set_float(left_value / right_value as f32)
1732 }).unwrap()))
1733 },
1734
1735 DataValue::Long(right_value) => {
1736 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1737 data_object.set_float(left_value / right_value as f32)
1738 }).unwrap()))
1739 },
1740
1741 DataValue::Float(right_value) => {
1742 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1743 data_object.set_float(left_value / right_value)
1744 }).unwrap()))
1745 },
1746
1747 DataValue::Double(right_value) => {
1748 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1749 data_object.set_double(left_value as f64 / right_value)
1750 }).unwrap()))
1751 },
1752
1753 _ => None,
1754 }
1755 },
1756
1757 DataValue::Double(left_value) => {
1758 match right_side_operand.data_value() {
1759 DataValue::Int(right_value) => {
1760 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1761 data_object.set_double(left_value / right_value as f64)
1762 }).unwrap()))
1763 },
1764
1765 DataValue::Long(right_value) => {
1766 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1767 data_object.set_double(left_value / right_value as f64)
1768 }).unwrap()))
1769 },
1770
1771 DataValue::Float(right_value) => {
1772 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1773 data_object.set_double(left_value / right_value as f64)
1774 }).unwrap()))
1775 },
1776
1777 DataValue::Double(right_value) => {
1778 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1779 data_object.set_double(left_value / right_value)
1780 }).unwrap()))
1781 },
1782
1783 _ => None,
1784 }
1785 },
1786
1787 _ => None,
1788 }
1789}
1790pub fn op_trunc_div(
1794 interpreter: &mut Interpreter,
1795 left_side_operand: &DataObjectRef,
1796 right_side_operand: &DataObjectRef,
1797 pos: CodePosition,
1798) -> OptionDataObjectRef {
1799 let ret = call_operator_method_2_arg(
1800 interpreter,
1801 "truncDiv",
1802 true,
1803 left_side_operand,
1804 right_side_operand,
1805 pos,
1806 );
1807 if let Some(ret) = ret {
1808 return Some(ret);
1809 }
1810
1811 match left_side_operand.data_value() {
1812 DataValue::Int(left_value) => {
1813 match right_side_operand.data_value() {
1814 DataValue::Int(right_value) => {
1815 if right_value == 0 {
1816 Some(interpreter.set_errno_error_object(
1817 InterpretingError::DivByZero,
1818 None,
1819 pos,
1820 ))
1821 }else {
1822 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1823 data_object.set_int(left_value.wrapping_div(right_value))
1824 }).unwrap()))
1825 }
1826 },
1827
1828 DataValue::Long(right_value) => {
1829 if right_value == 0 {
1830 Some(interpreter.set_errno_error_object(
1831 InterpretingError::DivByZero,
1832 None,
1833 pos,
1834 ))
1835 }else {
1836 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1837 data_object.set_long((left_value as i64).wrapping_div(right_value))
1838 }).unwrap()))
1839 }
1840 },
1841
1842 DataValue::Float(right_value) => {
1843 if right_value == 0.0 {
1844 Some(interpreter.set_errno_error_object(
1845 InterpretingError::DivByZero,
1846 None,
1847 pos,
1848 ))
1849 }else {
1850 let tmp = left_value as f32 / right_value;
1851 let tmp = if tmp > 0.0 {
1852 tmp.floor()
1853 }else {
1854 tmp.ceil()
1855 };
1856
1857 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1858 data_object.set_float(tmp)
1859 }).unwrap()))
1860 }
1861 },
1862
1863 DataValue::Double(right_value) => {
1864 if right_value == 0.0 {
1865 Some(interpreter.set_errno_error_object(
1866 InterpretingError::DivByZero,
1867 None,
1868 pos,
1869 ))
1870 }else {
1871 let tmp = left_value as f64 / right_value;
1872 let tmp = if tmp > 0.0 {
1873 tmp.floor()
1874 }else {
1875 tmp.ceil()
1876 };
1877
1878 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1879 data_object.set_double(tmp)
1880 }).unwrap()))
1881 }
1882 },
1883
1884 _ => None,
1885 }
1886 },
1887
1888 DataValue::Long(left_value) => {
1889 match right_side_operand.data_value() {
1890 DataValue::Int(right_value) => {
1891 if right_value == 0 {
1892 Some(interpreter.set_errno_error_object(
1893 InterpretingError::DivByZero,
1894 None,
1895 pos,
1896 ))
1897 }else {
1898 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1899 data_object.set_long(left_value.wrapping_div(right_value as i64))
1900 }).unwrap()))
1901 }
1902 },
1903
1904 DataValue::Long(right_value) => {
1905 if right_value == 0 {
1906 Some(interpreter.set_errno_error_object(
1907 InterpretingError::DivByZero,
1908 None,
1909 pos,
1910 ))
1911 }else {
1912 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1913 data_object.set_long(left_value.wrapping_div(right_value))
1914 }).unwrap()))
1915 }
1916 },
1917
1918 DataValue::Float(right_value) => {
1919 if right_value == 0.0 {
1920 Some(interpreter.set_errno_error_object(
1921 InterpretingError::DivByZero,
1922 None,
1923 pos,
1924 ))
1925 }else {
1926 let tmp = left_value as f32 / right_value;
1927 let tmp = if tmp > 0.0 {
1928 tmp.floor()
1929 }else {
1930 tmp.ceil()
1931 };
1932
1933 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1934 data_object.set_float(tmp)
1935 }).unwrap()))
1936 }
1937 },
1938
1939 DataValue::Double(right_value) => {
1940 if right_value == 0.0 {
1941 Some(interpreter.set_errno_error_object(
1942 InterpretingError::DivByZero,
1943 None,
1944 pos,
1945 ))
1946 }else {
1947 let tmp = left_value as f64 / right_value;
1948 let tmp = if tmp > 0.0 {
1949 tmp.floor()
1950 }else {
1951 tmp.ceil()
1952 };
1953
1954 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1955 data_object.set_double(tmp)
1956 }).unwrap()))
1957 }
1958 },
1959
1960 _ => None,
1961 }
1962 },
1963
1964 DataValue::Float(left_value) => {
1965 match right_side_operand.data_value() {
1966 DataValue::Int(right_value) => {
1967 if right_value == 0 {
1968 Some(interpreter.set_errno_error_object(
1969 InterpretingError::DivByZero,
1970 None,
1971 pos,
1972 ))
1973 }else {
1974 let tmp = left_value / right_value as f32;
1975 let tmp = if tmp > 0.0 {
1976 tmp.floor()
1977 }else {
1978 tmp.ceil()
1979 };
1980
1981 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
1982 data_object.set_float(tmp)
1983 }).unwrap()))
1984 }
1985 },
1986
1987 DataValue::Long(right_value) => {
1988 if right_value == 0 {
1989 Some(interpreter.set_errno_error_object(
1990 InterpretingError::DivByZero,
1991 None,
1992 pos,
1993 ))
1994 }else {
1995 let tmp = left_value / right_value as f32;
1996 let tmp = if tmp > 0.0 {
1997 tmp.floor()
1998 }else {
1999 tmp.ceil()
2000 };
2001
2002 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2003 data_object.set_float(tmp)
2004 }).unwrap()))
2005 }
2006 },
2007
2008 DataValue::Float(right_value) => {
2009 if right_value == 0.0 {
2010 Some(interpreter.set_errno_error_object(
2011 InterpretingError::DivByZero,
2012 None,
2013 pos,
2014 ))
2015 }else {
2016 let tmp = left_value / right_value;
2017 let tmp = if tmp > 0.0 {
2018 tmp.floor()
2019 }else {
2020 tmp.ceil()
2021 };
2022
2023 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2024 data_object.set_float(tmp)
2025 }).unwrap()))
2026 }
2027 },
2028
2029 DataValue::Double(right_value) => {
2030 if right_value == 0.0 {
2031 Some(interpreter.set_errno_error_object(
2032 InterpretingError::DivByZero,
2033 None,
2034 pos,
2035 ))
2036 }else {
2037 let tmp = left_value as f64 / right_value;
2038 let tmp = if tmp > 0.0 {
2039 tmp.floor()
2040 }else {
2041 tmp.ceil()
2042 };
2043
2044 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2045 data_object.set_double(tmp)
2046 }).unwrap()))
2047 }
2048 },
2049
2050 _ => None,
2051 }
2052 },
2053
2054 DataValue::Double(left_value) => {
2055 match right_side_operand.data_value() {
2056 DataValue::Int(right_value) => {
2057 if right_value == 0 {
2058 Some(interpreter.set_errno_error_object(
2059 InterpretingError::DivByZero,
2060 None,
2061 pos,
2062 ))
2063 }else {
2064 let tmp = left_value / right_value as f64;
2065 let tmp = if tmp > 0.0 {
2066 tmp.floor()
2067 }else {
2068 tmp.ceil()
2069 };
2070
2071 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2072 data_object.set_double(tmp)
2073 }).unwrap()))
2074 }
2075 },
2076
2077 DataValue::Long(right_value) => {
2078 if right_value == 0 {
2079 Some(interpreter.set_errno_error_object(
2080 InterpretingError::DivByZero,
2081 None,
2082 pos,
2083 ))
2084 }else {
2085 let tmp = left_value / right_value as f64;
2086 let tmp = if tmp > 0.0 {
2087 tmp.floor()
2088 }else {
2089 tmp.ceil()
2090 };
2091
2092 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2093 data_object.set_double(tmp)
2094 }).unwrap()))
2095 }
2096 },
2097
2098 DataValue::Float(right_value) => {
2099 if right_value == 0.0 {
2100 Some(interpreter.set_errno_error_object(
2101 InterpretingError::DivByZero,
2102 None,
2103 pos,
2104 ))
2105 }else {
2106 let tmp = left_value / right_value as f64;
2107 let tmp = if tmp > 0.0 {
2108 tmp.floor()
2109 }else {
2110 tmp.ceil()
2111 };
2112
2113 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2114 data_object.set_double(tmp)
2115 }).unwrap()))
2116 }
2117 },
2118
2119 DataValue::Double(right_value) => {
2120 if right_value == 0.0 {
2121 Some(interpreter.set_errno_error_object(
2122 InterpretingError::DivByZero,
2123 None,
2124 pos,
2125 ))
2126 }else {
2127 let tmp = left_value / right_value;
2128 let tmp = if tmp > 0.0 {
2129 tmp.floor()
2130 }else {
2131 tmp.ceil()
2132 };
2133
2134 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2135 data_object.set_double(tmp)
2136 }).unwrap()))
2137 }
2138 },
2139
2140 _ => None,
2141 }
2142 },
2143
2144 _ => None,
2145 }
2146}
2147pub fn op_floor_div(
2151 interpreter: &mut Interpreter,
2152 left_side_operand: &DataObjectRef,
2153 right_side_operand: &DataObjectRef,
2154 pos: CodePosition,
2155) -> OptionDataObjectRef {
2156 let ret = call_operator_method_2_arg(
2157 interpreter,
2158 "floorDiv",
2159 true,
2160 left_side_operand,
2161 right_side_operand,
2162 pos,
2163 );
2164 if let Some(ret) = ret {
2165 return Some(ret);
2166 }
2167
2168 match left_side_operand.data_value() {
2169 DataValue::Int(left_value) => {
2170 match right_side_operand.data_value() {
2171 DataValue::Int(right_value) => {
2172 if right_value == 0 {
2173 Some(interpreter.set_errno_error_object(
2174 InterpretingError::DivByZero,
2175 None,
2176 pos,
2177 ))
2178 }else {
2179 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2180 data_object.set_int(left_value.wrapping_floor_div(right_value))
2181 }).unwrap()))
2182 }
2183 },
2184
2185 DataValue::Long(right_value) => {
2186 if right_value == 0 {
2187 Some(interpreter.set_errno_error_object(
2188 InterpretingError::DivByZero,
2189 None,
2190 pos,
2191 ))
2192 }else {
2193 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2194 data_object.set_long((left_value as i64).wrapping_floor_div(right_value))
2195 }).unwrap()))
2196 }
2197 },
2198
2199 DataValue::Float(right_value) => {
2200 if right_value == 0.0 {
2201 Some(interpreter.set_errno_error_object(
2202 InterpretingError::DivByZero,
2203 None,
2204 pos,
2205 ))
2206 }else {
2207 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2208 data_object.set_float((left_value as f32 / right_value).floor())
2209 }).unwrap()))
2210 }
2211 },
2212
2213 DataValue::Double(right_value) => {
2214 if right_value == 0.0 {
2215 Some(interpreter.set_errno_error_object(
2216 InterpretingError::DivByZero,
2217 None,
2218 pos,
2219 ))
2220 }else {
2221 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2222 data_object.set_double((left_value as f64 / right_value).floor())
2223 }).unwrap()))
2224 }
2225 },
2226
2227 _ => None,
2228 }
2229 },
2230
2231 DataValue::Long(left_value) => {
2232 match right_side_operand.data_value() {
2233 DataValue::Int(right_value) => {
2234 if right_value == 0 {
2235 Some(interpreter.set_errno_error_object(
2236 InterpretingError::DivByZero,
2237 None,
2238 pos,
2239 ))
2240 }else {
2241 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2242 data_object.set_long(left_value.wrapping_floor_div(right_value as i64))
2243 }).unwrap()))
2244 }
2245 },
2246
2247 DataValue::Long(right_value) => {
2248 if right_value == 0 {
2249 Some(interpreter.set_errno_error_object(
2250 InterpretingError::DivByZero,
2251 None,
2252 pos,
2253 ))
2254 }else {
2255 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2256 data_object.set_long(left_value.wrapping_floor_div(right_value))
2257 }).unwrap()))
2258 }
2259 },
2260
2261 DataValue::Float(right_value) => {
2262 if right_value == 0.0 {
2263 Some(interpreter.set_errno_error_object(
2264 InterpretingError::DivByZero,
2265 None,
2266 pos,
2267 ))
2268 }else {
2269 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2270 data_object.set_float((left_value as f32 / right_value).floor())
2271 }).unwrap()))
2272 }
2273 },
2274
2275 DataValue::Double(right_value) => {
2276 if right_value == 0.0 {
2277 Some(interpreter.set_errno_error_object(
2278 InterpretingError::DivByZero,
2279 None,
2280 pos,
2281 ))
2282 }else {
2283 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2284 data_object.set_double((left_value as f64 / right_value).floor())
2285 }).unwrap()))
2286 }
2287 },
2288
2289 _ => None,
2290 }
2291 },
2292
2293 DataValue::Float(left_value) => {
2294 match right_side_operand.data_value() {
2295 DataValue::Int(right_value) => {
2296 if right_value == 0 {
2297 Some(interpreter.set_errno_error_object(
2298 InterpretingError::DivByZero,
2299 None,
2300 pos,
2301 ))
2302 }else {
2303 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2304 data_object.set_float((left_value / right_value as f32).floor())
2305 }).unwrap()))
2306 }
2307 },
2308
2309 DataValue::Long(right_value) => {
2310 if right_value == 0 {
2311 Some(interpreter.set_errno_error_object(
2312 InterpretingError::DivByZero,
2313 None,
2314 pos,
2315 ))
2316 }else {
2317 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2318 data_object.set_float((left_value / right_value as f32).floor())
2319 }).unwrap()))
2320 }
2321 },
2322
2323 DataValue::Float(right_value) => {
2324 if right_value == 0.0 {
2325 Some(interpreter.set_errno_error_object(
2326 InterpretingError::DivByZero,
2327 None,
2328 pos,
2329 ))
2330 }else {
2331 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2332 data_object.set_float((left_value / right_value).floor())
2333 }).unwrap()))
2334 }
2335 },
2336
2337 DataValue::Double(right_value) => {
2338 if right_value == 0.0 {
2339 Some(interpreter.set_errno_error_object(
2340 InterpretingError::DivByZero,
2341 None,
2342 pos,
2343 ))
2344 }else {
2345 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2346 data_object.set_double((left_value as f64 / right_value).floor())
2347 }).unwrap()))
2348 }
2349 },
2350
2351 _ => None,
2352 }
2353 },
2354
2355 DataValue::Double(left_value) => {
2356 match right_side_operand.data_value() {
2357 DataValue::Int(right_value) => {
2358 if right_value == 0 {
2359 Some(interpreter.set_errno_error_object(
2360 InterpretingError::DivByZero,
2361 None,
2362 pos,
2363 ))
2364 }else {
2365 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2366 data_object.set_double((left_value / right_value as f64).floor())
2367 }).unwrap()))
2368 }
2369 },
2370
2371 DataValue::Long(right_value) => {
2372 if right_value == 0 {
2373 Some(interpreter.set_errno_error_object(
2374 InterpretingError::DivByZero,
2375 None,
2376 pos,
2377 ))
2378 }else {
2379 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2380 data_object.set_double((left_value / right_value as f64).floor())
2381 }).unwrap()))
2382 }
2383 },
2384
2385 DataValue::Float(right_value) => {
2386 if right_value == 0.0 {
2387 Some(interpreter.set_errno_error_object(
2388 InterpretingError::DivByZero,
2389 None,
2390 pos,
2391 ))
2392 }else {
2393 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2394 data_object.set_double((left_value / right_value as f64).floor())
2395 }).unwrap()))
2396 }
2397 },
2398
2399 DataValue::Double(right_value) => {
2400 if right_value == 0.0 {
2401 Some(interpreter.set_errno_error_object(
2402 InterpretingError::DivByZero,
2403 None,
2404 pos,
2405 ))
2406 }else {
2407 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2408 data_object.set_double((left_value / right_value).floor())
2409 }).unwrap()))
2410 }
2411 },
2412
2413 _ => None,
2414 }
2415 },
2416
2417 _ => None,
2418 }
2419}
2420pub fn op_ceil_div(
2424 interpreter: &mut Interpreter,
2425 left_side_operand: &DataObjectRef,
2426 right_side_operand: &DataObjectRef,
2427 pos: CodePosition,
2428) -> OptionDataObjectRef {
2429 let ret = call_operator_method_2_arg(
2430 interpreter,
2431 "ceilDiv",
2432 true,
2433 left_side_operand,
2434 right_side_operand,
2435 pos,
2436 );
2437 if let Some(ret) = ret {
2438 return Some(ret);
2439 }
2440
2441 match left_side_operand.data_value() {
2442 DataValue::Int(left_value) => {
2443 match right_side_operand.data_value() {
2444 DataValue::Int(right_value) => {
2445 if right_value == 0 {
2446 Some(interpreter.set_errno_error_object(
2447 InterpretingError::DivByZero,
2448 None,
2449 pos,
2450 ))
2451 }else {
2452 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2453 data_object.set_int(left_value.wrapping_ceil_div(right_value))
2454 }).unwrap()))
2455 }
2456 },
2457
2458 DataValue::Long(right_value) => {
2459 if right_value == 0 {
2460 Some(interpreter.set_errno_error_object(
2461 InterpretingError::DivByZero,
2462 None,
2463 pos,
2464 ))
2465 }else {
2466 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2467 data_object.set_long((left_value as i64).wrapping_ceil_div(right_value))
2468 }).unwrap()))
2469 }
2470 },
2471
2472 DataValue::Float(right_value) => {
2473 if right_value == 0.0 {
2474 Some(interpreter.set_errno_error_object(
2475 InterpretingError::DivByZero,
2476 None,
2477 pos,
2478 ))
2479 }else {
2480 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2481 data_object.set_float((left_value as f32 / right_value).ceil())
2482 }).unwrap()))
2483 }
2484 },
2485
2486 DataValue::Double(right_value) => {
2487 if right_value == 0.0 {
2488 Some(interpreter.set_errno_error_object(
2489 InterpretingError::DivByZero,
2490 None,
2491 pos,
2492 ))
2493 }else {
2494 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2495 data_object.set_double((left_value as f64 / right_value).ceil())
2496 }).unwrap()))
2497 }
2498 },
2499
2500 _ => None,
2501 }
2502 },
2503
2504 DataValue::Long(left_value) => {
2505 match right_side_operand.data_value() {
2506 DataValue::Int(right_value) => {
2507 if right_value == 0 {
2508 Some(interpreter.set_errno_error_object(
2509 InterpretingError::DivByZero,
2510 None,
2511 pos,
2512 ))
2513 }else {
2514 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2515 data_object.set_long(left_value.wrapping_ceil_div(right_value as i64))
2516 }).unwrap()))
2517 }
2518 },
2519
2520 DataValue::Long(right_value) => {
2521 if right_value == 0 {
2522 Some(interpreter.set_errno_error_object(
2523 InterpretingError::DivByZero,
2524 None,
2525 pos,
2526 ))
2527 }else {
2528 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2529 data_object.set_long(left_value.wrapping_ceil_div(right_value))
2530 }).unwrap()))
2531 }
2532 },
2533
2534 DataValue::Float(right_value) => {
2535 if right_value == 0.0 {
2536 Some(interpreter.set_errno_error_object(
2537 InterpretingError::DivByZero,
2538 None,
2539 pos,
2540 ))
2541 }else {
2542 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2543 data_object.set_float((left_value as f32 / right_value).ceil())
2544 }).unwrap()))
2545 }
2546 },
2547
2548 DataValue::Double(right_value) => {
2549 if right_value == 0.0 {
2550 Some(interpreter.set_errno_error_object(
2551 InterpretingError::DivByZero,
2552 None,
2553 pos,
2554 ))
2555 }else {
2556 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2557 data_object.set_double((left_value as f64 / right_value).ceil())
2558 }).unwrap()))
2559 }
2560 },
2561
2562 _ => None,
2563 }
2564 },
2565
2566 DataValue::Float(left_value) => {
2567 match right_side_operand.data_value() {
2568 DataValue::Int(right_value) => {
2569 if right_value == 0 {
2570 Some(interpreter.set_errno_error_object(
2571 InterpretingError::DivByZero,
2572 None,
2573 pos,
2574 ))
2575 }else {
2576 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2577 data_object.set_float((left_value / right_value as f32).ceil())
2578 }).unwrap()))
2579 }
2580 },
2581
2582 DataValue::Long(right_value) => {
2583 if right_value == 0 {
2584 Some(interpreter.set_errno_error_object(
2585 InterpretingError::DivByZero,
2586 None,
2587 pos,
2588 ))
2589 }else {
2590 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2591 data_object.set_float((left_value / right_value as f32).ceil())
2592 }).unwrap()))
2593 }
2594 },
2595
2596 DataValue::Float(right_value) => {
2597 if right_value == 0.0 {
2598 Some(interpreter.set_errno_error_object(
2599 InterpretingError::DivByZero,
2600 None,
2601 pos,
2602 ))
2603 }else {
2604 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2605 data_object.set_float((left_value / right_value).ceil())
2606 }).unwrap()))
2607 }
2608 },
2609
2610 DataValue::Double(right_value) => {
2611 if right_value == 0.0 {
2612 Some(interpreter.set_errno_error_object(
2613 InterpretingError::DivByZero,
2614 None,
2615 pos,
2616 ))
2617 }else {
2618 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2619 data_object.set_double((left_value as f64 / right_value).ceil())
2620 }).unwrap()))
2621 }
2622 },
2623
2624 _ => None,
2625 }
2626 },
2627
2628 DataValue::Double(left_value) => {
2629 match right_side_operand.data_value() {
2630 DataValue::Int(right_value) => {
2631 if right_value == 0 {
2632 Some(interpreter.set_errno_error_object(
2633 InterpretingError::DivByZero,
2634 None,
2635 pos,
2636 ))
2637 }else {
2638 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2639 data_object.set_double((left_value / right_value as f64).ceil())
2640 }).unwrap()))
2641 }
2642 },
2643
2644 DataValue::Long(right_value) => {
2645 if right_value == 0 {
2646 Some(interpreter.set_errno_error_object(
2647 InterpretingError::DivByZero,
2648 None,
2649 pos,
2650 ))
2651 }else {
2652 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2653 data_object.set_double((left_value / right_value as f64).ceil())
2654 }).unwrap()))
2655 }
2656 },
2657
2658 DataValue::Float(right_value) => {
2659 if right_value == 0.0 {
2660 Some(interpreter.set_errno_error_object(
2661 InterpretingError::DivByZero,
2662 None,
2663 pos,
2664 ))
2665 }else {
2666 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2667 data_object.set_double((left_value / right_value as f64).ceil())
2668 }).unwrap()))
2669 }
2670 },
2671
2672 DataValue::Double(right_value) => {
2673 if right_value == 0.0 {
2674 Some(interpreter.set_errno_error_object(
2675 InterpretingError::DivByZero,
2676 None,
2677 pos,
2678 ))
2679 }else {
2680 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2681 data_object.set_double((left_value / right_value).ceil())
2682 }).unwrap()))
2683 }
2684 },
2685
2686 _ => None,
2687 }
2688 },
2689
2690 _ => None,
2691 }
2692}
2693pub fn op_mod(
2697 interpreter: &mut Interpreter,
2698 left_side_operand: &DataObjectRef,
2699 right_side_operand: &DataObjectRef,
2700 pos: CodePosition,
2701) -> OptionDataObjectRef {
2702 let ret = call_operator_method_2_arg(
2703 interpreter,
2704 "mod",
2705 true,
2706 left_side_operand,
2707 right_side_operand,
2708 pos,
2709 );
2710 if let Some(ret) = ret {
2711 return Some(ret);
2712 }
2713
2714 match &left_side_operand.data_value() {
2715 DataValue::Int(left_value) => {
2716 match right_side_operand.data_value() {
2717 DataValue::Int(right_value) => {
2718 if right_value == 0 {
2719 Some(interpreter.set_errno_error_object(
2720 InterpretingError::DivByZero,
2721 None,
2722 pos,
2723 ))
2724 }else {
2725 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2726 data_object.set_int(left_value.wrapping_rem(right_value))
2727 }).unwrap()))
2728 }
2729 },
2730
2731 DataValue::Long(right_value) => {
2732 if right_value == 0 {
2733 Some(interpreter.set_errno_error_object(
2734 InterpretingError::DivByZero,
2735 None,
2736 pos,
2737 ))
2738 }else {
2739 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2740 data_object.set_long((*left_value as i64).wrapping_rem(right_value))
2741 }).unwrap()))
2742 }
2743 },
2744
2745 DataValue::Float(right_value) => {
2746 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2747 data_object.set_float(*left_value as f32 % right_value)
2748 }).unwrap()))
2749 },
2750
2751 DataValue::Double(right_value) => {
2752 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2753 data_object.set_double(*left_value as f64 % right_value)
2754 }).unwrap()))
2755 },
2756
2757 _ => None,
2758 }
2759 },
2760
2761 DataValue::Long(left_value) => {
2762 match right_side_operand.data_value() {
2763 DataValue::Int(right_value) => {
2764 if right_value == 0 {
2765 Some(interpreter.set_errno_error_object(
2766 InterpretingError::DivByZero,
2767 None,
2768 pos,
2769 ))
2770 }else {
2771 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2772 data_object.set_long(left_value.wrapping_rem(right_value as i64))
2773 }).unwrap()))
2774 }
2775 },
2776
2777 DataValue::Long(right_value) => {
2778 if right_value == 0 {
2779 Some(interpreter.set_errno_error_object(
2780 InterpretingError::DivByZero,
2781 None,
2782 pos,
2783 ))
2784 }else {
2785 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2786 data_object.set_long(left_value.wrapping_rem(right_value))
2787 }).unwrap()))
2788 }
2789 },
2790
2791 DataValue::Float(right_value) => {
2792 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2793 data_object.set_float(*left_value as f32 % right_value)
2794 }).unwrap()))
2795 },
2796
2797 DataValue::Double(right_value) => {
2798 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2799 data_object.set_double(*left_value as f64 % right_value)
2800 }).unwrap()))
2801 },
2802
2803 _ => None,
2804 }
2805 },
2806
2807 DataValue::Float(left_value) => {
2808 match right_side_operand.data_value() {
2809 DataValue::Int(right_value) => {
2810 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2811 data_object.set_float(left_value % right_value as f32)
2812 }).unwrap()))
2813 },
2814
2815 DataValue::Long(right_value) => {
2816 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2817 data_object.set_float(left_value % right_value as f32)
2818 }).unwrap()))
2819 },
2820
2821 DataValue::Float(right_value) => {
2822 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2823 data_object.set_float(left_value % right_value)
2824 }).unwrap()))
2825 },
2826
2827 DataValue::Double(right_value) => {
2828 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2829 data_object.set_double(*left_value as f64 % right_value)
2830 }).unwrap()))
2831 },
2832
2833 _ => None,
2834 }
2835 },
2836
2837 DataValue::Double(left_value) => {
2838 match right_side_operand.data_value() {
2839 DataValue::Int(right_value) => {
2840 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2841 data_object.set_double(left_value % right_value as f64)
2842 }).unwrap()))
2843 },
2844
2845 DataValue::Long(right_value) => {
2846 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2847 data_object.set_double(left_value % right_value as f64)
2848 }).unwrap()))
2849 },
2850
2851 DataValue::Float(right_value) => {
2852 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2853 data_object.set_double(left_value % right_value as f64)
2854 }).unwrap()))
2855 },
2856
2857 DataValue::Double(right_value) => {
2858 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2859 data_object.set_double(left_value % right_value)
2860 }).unwrap()))
2861 },
2862
2863 _ => None,
2864 }
2865 },
2866
2867 DataValue::Text(left_value) => {
2868 let right_value = right_side_operand.array_value()?.borrow().clone();
2869
2870 Some(interpreter.format_text(left_value, &right_value))
2871 },
2872
2873 _ => None,
2874 }
2875}
2876pub fn op_and(
2880 interpreter: &mut Interpreter,
2881 left_side_operand: &DataObjectRef,
2882 right_side_operand: &DataObjectRef,
2883 pos: CodePosition,
2884) -> OptionDataObjectRef {
2885 let ret = call_operator_method_2_arg(
2886 interpreter,
2887 "and",
2888 true,
2889 left_side_operand,
2890 right_side_operand,
2891 pos,
2892 );
2893 if let Some(ret) = ret {
2894 return Some(ret);
2895 }
2896
2897 match left_side_operand.data_value() {
2898 DataValue::Int(left_value) => {
2899 match right_side_operand.data_value() {
2900 DataValue::Int(right_value) => {
2901 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2902 data_object.set_int(left_value & right_value)
2903 }).unwrap()))
2904 },
2905
2906 DataValue::Long(right_value) => {
2907 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2908 data_object.set_long(left_value as i64 & right_value)
2909 }).unwrap()))
2910 },
2911
2912 _ => None,
2913 }
2914 },
2915
2916 DataValue::Long(left_value) => {
2917 match right_side_operand.data_value() {
2918 DataValue::Int(right_value) => {
2919 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2920 data_object.set_long(left_value & right_value as i64)
2921 }).unwrap()))
2922 },
2923
2924 DataValue::Long(right_value) => {
2925 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2926 data_object.set_long(left_value & right_value)
2927 }).unwrap()))
2928 },
2929
2930 _ => None,
2931 }
2932 },
2933
2934 _ => None,
2935 }
2936}
2937pub fn op_or(
2941 interpreter: &mut Interpreter,
2942 left_side_operand: &DataObjectRef,
2943 right_side_operand: &DataObjectRef,
2944 pos: CodePosition,
2945) -> OptionDataObjectRef {
2946 let ret = call_operator_method_2_arg(
2947 interpreter,
2948 "or",
2949 true,
2950 left_side_operand,
2951 right_side_operand,
2952 pos,
2953 );
2954 if let Some(ret) = ret {
2955 return Some(ret);
2956 }
2957
2958 if let Some(right_value) = right_side_operand.function_pointer_value() {
2959 return interpreter.call_function_pointer(
2960 &right_value,
2961 right_side_operand.variable_name().as_deref(),
2962 std::slice::from_ref(left_side_operand),
2963 pos
2964 );
2965 }
2966
2967 match left_side_operand.data_value() {
2968 DataValue::Int(left_value) => {
2969 match right_side_operand.data_value() {
2970 DataValue::Int(right_value) => {
2971 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2972 data_object.set_int(left_value | right_value)
2973 }).unwrap()))
2974 },
2975
2976 DataValue::Long(right_value) => {
2977 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2978 data_object.set_long(left_value as i64 | right_value)
2979 }).unwrap()))
2980 },
2981
2982 _ => None,
2983 }
2984 },
2985
2986 DataValue::Long(left_value) => {
2987 match right_side_operand.data_value() {
2988 DataValue::Int(right_value) => {
2989 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2990 data_object.set_long(left_value | right_value as i64)
2991 }).unwrap()))
2992 },
2993
2994 DataValue::Long(right_value) => {
2995 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
2996 data_object.set_long(left_value | right_value)
2997 }).unwrap()))
2998 },
2999
3000 _ => None,
3001 }
3002 },
3003
3004 _ => None,
3005 }
3006}
3007pub fn op_xor(
3011 interpreter: &mut Interpreter,
3012 left_side_operand: &DataObjectRef,
3013 right_side_operand: &DataObjectRef,
3014 pos: CodePosition,
3015) -> OptionDataObjectRef {
3016 let ret = call_operator_method_2_arg(
3017 interpreter,
3018 "xor",
3019 true,
3020 left_side_operand,
3021 right_side_operand,
3022 pos,
3023 );
3024 if let Some(ret) = ret {
3025 return Some(ret);
3026 }
3027
3028 match left_side_operand.data_value() {
3029 DataValue::Int(left_value) => {
3030 match right_side_operand.data_value() {
3031 DataValue::Int(right_value) => {
3032 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3033 data_object.set_int(left_value ^ right_value)
3034 }).unwrap()))
3035 },
3036
3037 DataValue::Long(right_value) => {
3038 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3039 data_object.set_long(left_value as i64 ^ right_value)
3040 }).unwrap()))
3041 },
3042
3043 _ => None,
3044 }
3045 },
3046
3047 DataValue::Long(left_value) => {
3048 match right_side_operand.data_value() {
3049 DataValue::Int(right_value) => {
3050 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3051 data_object.set_long(left_value ^ right_value as i64)
3052 }).unwrap()))
3053 },
3054
3055 DataValue::Long(right_value) => {
3056 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3057 data_object.set_long(left_value ^ right_value)
3058 }).unwrap()))
3059 },
3060
3061 _ => None,
3062 }
3063 },
3064
3065 _ => None,
3066 }
3067}
3068pub fn op_not(
3072 interpreter: &mut Interpreter,
3073 operand: &DataObjectRef,
3074 pos: CodePosition,
3075) -> OptionDataObjectRef {
3076 let ret = call_operator_method_1_arg(
3077 interpreter,
3078 "not",
3079 operand,
3080 pos,
3081 );
3082 if let Some(ret) = ret {
3083 return Some(ret);
3084 }
3085
3086 match operand.data_value() {
3087 DataValue::Int(value) => {
3088 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3089 data_object.set_int(!value)
3090 }).unwrap()))
3091 },
3092
3093 DataValue::Long(value) => {
3094 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3095 data_object.set_long(!value)
3096 }).unwrap()))
3097 },
3098
3099 _ => None,
3100 }
3101}
3102pub fn op_lshift(
3106 interpreter: &mut Interpreter,
3107 left_side_operand: &DataObjectRef,
3108 right_side_operand: &DataObjectRef,
3109 pos: CodePosition,
3110) -> OptionDataObjectRef {
3111 let ret = call_operator_method_2_arg(
3112 interpreter,
3113 "lshift",
3114 true,
3115 left_side_operand,
3116 right_side_operand,
3117 pos,
3118 );
3119 if let Some(ret) = ret {
3120 return Some(ret);
3121 }
3122
3123 match left_side_operand.data_value() {
3124 DataValue::Int(left_value) => {
3125 match right_side_operand.data_value() {
3126 DataValue::Int(right_value) => {
3127 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3128 data_object.set_int(left_value.wrapping_shl(right_value as u32))
3129 }).unwrap()))
3130 },
3131
3132 DataValue::Long(right_value) => {
3133 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3134 data_object.set_long((left_value as i64).wrapping_shl(right_value as u32))
3135 }).unwrap()))
3136 },
3137
3138 _ => None,
3139 }
3140 },
3141
3142 DataValue::Long(left_value) => {
3143 match right_side_operand.data_value() {
3144 DataValue::Int(right_value) => {
3145 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3146 data_object.set_long(left_value.wrapping_shl(right_value as u32))
3147 }).unwrap()))
3148 },
3149
3150 DataValue::Long(right_value) => {
3151 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3152 data_object.set_long(left_value.wrapping_shl(right_value as u32))
3153 }).unwrap()))
3154 },
3155
3156 _ => None,
3157 }
3158 },
3159
3160 _ => None,
3161 }
3162}
3163pub fn op_rshift(
3167 interpreter: &mut Interpreter,
3168 left_side_operand: &DataObjectRef,
3169 right_side_operand: &DataObjectRef,
3170 pos: CodePosition,
3171) -> OptionDataObjectRef {
3172 let ret = call_operator_method_2_arg(
3173 interpreter,
3174 "rshift",
3175 true,
3176 left_side_operand,
3177 right_side_operand,
3178 pos,
3179 );
3180 if let Some(ret) = ret {
3181 return Some(ret);
3182 }
3183
3184 if let Some(right_value) = right_side_operand.function_pointer_value() {
3185 return interpreter.call_function_pointer(
3186 &right_value,
3187 right_side_operand.variable_name().as_deref(),
3188 std::slice::from_ref(left_side_operand),
3189 pos
3190 );
3191 }
3192
3193 match left_side_operand.data_value() {
3194 DataValue::Int(left_value) => {
3195 match right_side_operand.data_value() {
3196 DataValue::Int(right_value) => {
3197 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3198 data_object.set_int(left_value.wrapping_shr(right_value as u32))
3199 }).unwrap()))
3200 },
3201
3202 DataValue::Long(right_value) => {
3203 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3204 data_object.set_long((left_value as i64).wrapping_shr(right_value as u32))
3205 }).unwrap()))
3206 },
3207
3208 _ => None,
3209 }
3210 },
3211
3212 DataValue::Long(left_value) => {
3213 match right_side_operand.data_value() {
3214 DataValue::Int(right_value) => {
3215 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3216 data_object.set_long(left_value.wrapping_shr(right_value as u32))
3217 }).unwrap()))
3218 },
3219
3220 DataValue::Long(right_value) => {
3221 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3222 data_object.set_long(left_value.wrapping_shr(right_value as u32))
3223 }).unwrap()))
3224 },
3225
3226 _ => None,
3227 }
3228 },
3229
3230 _ => None,
3231 }
3232}
3233pub fn op_rzshift(
3237 interpreter: &mut Interpreter,
3238 left_side_operand: &DataObjectRef,
3239 right_side_operand: &DataObjectRef,
3240 pos: CodePosition,
3241) -> OptionDataObjectRef {
3242 let ret = call_operator_method_2_arg(
3243 interpreter,
3244 "rzshift",
3245 true,
3246 left_side_operand,
3247 right_side_operand,
3248 pos,
3249 );
3250 if let Some(ret) = ret {
3251 return Some(ret);
3252 }
3253
3254 if let Some(right_value) = right_side_operand.function_pointer_value()
3255 && let Some(left_value) = left_side_operand.array_value() {
3256 return interpreter.call_function_pointer(
3257 &right_value,
3258 right_side_operand.variable_name().as_deref(),
3259 &utils::separate_arguments_with_argument_separators(&left_value.borrow()),
3260 pos
3261 );
3262 }
3263
3264 match left_side_operand.data_value() {
3265 DataValue::Int(left_value) => {
3266 match right_side_operand.data_value() {
3267 DataValue::Int(right_value) => {
3268 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3269 data_object.set_int((left_value as u32).wrapping_shr(right_value as u32) as i32)
3270 }).unwrap()))
3271 },
3272
3273 DataValue::Long(right_value) => {
3274 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3275 data_object.set_long((left_value as i64 as u64).wrapping_shr(right_value as u32) as i64)
3276 }).unwrap()))
3277 },
3278
3279 _ => None,
3280 }
3281 },
3282
3283 DataValue::Long(left_value) => {
3284 match right_side_operand.data_value() {
3285 DataValue::Int(right_value) => {
3286 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3287 data_object.set_long((left_value as u64).wrapping_shr(right_value as u32) as i64)
3288 }).unwrap()))
3289 },
3290
3291 DataValue::Long(right_value) => {
3292 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3293 data_object.set_long((left_value as u64).wrapping_shr(right_value as u32) as i64)
3294 }).unwrap()))
3295 },
3296
3297 _ => None,
3298 }
3299 },
3300
3301 _ => None,
3302 }
3303}
3304
3305pub fn op_cast(
3309 interpreter: &mut Interpreter,
3310 left_side_operand: &DataObjectRef,
3311 right_side_operand: &DataObjectRef,
3312 pos: CodePosition,
3313) -> OptionDataObjectRef {
3314 let type_value = left_side_operand.type_value()?;
3315
3316 match type_value {
3317 DataType::TEXT => {
3318 let value = conversions::to_text(interpreter, right_side_operand, pos);
3319
3320 Some(DataObjectRef::new(DataObject::new_text(value)))
3321 },
3322
3323 DataType::CHAR => {
3324 let value = conversions::to_char(interpreter, right_side_operand, pos)?;
3325
3326 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3327 data_object.set_char(value)
3328 }).unwrap()))
3329 },
3330
3331 DataType::INT => {
3332 let value = conversions::to_int(interpreter, right_side_operand, pos)?;
3333
3334 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3335 data_object.set_int(value)
3336 }).unwrap()))
3337 },
3338
3339 DataType::LONG => {
3340 let value = conversions::to_long(interpreter, right_side_operand, pos)?;
3341
3342 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3343 data_object.set_long(value)
3344 }).unwrap()))
3345 },
3346
3347 DataType::FLOAT => {
3348 let value = conversions::to_float(interpreter, right_side_operand, pos)?;
3349
3350 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3351 data_object.set_float(value)
3352 }).unwrap()))
3353 },
3354
3355 DataType::DOUBLE => {
3356 let value = conversions::to_double(interpreter, right_side_operand, pos)?;
3357
3358 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3359 data_object.set_double(value)
3360 }).unwrap()))
3361 },
3362
3363 DataType::BYTE_BUFFER => {
3364 let value = conversions::to_byte_buffer(interpreter, right_side_operand, pos)?;
3365
3366 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3367 data_object.set_byte_buffer(value)
3368 }).unwrap()))
3369 },
3370
3371 DataType::ARRAY => {
3372 let value = conversions::to_array(interpreter, right_side_operand, pos)?;
3373
3374 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3375 data_object.set_array(value)
3376 }).unwrap()))
3377 },
3378
3379 DataType::LIST => {
3380 let value = conversions::to_list(interpreter, right_side_operand, pos)?;
3381
3382 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3383 data_object.set_list(value)
3384 }).unwrap()))
3385 },
3386
3387 _ => None,
3388 }
3389}
3390pub fn op_get_item(
3394 interpreter: &mut Interpreter,
3395 left_side_operand: &DataObjectRef,
3396 right_side_operand: &DataObjectRef,
3397 pos: CodePosition,
3398) -> OptionDataObjectRef {
3399 let ret = call_operator_method_2_arg(
3400 interpreter,
3401 "getItem",
3402 false,
3403 left_side_operand,
3404 right_side_operand,
3405 pos,
3406 );
3407 if let Some(ret) = ret {
3408 return Some(ret);
3409 }
3410
3411 match &left_side_operand.data_value() {
3412 DataValue::ByteBuffer(left_value) => {
3413 let right_value = right_side_operand.int_value()? as isize;
3414
3415 let len = left_value.borrow().len();
3416 let index = if right_value < 0 {
3417 right_value.wrapping_add(len as isize)
3418 }else {
3419 right_value
3420 };
3421
3422 if index < 0 || index as usize >= len {
3423 return Some(interpreter.set_errno_error_object(
3424 InterpretingError::IndexOutOfBounds,
3425 None,
3426 pos,
3427 ));
3428 }
3429
3430 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3431 data_object.set_int(left_value.borrow()[index as usize] as i8 as i32)
3432 }).unwrap()))
3433 },
3434
3435 DataValue::Array(left_value) => {
3436 let right_value = right_side_operand.int_value()? as isize;
3437
3438 let len = left_value.borrow().len();
3439 let index = if right_value < 0 {
3440 right_value.wrapping_add(len as isize)
3441 }else {
3442 right_value
3443 };
3444
3445 if index < 0 || index as usize >= len {
3446 return Some(interpreter.set_errno_error_object(
3447 InterpretingError::IndexOutOfBounds,
3448 None,
3449 pos,
3450 ));
3451 }
3452
3453 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3454 data_object.set_data(&left_value.borrow()[index as usize].borrow())
3455 }).unwrap()))
3456 },
3457
3458 DataValue::List(left_value) => {
3459 let right_value = right_side_operand.int_value()? as isize;
3460
3461 let len = left_value.borrow().len();
3462 let index = if right_value < 0 {
3463 right_value.wrapping_add(len as isize)
3464 }else {
3465 right_value
3466 };
3467
3468 if index < 0 || index as usize >= len {
3469 return Some(interpreter.set_errno_error_object(
3470 InterpretingError::IndexOutOfBounds,
3471 None,
3472 pos,
3473 ));
3474 }
3475
3476 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3477 data_object.set_data(&left_value.borrow()[index as usize].borrow())
3478 }).unwrap()))
3479 },
3480
3481 DataValue::Text(left_value) => {
3482 let right_value = right_side_operand.int_value()? as isize;
3483
3484 let len = left_value.chars().count();
3485 let index = if right_value < 0 {
3486 right_value.wrapping_add(len as isize)
3487 }else {
3488 right_value
3489 };
3490
3491 if index < 0 || index as usize >= len {
3492 return Some(interpreter.set_errno_error_object(
3493 InterpretingError::IndexOutOfBounds,
3494 None,
3495 pos,
3496 ));
3497 }
3498
3499 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3500 data_object.set_char(left_value.chars().nth(index as usize).unwrap())
3501 }).unwrap()))
3502 },
3503
3504 DataValue::Char(left_value) => {
3505 let right_value = right_side_operand.int_value()? as isize;
3506
3507 let index = if right_value < 0 {
3508 right_value.wrapping_add(1)
3509 }else {
3510 right_value
3511 };
3512
3513 if index < 0 {
3514 return Some(interpreter.set_errno_error_object(
3515 InterpretingError::IndexOutOfBounds,
3516 None,
3517 pos,
3518 ));
3519 }
3520
3521 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3522 data_object.set_char(*left_value)
3523 }).unwrap()))
3524 },
3525
3526 DataValue::Struct(left_value) => {
3527 let right_value = right_side_operand.text_value()?;
3528
3529 let ret = left_value.get_member(&right_value);
3530 match ret {
3531 Ok(ret) => {
3532 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3533 data_object.set_data(&ret.borrow())
3534 }).unwrap()))
3535 },
3536
3537 Err(e) => {
3538 Some(interpreter.set_errno_error_object(
3539 InterpretingError::IncompatibleDataType,
3540 Some(e.message()),
3541 pos,
3542 ))
3543 },
3544 }
3545 },
3546
3547 _ => None,
3548 }
3549}
3550pub fn op_optional_get_item(
3554 interpreter: &mut Interpreter,
3555 left_side_operand: &DataObjectRef,
3556 right_side_operand: &DataObjectRef,
3557 pos: CodePosition,
3558) -> OptionDataObjectRef {
3559 if matches!(left_side_operand.data_type(), DataType::NULL | DataType::VOID) {
3560 Some(DataObjectRef::new(DataObject::new_void()))
3561 }else {
3562 op_get_item(interpreter, left_side_operand, right_side_operand, pos)
3563 }
3564}
3565pub fn op_slice(
3569 interpreter: &mut Interpreter,
3570 left_side_operand: &DataObjectRef,
3571 middle_operand: &DataObjectRef,
3572 right_side_operand: &DataObjectRef,
3573 pos: CodePosition,
3574) -> OptionDataObjectRef {
3575 let ret = call_operator_method_3_arg(
3576 interpreter,
3577 "slice",
3578 left_side_operand,
3579 middle_operand,
3580 right_side_operand,
3581 pos,
3582 );
3583 if let Some(ret) = ret {
3584 return Some(ret);
3585 }
3586
3587 match &left_side_operand.data_value() {
3588 DataValue::ByteBuffer(left_value) => {
3589 let len = left_value.borrow().len();
3590
3591 let middle_value = middle_operand.int_value().
3592 or_else(|| (middle_operand.data_type() == DataType::VOID).then_some(0))? as isize;
3593
3594 let right_value = right_side_operand.int_value().map(|i| i as isize).
3595 or_else(|| (right_side_operand.data_type() == DataType::VOID).then_some(len as isize))?;
3596
3597 let from_index = if middle_value < 0 {
3598 middle_value.wrapping_add(len as isize)
3599 }else {
3600 middle_value
3601 };
3602
3603 let to_index = if right_value < 0 {
3604 right_value.wrapping_add(len as isize)
3605 }else {
3606 right_value
3607 };
3608
3609 if from_index < 0 || from_index as usize >= len {
3610 return Some(interpreter.set_errno_error_object(
3611 InterpretingError::IndexOutOfBounds,
3612 Some("For slice from index"),
3613 pos,
3614 ));
3615 }
3616
3617 if to_index < 0 || to_index as usize > len {
3618 return Some(interpreter.set_errno_error_object(
3619 InterpretingError::IndexOutOfBounds,
3620 Some("For slice to index"),
3621 pos,
3622 ));
3623 }
3624
3625 if to_index < from_index {
3626 return Some(interpreter.set_errno_error_object(
3627 InterpretingError::IndexOutOfBounds,
3628 Some("to index is less than from index"),
3629 pos,
3630 ));
3631 }
3632
3633 let from_index = from_index as usize;
3634 let to_index = to_index as usize;
3635
3636 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3637 data_object.set_byte_buffer(Box::from(&left_value.borrow()[from_index..to_index]))
3638 }).unwrap()))
3639 },
3640
3641 DataValue::Array(left_value) => {
3642 let len = left_value.borrow().len();
3643
3644 let middle_value = middle_operand.int_value().
3645 or_else(|| (middle_operand.data_type() == DataType::VOID).then_some(0))? as isize;
3646
3647 let right_value = right_side_operand.int_value().map(|i| i as isize).
3648 or_else(|| (right_side_operand.data_type() == DataType::VOID).then_some(len as isize))?;
3649
3650 let from_index = if middle_value < 0 {
3651 middle_value.wrapping_add(len as isize)
3652 }else {
3653 middle_value
3654 };
3655
3656 let to_index = if right_value < 0 {
3657 right_value.wrapping_add(len as isize)
3658 }else {
3659 right_value
3660 };
3661
3662 if from_index < 0 || from_index as usize >= len {
3663 return Some(interpreter.set_errno_error_object(
3664 InterpretingError::IndexOutOfBounds,
3665 Some("For slice from index"),
3666 pos,
3667 ));
3668 }
3669
3670 if to_index < 0 || to_index as usize > len {
3671 return Some(interpreter.set_errno_error_object(
3672 InterpretingError::IndexOutOfBounds,
3673 Some("For slice to index"),
3674 pos,
3675 ));
3676 }
3677
3678 if to_index < from_index {
3679 return Some(interpreter.set_errno_error_object(
3680 InterpretingError::IndexOutOfBounds,
3681 Some("to index is less than from index"),
3682 pos,
3683 ));
3684 }
3685
3686 let from_index = from_index as usize;
3687 let to_index = to_index as usize;
3688
3689 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3690 data_object.set_array(Box::from(&left_value.borrow()[from_index..to_index]))
3691 }).unwrap()))
3692 },
3693
3694 DataValue::List(left_value) => {
3695 let len = left_value.borrow().len();
3696
3697 let middle_value = middle_operand.int_value().
3698 or_else(|| (middle_operand.data_type() == DataType::VOID).then_some(0))? as isize;
3699
3700 let right_value = right_side_operand.int_value().map(|i| i as isize).
3701 or_else(|| (right_side_operand.data_type() == DataType::VOID).then_some(len as isize))?;
3702
3703 let from_index = if middle_value < 0 {
3704 middle_value.wrapping_add(len as isize)
3705 }else {
3706 middle_value
3707 };
3708
3709 let to_index = if right_value < 0 {
3710 right_value.wrapping_add(len as isize)
3711 }else {
3712 right_value
3713 };
3714
3715 if from_index < 0 || from_index as usize >= len {
3716 return Some(interpreter.set_errno_error_object(
3717 InterpretingError::IndexOutOfBounds,
3718 Some("For slice from index"),
3719 pos,
3720 ));
3721 }
3722
3723 if to_index < 0 || to_index as usize > len {
3724 return Some(interpreter.set_errno_error_object(
3725 InterpretingError::IndexOutOfBounds,
3726 Some("For slice to index"),
3727 pos,
3728 ));
3729 }
3730
3731 if to_index < from_index {
3732 return Some(interpreter.set_errno_error_object(
3733 InterpretingError::IndexOutOfBounds,
3734 Some("to index is less than from index"),
3735 pos,
3736 ));
3737 }
3738
3739 let from_index = from_index as usize;
3740 let to_index = to_index as usize;
3741
3742 let list = left_value.borrow().iter().
3743 take(to_index).
3744 skip(from_index).
3745 cloned().
3746 collect::<VecDeque<_>>();
3747
3748 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3749 data_object.set_list(list)
3750 }).unwrap()))
3751 },
3752
3753 DataValue::Text(left_value) => {
3754 let len = left_value.chars().count();
3755
3756 let middle_value = middle_operand.int_value().
3757 or_else(|| (middle_operand.data_type() == DataType::VOID).then_some(0))? as isize;
3758
3759 let right_value = right_side_operand.int_value().map(|i| i as isize).
3760 or_else(|| (right_side_operand.data_type() == DataType::VOID).then_some(len as isize))?;
3761
3762 let from_index = if middle_value < 0 {
3763 middle_value.wrapping_add(len as isize)
3764 }else {
3765 middle_value
3766 };
3767
3768 let to_index = if right_value < 0 {
3769 right_value.wrapping_add(len as isize)
3770 }else {
3771 right_value
3772 };
3773
3774 if from_index < 0 || from_index as usize >= len {
3775 return Some(interpreter.set_errno_error_object(
3776 InterpretingError::IndexOutOfBounds,
3777 Some("For slice from index"),
3778 pos,
3779 ));
3780 }
3781
3782 if to_index < 0 || to_index as usize > len {
3783 return Some(interpreter.set_errno_error_object(
3784 InterpretingError::IndexOutOfBounds,
3785 Some("For slice to index"),
3786 pos,
3787 ));
3788 }
3789
3790 if to_index < from_index {
3791 return Some(interpreter.set_errno_error_object(
3792 InterpretingError::IndexOutOfBounds,
3793 Some("to index is less than from index"),
3794 pos,
3795 ));
3796 }
3797
3798 let from_index = from_index as usize;
3799 let to_index = to_index as usize;
3800
3801 let text = left_value.chars().
3802 take(to_index).
3803 skip(from_index).
3804 collect::<Box<str>>();
3805
3806 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3807 data_object.set_text(text)
3808 }).unwrap()))
3809 },
3810
3811 DataValue::Char(left_value) => {
3812 let middle_value = middle_operand.int_value().
3813 or_else(|| (middle_operand.data_type() == DataType::VOID).then_some(0))? as isize;
3814
3815 let right_value = right_side_operand.int_value().map(|i| i as isize).
3816 or_else(|| (right_side_operand.data_type() == DataType::VOID).then_some(1))?;
3817
3818 let from_index = if middle_value < 0 {
3819 middle_value.wrapping_add(1)
3820 }else {
3821 middle_value
3822 };
3823
3824 let to_index = if right_value < 0 {
3825 right_value.wrapping_add(1)
3826 }else {
3827 right_value
3828 };
3829
3830 if from_index != 0 {
3831 return Some(interpreter.set_errno_error_object(
3832 InterpretingError::IndexOutOfBounds,
3833 Some("For slice from index"),
3834 pos,
3835 ));
3836 }
3837
3838 if to_index != 0 && to_index != 1 {
3839 return Some(interpreter.set_errno_error_object(
3840 InterpretingError::IndexOutOfBounds,
3841 Some("For slice to index"),
3842 pos,
3843 ));
3844 }
3845
3846 if to_index == 0 {
3847 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3848 data_object.set_text("")
3849 }).unwrap()))
3850 }else {
3851 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
3852 data_object.set_char(*left_value)
3853 }).unwrap()))
3854 }
3855 },
3856
3857 _ => None,
3858 }
3859}
3860pub fn op_optional_slice(
3864 interpreter: &mut Interpreter,
3865 left_side_operand: &DataObjectRef,
3866 middle_operand: &DataObjectRef,
3867 right_side_operand: &DataObjectRef,
3868 pos: CodePosition,
3869) -> OptionDataObjectRef {
3870 if matches!(left_side_operand.data_type(), DataType::NULL | DataType::VOID) {
3871 Some(DataObjectRef::new(DataObject::new_void()))
3872 }else {
3873 op_slice(interpreter, left_side_operand, middle_operand, right_side_operand, pos)
3874 }
3875}
3876pub fn op_set_item(
3878 interpreter: &mut Interpreter,
3879 left_side_operand: &DataObjectRef,
3880 middle_operand: &DataObjectRef,
3881 right_side_operand: &DataObjectRef,
3882 pos: CodePosition,
3883) -> OptionDataObjectRef {
3884 let ret = call_operator_method_3_arg(
3885 interpreter,
3886 "setItem",
3887 left_side_operand,
3888 middle_operand,
3889 right_side_operand,
3890 pos,
3891 );
3892 if let Some(ret) = ret {
3893 return Some(ret);
3894 }
3895
3896 match &left_side_operand.data_value() {
3897 DataValue::ByteBuffer(left_value) => {
3898 let middle_value = middle_operand.int_value()? as isize;
3899
3900 let len = left_value.borrow().len();
3901 let index = if middle_value < 0 {
3902 middle_value.wrapping_add(len as isize)
3903 }else {
3904 middle_value
3905 };
3906
3907 if index < 0 || index as usize >= len {
3908 return Some(interpreter.set_errno_error_object(
3909 InterpretingError::IndexOutOfBounds,
3910 None,
3911 pos,
3912 ));
3913 }
3914
3915 let value_number = conversions::to_number(interpreter, right_side_operand, pos);
3916 let Some(value_number) = value_number else {
3917 return Some(interpreter.set_errno_error_object(
3918 InterpretingError::NoNum,
3919 None,
3920 pos,
3921 ));
3922 };
3923 let value = value_number.int_value() as u8;
3924
3925 left_value.borrow_mut()[index as usize] = value;
3926
3927 Some(DataObjectRef::new(DataObject::new_void()))
3928 },
3929
3930 DataValue::Array(left_value) => {
3931 let middle_value = middle_operand.int_value()? as isize;
3932
3933 let len = left_value.borrow().len();
3934 let index = if middle_value < 0 {
3935 middle_value.wrapping_add(len as isize)
3936 }else {
3937 middle_value
3938 };
3939
3940 if index < 0 || index as usize >= len {
3941 return Some(interpreter.set_errno_error_object(
3942 InterpretingError::IndexOutOfBounds,
3943 None,
3944 pos,
3945 ));
3946 }
3947
3948 let value = DataObjectRef::new(DataObject::with_update(|data_object| {
3949 data_object.set_data(&right_side_operand.borrow())
3950 }).unwrap());
3951
3952 left_value.borrow_mut()[index as usize] = value;
3953
3954 Some(DataObjectRef::new(DataObject::new_void()))
3955 },
3956
3957 DataValue::List(left_value) => {
3958 let middle_value = middle_operand.int_value()? as isize;
3959
3960 let len = left_value.borrow().len();
3961 let index = if middle_value < 0 {
3962 middle_value.wrapping_add(len as isize)
3963 }else {
3964 middle_value
3965 };
3966
3967 if index < 0 || index as usize >= len {
3968 return Some(interpreter.set_errno_error_object(
3969 InterpretingError::IndexOutOfBounds,
3970 None,
3971 pos,
3972 ));
3973 }
3974
3975 let value = DataObjectRef::new(DataObject::with_update(|data_object| {
3976 data_object.set_data(&right_side_operand.borrow())
3977 }).unwrap());
3978
3979 left_value.borrow_mut()[index as usize] = value;
3980
3981 Some(DataObjectRef::new(DataObject::new_void()))
3982 },
3983
3984 DataValue::Struct(left_value) => {
3985 let middle_value = middle_operand.text_value()?;
3986
3987 let ret = left_value.set_member(&middle_value, &right_side_operand.borrow());
3988 if let Err(e) = ret {
3989 Some(interpreter.set_errno_error_object(
3990 InterpretingError::IncompatibleDataType,
3991 Some(e.message()),
3992 pos,
3993 ))
3994 }else {
3995 Some(DataObjectRef::new(DataObject::new_void()))
3996 }
3997 },
3998
3999 _ => None,
4000 }
4001}
4002
4003pub fn op_abs(
4007 interpreter: &mut Interpreter,
4008 operand: &DataObjectRef,
4009 pos: CodePosition,
4010) -> OptionDataObjectRef {
4011 let ret = call_operator_method_1_arg(
4012 interpreter,
4013 "abs",
4014 operand,
4015 pos,
4016 );
4017 if let Some(ret) = ret {
4018 return Some(ret);
4019 }
4020
4021 match operand.data_value() {
4022 DataValue::Int(value) => {
4023 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
4024 data_object.set_int(value.wrapping_abs())
4025 }).unwrap()))
4026 },
4027
4028 DataValue::Long(value) => {
4029 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
4030 data_object.set_long(value.wrapping_abs())
4031 }).unwrap()))
4032 },
4033
4034 DataValue::Float(value) => {
4035 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
4036 data_object.set_float(value.abs())
4037 }).unwrap()))
4038 },
4039
4040 DataValue::Double(value) => {
4041 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
4042 data_object.set_double(value.abs())
4043 }).unwrap()))
4044 },
4045
4046 _ => None,
4047 }
4048}
4049pub fn op_iter(
4051 interpreter: &mut Interpreter,
4052 operand: &DataObjectRef,
4053 pos: CodePosition,
4054) -> OptionDataObjectRef {
4055 let ret = call_operator_method_1_arg(
4056 interpreter,
4057 "iter",
4058 operand,
4059 pos,
4060 );
4061 if let Some(ret) = ret {
4062 return Some(ret);
4063 }
4064
4065 match operand.data_value() {
4066 DataValue::ByteBuffer(_) |
4067 DataValue::Array(_) |
4068 DataValue::List(_) |
4069 DataValue::Struct(_) |
4070 DataValue::Text(_) => {
4071 let basic_iterator_class = interpreter.standard_types.get("&BasicIterator").unwrap().object_value().unwrap();
4072
4073 Some(interpreter.call_constructor(&basic_iterator_class, std::slice::from_ref(operand), pos))
4074 },
4075
4076 _ => None,
4077 }
4078}
4079pub fn op_has_next(
4081 interpreter: &mut Interpreter,
4082 operand: &DataObjectRef,
4083 pos: CodePosition,
4084) -> OptionDataObjectRef {
4085 let ret = call_operator_method_1_arg(
4086 interpreter,
4087 "hasNext",
4088 operand,
4089 pos,
4090 )?;
4091
4092 Some(DataObjectRef::new(DataObject::with_update(|data_object| {
4093 data_object.set_bool(conversions::to_bool(interpreter, &ret, pos))
4094 }).unwrap()))
4095}
4096pub fn op_next(
4098 interpreter: &mut Interpreter,
4099 operand: &DataObjectRef,
4100 pos: CodePosition,
4101) -> OptionDataObjectRef {
4102 call_operator_method_1_arg(
4103 interpreter,
4104 "next",
4105 operand,
4106 pos,
4107 )
4108}
4109
4110pub fn op_call(
4112 interpreter: &mut Interpreter,
4113 callee: &DataObjectRef,
4114 argument_list: &[DataObjectRef],
4115 pos: CodePosition,
4116) -> OptionDataObjectRef {
4117 let ret = call_operator_method(interpreter, callee,"op:call", argument_list, pos);
4118 if let Some(ret) = ret {
4119 return Some(ret);
4120 }
4121
4122 if let Some(function_value) = callee.function_pointer_value() {
4123 return interpreter.call_function_pointer(
4124 &function_value,
4125 callee.variable_name().as_deref(),
4126 argument_list,
4127 pos,
4128 );
4129 }else if let Some(type_value) = callee.type_value() {
4130 let combined_argument_list = utils::combine_arguments_without_argument_separators(
4131 argument_list, interpreter, pos,
4132 );
4133
4134 if combined_argument_list.is_empty() {
4135 return Some(interpreter.set_errno_error_object(
4136 InterpretingError::InvalidArgCount,
4137 Some("Not enough arguments for TYPE casting (1 needed)"),
4138 pos,
4139 ));
4140 }
4141 if combined_argument_list.len() > 1 {
4142 return Some(interpreter.set_errno_error_object(
4143 InterpretingError::InvalidArgCount,
4144 Some("Too many arguments for TYPE casting (1 needed)"),
4145 pos,
4146 ));
4147 }
4148
4149 let arg = &combined_argument_list[0];
4150
4151 let output = op_cast(interpreter, callee, arg, pos);
4152 if output.is_none() {
4153 return Some(interpreter.set_errno_error_object(
4154 InterpretingError::IncompatibleDataType,
4155 Some(&format!(
4156 "Data type \"{}\" can not be casted to \"{}\"!",
4157 arg.data_type(),
4158 type_value,
4159 )),
4160 pos,
4161 ));
4162 }
4163
4164 return output;
4165 }else if let Some(struct_value) = callee.struct_value() {
4166 if struct_value.is_definition() {
4167 let combined_argument_list = utils::combine_arguments_without_argument_separators(
4168 argument_list, interpreter, pos,
4169 );
4170
4171 let member_names = struct_value.member_names();
4172 if combined_argument_list.len() != member_names.len() {
4173 return Some(interpreter.set_errno_error_object(
4174 InterpretingError::InvalidArguments,
4175 Some(&format!(
4176 "The argument count is not equals to the count of member names ({})",
4177 member_names.len(),
4178 )),
4179 pos,
4180 ));
4181 }
4182
4183 let ret = DataObject::with_update(|data_object| {
4184 data_object.set_struct(Gc::new(StructObject::new_instance(
4185 struct_value,
4186 &combined_argument_list,
4187 )?))
4188 });
4189 return match ret {
4190 Ok(ret) => Some(DataObjectRef::new(ret)),
4191
4192 Err(e) => {
4193 Some(interpreter.set_errno_error_object(
4194 InterpretingError::IncompatibleDataType,
4195 Some(e.message()),
4196 pos,
4197 ))
4198 },
4199 };
4200 }
4201 }else if let Some(object_value) = callee.object_value() {
4202 let is_class = object_value.borrow().is_class();
4203 if is_class {
4204 let created_object = LangObject::new_object(&object_value).unwrap();
4205
4206 let constructors = created_object.borrow().constructors();
4207
4208 let ret = interpreter.call_function_pointer(
4209 &constructors,
4210 constructors.function_name(),
4211 argument_list,
4212 pos,
4213 ).unwrap_or_else(|| DataObjectRef::new(DataObject::new_void()));
4214
4215 if ret.data_type() != DataType::VOID {
4216 return Some(interpreter.set_errno_error_object(
4217 InterpretingError::InvalidAstNode,
4218 Some("Invalid constructor implementation: VOID must be returned"),
4219 pos,
4220 ));
4221 }
4222
4223 let ret = created_object.borrow_mut().post_construct();
4224 if let Err(e) = ret {
4225 return Some(interpreter.set_errno_error_object(
4226 InterpretingError::IncompatibleDataType,
4227 Some(&format!(
4228 "Invalid constructor implementation (Some members have invalid types): {}",
4229 e.message(),
4230 )),
4231 pos,
4232 ));
4233 };
4234
4235 return Some(DataObjectRef::new(DataObject::with_update(|data_object| {
4236 data_object.set_object(created_object)
4237 }).unwrap()));
4238 }
4239 }
4240
4241 None
4242}
4243
4244pub fn is_equals(
4250 interpreter: &mut Interpreter,
4251 left_side_operand: &DataObjectRef,
4252 right_side_operand: &DataObjectRef,
4253 pos: CodePosition,
4254) -> bool {
4255 let ret = call_operator_method_2_arg(
4256 interpreter,
4257 "isEquals",
4258 true,
4259 left_side_operand,
4260 right_side_operand,
4261 pos,
4262 );
4263
4264 if let Some(ret) = ret {
4265 return conversions::to_bool(interpreter, &ret, pos);
4266 }
4267
4268 if ptr::eq(
4269 left_side_operand.borrow().deref(),
4270 right_side_operand.borrow().deref(),
4271 ) {
4272 return true;
4273 }
4274
4275 let number = conversions::to_number(interpreter, right_side_operand, pos);
4276
4277 match &left_side_operand.data_value() {
4278 DataValue::Text(left_value) => {
4279 if let Some(right_value) = right_side_operand.text_value() {
4280 return **left_value == *right_value;
4281 }
4282
4283 if left_value.chars().count() == 1
4284 && let Some(right_value) = right_side_operand.char_value() {
4285 return left_value.chars().next().unwrap() == right_value;
4286 }
4287
4288 number.is_some_and(|_| is_equals(interpreter, right_side_operand, left_side_operand, pos))
4289 },
4290
4291 DataValue::Char(left_value) => {
4292 if let Some(right_value) = right_side_operand.text_value()
4293 && right_value.chars().count() == 1 {
4294 return *left_value == right_value.chars().next().unwrap();
4295 }
4296
4297 number.is_some_and(|number| *left_value as i32 == number.int_value())
4298 },
4299
4300 DataValue::Int(left_value) => {
4301 number.is_some_and(|number| *left_value == number.int_value())
4302 },
4303
4304 DataValue::Long(left_value) => {
4305 number.is_some_and(|number| *left_value == number.long_value())
4306 },
4307
4308 DataValue::Float(left_value) => {
4309 number.is_some_and(|number| *left_value == number.float_value())
4310 },
4311
4312 DataValue::Double(left_value) => {
4313 number.is_some_and(|number| *left_value == number.double_value())
4314 },
4315
4316 DataValue::ByteBuffer(left_value) => {
4317 if let Some(right_value) = right_side_operand.byte_buffer_value() {
4318 return **left_value.borrow() == **right_value.borrow();
4319 }
4320
4321 number.is_some_and(|number| left_value.borrow().len() == number.int_value() as usize)
4322 },
4323
4324 DataValue::Array(left_value) => {
4325 if let Some(right_value) = right_side_operand.array_value() {
4326 if left_value.borrow().len() != right_value.borrow().len() {
4327 return false;
4328 }
4329
4330 let left_value = left_value.borrow().clone();
4331 let right_value = right_value.borrow().clone();
4332 for (left_value, right_value) in left_value.iter().
4333 zip(right_value.iter()) {
4334 if !is_equals(interpreter, left_value, right_value, pos) {
4335 return false;
4336 }
4337 }
4338
4339 return true;
4340 }
4341
4342 if let Some(right_value) = right_side_operand.list_value() {
4343 if left_value.borrow().len() != right_value.borrow().len() {
4344 return false;
4345 }
4346
4347 let left_value = left_value.borrow().clone();
4348 let right_value = right_value.borrow().clone();
4349 for (left_value, right_value) in left_value.iter().
4350 zip(right_value.iter()) {
4351 if !is_equals(interpreter, left_value, right_value, pos) {
4352 return false;
4353 }
4354 }
4355
4356 return true;
4357 }
4358
4359 number.is_some_and(|number| left_value.borrow().len() == number.int_value() as usize)
4360 },
4361
4362 DataValue::List(left_value) => {
4363 if let Some(right_value) = right_side_operand.list_value() {
4364 if left_value.borrow().len() != right_value.borrow().len() {
4365 return false;
4366 }
4367
4368 let left_value = left_value.borrow().clone();
4369 let right_value = right_value.borrow().clone();
4370 for (left_value, right_value) in left_value.iter().
4371 zip(right_value.iter()) {
4372 if !is_equals(interpreter, left_value, right_value, pos) {
4373 return false;
4374 }
4375 }
4376
4377 return true;
4378 }
4379
4380 if let Some(right_value) = right_side_operand.array_value() {
4381 if left_value.borrow().len() != right_value.borrow().len() {
4382 return false;
4383 }
4384
4385 let left_value = left_value.borrow().clone();
4386 let right_value = right_value.borrow().clone();
4387 for (left_value, right_value) in left_value.iter().
4388 zip(right_value.iter()) {
4389 if !is_equals(interpreter, left_value, right_value, pos) {
4390 return false;
4391 }
4392 }
4393
4394 return true;
4395 }
4396
4397 number.is_some_and(|number| left_value.borrow().len() == number.int_value() as usize)
4398 },
4399
4400 DataValue::Struct(left_value) => {
4401 if let Some(right_value) = right_side_operand.struct_value() {
4402 if left_value.is_definition() != right_value.is_definition() {
4403 return false;
4404 }
4405
4406 let left_member_names = left_value.member_names();
4407 let right_member_names = right_value.member_names();
4408 if left_member_names.len() != right_member_names.len() {
4409 return false;
4410 }
4411
4412 for (left_member_name, right_member_name) in left_member_names.into_iter().
4413 zip(right_member_names) {
4414 if left_member_name != right_member_name || (!left_value.is_definition() &&
4415 !is_equals(
4416 interpreter,
4417 &left_value.get_member(&left_member_name).unwrap(),
4418 &right_value.get_member(&right_member_name).unwrap(),
4419 pos,
4420 )) {
4421 return false;
4422 }
4423 }
4424
4425 return true;
4426 }
4427
4428 number.is_some_and(|number| left_value.member_names().len() == number.int_value() as usize)
4429 },
4430
4431 DataValue::Object(left_value) => {
4432 right_side_operand.object_value().is_some_and(|right_value| {
4433 ptr::eq(left_value.borrow().deref(), right_value.borrow().deref())
4435 })
4436 },
4437
4438 DataValue::VarPointer(left_value) => {
4439 right_side_operand.var_pointer_value().is_some_and(|right_value| {
4440 ptr::eq(left_value.borrow().deref(), right_value.borrow().deref())
4442 })
4443 },
4444
4445 DataValue::FunctionPointer(left_value) => {
4446 right_side_operand.function_pointer_value().is_some_and(|right_value| {
4447 left_value.is_equals(&right_value, interpreter, pos)
4448 })
4449 },
4450
4451 DataValue::Error(left_value) => {
4452 match &right_side_operand.data_value() {
4453 DataValue::Text(right_value) => {
4454 if let Some(number) = number {
4455 left_value.err().error_code() == number.int_value()
4456 }else {
4457 *left_value.err().error_text() == **right_value
4458 }
4459 },
4460
4461 DataValue::Char(_) |
4462 DataValue::Int(_) |
4463 DataValue::Long(_) |
4464 DataValue::Float(_) |
4465 DataValue::Double(_) |
4466 DataValue::ByteBuffer(_) |
4467 DataValue::Array(_) |
4468 DataValue::List(_) |
4469 DataValue::Struct(_) => {
4470 number.is_some_and(|number| left_value.err().error_code() == number.int_value())
4471 },
4472
4473 DataValue::Error(right_value) => {
4474 *left_value == *right_value
4475 },
4476
4477 _ => false,
4478 }
4479 },
4480
4481 DataValue::Type(left_value) => {
4482 if let Some(right_value) = right_side_operand.type_value() {
4483 *left_value == right_value
4484 }else {
4485 *left_value == right_side_operand.data_type()
4486 }
4487 },
4488
4489 DataValue::Null |
4490 DataValue::Void |
4491 DataValue::ArgumentSeparator(_) => {
4492 left_side_operand.data_type() == right_side_operand.data_type()
4493 },
4494 }
4495}
4496pub fn is_strict_equals(
4500 interpreter: &mut Interpreter,
4501 left_side_operand: &DataObjectRef,
4502 right_side_operand: &DataObjectRef,
4503 pos: CodePosition,
4504) -> bool {
4505 let ret = call_operator_method_2_arg(
4506 interpreter,
4507 "isStrictEquals",
4508 true,
4509 left_side_operand,
4510 right_side_operand,
4511 pos,
4512 );
4513
4514 if let Some(ret) = ret {
4515 return conversions::to_bool(interpreter, &ret, pos);
4516 }
4517
4518 if ptr::eq(
4519 left_side_operand.borrow().deref(),
4520 right_side_operand.borrow().deref(),
4521 ) {
4522 return true;
4523 }
4524
4525 if left_side_operand.data_type() != right_side_operand.data_type() {
4526 return false;
4527 }
4528
4529 match &left_side_operand.data_value() {
4530 DataValue::Text(left_value) => {
4531 let right_value = right_side_operand.text_value().unwrap();
4532
4533 **left_value == *right_value
4534 },
4535
4536 DataValue::Char(left_value) => {
4537 let right_value = right_side_operand.char_value().unwrap();
4538
4539 *left_value == right_value
4540 },
4541
4542 DataValue::Int(left_value) => {
4543 let right_value = right_side_operand.int_value().unwrap();
4544
4545 *left_value == right_value
4546 },
4547
4548 DataValue::Long(left_value) => {
4549 let right_value = right_side_operand.long_value().unwrap();
4550
4551 *left_value == right_value
4552 },
4553
4554 DataValue::Float(left_value) => {
4555 let right_value = right_side_operand.float_value().unwrap();
4556
4557 *left_value == right_value
4558 },
4559
4560 DataValue::Double(left_value) => {
4561 let right_value = right_side_operand.double_value().unwrap();
4562
4563 *left_value == right_value
4564 },
4565
4566 DataValue::ByteBuffer(left_value) => {
4567 let right_value = right_side_operand.byte_buffer_value().unwrap();
4568 let right_value = right_value.borrow();
4569
4570 **left_value.borrow() == **right_value
4571 },
4572
4573 DataValue::Array(left_value) => {
4574 let right_value = right_side_operand.array_value().unwrap();
4575
4576 if left_value.borrow().len() != right_value.borrow().len() {
4577 return false;
4578 }
4579
4580 let left_value = left_value.borrow().clone();
4581 let right_value = right_value.borrow().clone();
4582 for (left_value, right_value) in left_value.iter().
4583 zip(right_value.iter()) {
4584 if !is_strict_equals(interpreter, left_value, right_value, pos) {
4585 return false;
4586 }
4587 }
4588
4589 true
4590 },
4591
4592 DataValue::List(left_value) => {
4593 let right_value = right_side_operand.list_value().unwrap();
4594
4595 if left_value.borrow().len() != right_value.borrow().len() {
4596 return false;
4597 }
4598
4599 let left_value = left_value.borrow().clone();
4600 let right_value = right_value.borrow().clone();
4601 for (left_value, right_value) in left_value.iter().
4602 zip(right_value.iter()) {
4603 if !is_strict_equals(interpreter, left_value, right_value, pos) {
4604 return false;
4605 }
4606 }
4607
4608 true
4609 },
4610
4611 DataValue::Struct(left_value) => {
4612 let right_value = right_side_operand.struct_value().unwrap();
4613
4614 if left_value.is_definition() != right_value.is_definition() {
4615 return false;
4616 }
4617
4618 let left_member_names = left_value.member_names();
4619 let right_member_names = right_value.member_names();
4620 if left_member_names.len() != right_member_names.len() {
4621 return false;
4622 }
4623
4624 for (left_member_name, right_member_name) in left_member_names.into_iter().
4625 zip(right_member_names) {
4626 if left_member_name != right_member_name || (!left_value.is_definition() &&
4627 !is_strict_equals(
4628 interpreter,
4629 &left_value.get_member(&left_member_name).unwrap(),
4630 &right_value.get_member(&right_member_name).unwrap(),
4631 pos,
4632 )) {
4633 return false;
4634 }
4635 }
4636
4637 true
4638 },
4639
4640 DataValue::Object(left_value) => {
4641 let right_value = right_side_operand.object_value().unwrap();
4642 let right_value = right_value.borrow();
4643
4644 ptr::eq(left_value.borrow().deref(), right_value.deref())
4646 },
4647
4648 DataValue::VarPointer(left_value) => {
4649 let right_value = right_side_operand.var_pointer_value().unwrap();
4650 let right_value = right_value.borrow();
4651
4652 ptr::eq(left_value.borrow().deref(), right_value.deref())
4654 },
4655
4656 DataValue::FunctionPointer(left_value) => {
4657 let right_value = right_side_operand.function_pointer_value().unwrap();
4658
4659 left_value.is_equals(&right_value, interpreter, pos)
4660 },
4661
4662 DataValue::Error(left_value) => {
4663 let right_value = right_side_operand.error_value().unwrap();
4664
4665 *left_value == right_value
4666 },
4667
4668 DataValue::Type(left_value) => {
4669 let right_value = right_side_operand.type_value().unwrap();
4670
4671 *left_value == right_value
4672 },
4673
4674 DataValue::Null |
4675 DataValue::Void |
4676 DataValue::ArgumentSeparator(_) => {
4677 left_side_operand.data_type() == right_side_operand.data_type()
4678 },
4679 }
4680}
4681pub fn is_less_than(
4685 interpreter: &mut Interpreter,
4686 left_side_operand: &DataObjectRef,
4687 right_side_operand: &DataObjectRef,
4688 pos: CodePosition,
4689) -> bool {
4690 let ret = call_operator_method_2_arg(
4691 interpreter,
4692 "isLessThan",
4693 true,
4694 left_side_operand,
4695 right_side_operand,
4696 pos,
4697 );
4698
4699 if let Some(ret) = ret {
4700 return conversions::to_bool(interpreter, &ret, pos);
4701 }
4702
4703 if ptr::eq(
4704 left_side_operand.borrow().deref(),
4705 right_side_operand.borrow().deref(),
4706 ) {
4707 return false;
4708 }
4709
4710 let number = conversions::to_number(interpreter, right_side_operand, pos).
4711 map(|number| DataObject::with_update(|data_object| {
4712 data_object.set_number(number)
4713 }).unwrap()).unwrap_or_default();
4714
4715 match &left_side_operand.data_value() {
4716 DataValue::Text(left_value) => {
4717 if let Some(right_value) = right_side_operand.text_value() {
4718 return **left_value < *right_value;
4719 }
4720
4721 if left_value.chars().count() == 1
4722 && let Some(right_value) = right_side_operand.char_value() {
4723 return left_value.chars().next().unwrap() < right_value;
4724 }
4725
4726 let this_number = conversions::to_number(interpreter, left_side_operand, pos);
4727 let Some(this_number) = this_number else {
4728 return false;
4729 };
4730
4731 match number.data_value().clone() {
4732 DataValue::Int(number) => this_number.int_value() < number,
4733 DataValue::Long(number) => this_number.long_value() < number,
4734 DataValue::Float(number) => this_number.float_value() < number,
4735 DataValue::Double(number) => this_number.double_value() < number,
4736
4737 _ => false
4738 }
4739 },
4740
4741 DataValue::Char(left_value) => {
4742 if let Some(right_value) = right_side_operand.text_value()
4743 && right_value.chars().count() == 1 {
4744 return *left_value < right_value.chars().next().unwrap();
4745 }
4746
4747 match number.data_value().clone() {
4748 DataValue::Int(number) => (*left_value as i32) < number,
4749 DataValue::Long(number) => (*left_value as i64) < number,
4750 DataValue::Float(number) => (*left_value as i32 as f32) < number,
4751 DataValue::Double(number) => (*left_value as i32 as f64) < number,
4752
4753 _ => false
4754 }
4755 },
4756
4757 DataValue::Int(left_value) => {
4758 match number.data_value().clone() {
4759 DataValue::Int(number) => *left_value < number,
4760 DataValue::Long(number) => (*left_value as i64) < number,
4761 DataValue::Float(number) => (*left_value as f32) < number,
4762 DataValue::Double(number) => (*left_value as f64) < number,
4763
4764 _ => false
4765 }
4766 },
4767
4768 DataValue::Long(left_value) => {
4769 match number.data_value().clone() {
4770 DataValue::Int(number) => *left_value < number as i64,
4771 DataValue::Long(number) => *left_value < number,
4772 DataValue::Float(number) => (*left_value as f32) < number,
4773 DataValue::Double(number) => (*left_value as f64) < number,
4774
4775 _ => false
4776 }
4777 },
4778
4779 DataValue::Float(left_value) => {
4780 match number.data_value().clone() {
4781 DataValue::Int(number) => *left_value < number as f32,
4782 DataValue::Long(number) => *left_value < number as f32,
4783 DataValue::Float(number) => *left_value < number,
4784 DataValue::Double(number) => (*left_value as f64) < number,
4785
4786 _ => false
4787 }
4788 },
4789
4790 DataValue::Double(left_value) => {
4791 match number.data_value().clone() {
4792 DataValue::Int(number) => *left_value < number as f64,
4793 DataValue::Long(number) => *left_value < number as f64,
4794 DataValue::Float(number) => *left_value < number as f64,
4795 DataValue::Double(number) => *left_value < number,
4796
4797 _ => false
4798 }
4799 },
4800
4801 DataValue::ByteBuffer(left_value) => {
4802 match number.data_value().clone() {
4803 DataValue::Int(number) => (left_value.borrow().len() as i32) < number,
4804 DataValue::Long(number) => (left_value.borrow().len() as i32 as i64) < number,
4805 DataValue::Float(number) => (left_value.borrow().len() as i32 as f32) < number,
4806 DataValue::Double(number) => (left_value.borrow().len() as i32 as f64) < number,
4807
4808 _ => false
4809 }
4810 },
4811
4812 DataValue::Array(left_value) => {
4813 match number.data_value().clone() {
4814 DataValue::Int(number) => (left_value.borrow().len() as i32) < number,
4815 DataValue::Long(number) => (left_value.borrow().len() as i32 as i64) < number,
4816 DataValue::Float(number) => (left_value.borrow().len() as i32 as f32) < number,
4817 DataValue::Double(number) => (left_value.borrow().len() as i32 as f64) < number,
4818
4819 _ => false
4820 }
4821 },
4822
4823 DataValue::List(left_value) => {
4824 match number.data_value().clone() {
4825 DataValue::Int(number) => (left_value.borrow().len() as i32) < number,
4826 DataValue::Long(number) => (left_value.borrow().len() as i32 as i64) < number,
4827 DataValue::Float(number) => (left_value.borrow().len() as i32 as f32) < number,
4828 DataValue::Double(number) => (left_value.borrow().len() as i32 as f64) < number,
4829
4830 _ => false
4831 }
4832 },
4833
4834 DataValue::Error(left_value) => {
4835 if let Some(right_value) = right_side_operand.text_value() {
4836 return *left_value.err().error_text() < *right_value;
4837 }
4838
4839 match number.data_value().clone() {
4840 DataValue::Int(number) => left_value.err().error_code() < number,
4841 DataValue::Long(number) => (left_value.err().error_code() as i64) < number,
4842 DataValue::Float(number) => (left_value.err().error_code() as f32) < number,
4843 DataValue::Double(number) => (left_value.err().error_code() as f64) < number,
4844
4845 _ => false
4846 }
4847 },
4848
4849 DataValue::Struct(left_value) => {
4850 match number.data_value().clone() {
4851 DataValue::Int(number) => (left_value.member_names().len() as i32) < number,
4852 DataValue::Long(number) => (left_value.member_names().len() as i32 as i64) < number,
4853 DataValue::Float(number) => (left_value.member_names().len() as i32 as f32) < number,
4854 DataValue::Double(number) => (left_value.member_names().len() as i32 as f64) < number,
4855
4856 _ => false
4857 }
4858 },
4859
4860 _ => false,
4861 }
4862}
4863pub fn is_greater_than(
4867 interpreter: &mut Interpreter,
4868 left_side_operand: &DataObjectRef,
4869 right_side_operand: &DataObjectRef,
4870 pos: CodePosition,
4871) -> bool {
4872 let ret = call_operator_method_2_arg(
4873 interpreter,
4874 "isGreaterThan",
4875 true,
4876 left_side_operand,
4877 right_side_operand,
4878 pos,
4879 );
4880
4881 if let Some(ret) = ret {
4882 return conversions::to_bool(interpreter, &ret, pos);
4883 }
4884
4885 if ptr::eq(
4886 left_side_operand.borrow().deref(),
4887 right_side_operand.borrow().deref(),
4888 ) {
4889 return false;
4890 }
4891
4892 let number = conversions::to_number(interpreter, right_side_operand, pos).
4893 map(|number| DataObject::with_update(|data_object| {
4894 data_object.set_number(number)
4895 }).unwrap()).unwrap_or_default();
4896
4897 match &left_side_operand.data_value() {
4898 DataValue::Text(left_value) => {
4899 if let Some(right_value) = right_side_operand.text_value() {
4900 return **left_value > *right_value;
4901 }
4902
4903 if left_value.chars().count() == 1
4904 && let Some(right_value) = right_side_operand.char_value() {
4905 return left_value.chars().next().unwrap() > right_value;
4906 }
4907
4908 let this_number = conversions::to_number(interpreter, left_side_operand, pos);
4909 let Some(this_number) = this_number else {
4910 return false;
4911 };
4912
4913 match number.data_value().clone() {
4914 DataValue::Int(number) => this_number.int_value() > number,
4915 DataValue::Long(number) => this_number.long_value() > number,
4916 DataValue::Float(number) => this_number.float_value() > number,
4917 DataValue::Double(number) => this_number.double_value() > number,
4918
4919 _ => false
4920 }
4921 },
4922
4923 DataValue::Char(left_value) => {
4924 if let Some(right_value) = right_side_operand.text_value()
4925 && right_value.chars().count() == 1 {
4926 return *left_value > right_value.chars().next().unwrap();
4927 }
4928
4929 match number.data_value().clone() {
4930 DataValue::Int(number) => (*left_value as i32) > number,
4931 DataValue::Long(number) => (*left_value as i64) > number,
4932 DataValue::Float(number) => (*left_value as i32 as f32) > number,
4933 DataValue::Double(number) => (*left_value as i32 as f64) > number,
4934
4935 _ => false
4936 }
4937 },
4938
4939 DataValue::Int(left_value) => {
4940 match number.data_value().clone() {
4941 DataValue::Int(number) => *left_value > number,
4942 DataValue::Long(number) => (*left_value as i64) > number,
4943 DataValue::Float(number) => (*left_value as f32) > number,
4944 DataValue::Double(number) => (*left_value as f64) > number,
4945
4946 _ => false
4947 }
4948 },
4949
4950 DataValue::Long(left_value) => {
4951 match number.data_value().clone() {
4952 DataValue::Int(number) => *left_value > number as i64,
4953 DataValue::Long(number) => *left_value > number,
4954 DataValue::Float(number) => (*left_value as f32) > number,
4955 DataValue::Double(number) => (*left_value as f64) > number,
4956
4957 _ => false
4958 }
4959 },
4960
4961 DataValue::Float(left_value) => {
4962 match number.data_value().clone() {
4963 DataValue::Int(number) => *left_value > number as f32,
4964 DataValue::Long(number) => *left_value > number as f32,
4965 DataValue::Float(number) => *left_value > number,
4966 DataValue::Double(number) => (*left_value as f64) > number,
4967
4968 _ => false
4969 }
4970 },
4971
4972 DataValue::Double(left_value) => {
4973 match number.data_value().clone() {
4974 DataValue::Int(number) => *left_value > number as f64,
4975 DataValue::Long(number) => *left_value > number as f64,
4976 DataValue::Float(number) => *left_value > number as f64,
4977 DataValue::Double(number) => *left_value > number,
4978
4979 _ => false
4980 }
4981 },
4982
4983 DataValue::ByteBuffer(left_value) => {
4984 match number.data_value().clone() {
4985 DataValue::Int(number) => (left_value.borrow().len() as i32) > number,
4986 DataValue::Long(number) => (left_value.borrow().len() as i32 as i64) > number,
4987 DataValue::Float(number) => (left_value.borrow().len() as i32 as f32) > number,
4988 DataValue::Double(number) => (left_value.borrow().len() as i32 as f64) > number,
4989
4990 _ => false
4991 }
4992 },
4993
4994 DataValue::Array(left_value) => {
4995 match number.data_value().clone() {
4996 DataValue::Int(number) => (left_value.borrow().len() as i32) > number,
4997 DataValue::Long(number) => (left_value.borrow().len() as i32 as i64) > number,
4998 DataValue::Float(number) => (left_value.borrow().len() as i32 as f32) > number,
4999 DataValue::Double(number) => (left_value.borrow().len() as i32 as f64) > number,
5000
5001 _ => false
5002 }
5003 },
5004
5005 DataValue::List(left_value) => {
5006 match number.data_value().clone() {
5007 DataValue::Int(number) => (left_value.borrow().len() as i32) > number,
5008 DataValue::Long(number) => (left_value.borrow().len() as i32 as i64) > number,
5009 DataValue::Float(number) => (left_value.borrow().len() as i32 as f32) > number,
5010 DataValue::Double(number) => (left_value.borrow().len() as i32 as f64) > number,
5011
5012 _ => false
5013 }
5014 },
5015
5016 DataValue::Error(left_value) => {
5017 if let Some(right_value) = right_side_operand.text_value() {
5018 return *left_value.err().error_text() > *right_value;
5019 }
5020
5021 match number.data_value().clone() {
5022 DataValue::Int(number) => left_value.err().error_code() > number,
5023 DataValue::Long(number) => (left_value.err().error_code() as i64) > number,
5024 DataValue::Float(number) => (left_value.err().error_code() as f32) > number,
5025 DataValue::Double(number) => (left_value.err().error_code() as f64) > number,
5026
5027 _ => false
5028 }
5029 },
5030
5031 DataValue::Struct(left_value) => {
5032 match number.data_value().clone() {
5033 DataValue::Int(number) => (left_value.member_names().len() as i32) > number,
5034 DataValue::Long(number) => (left_value.member_names().len() as i32 as i64) > number,
5035 DataValue::Float(number) => (left_value.member_names().len() as i32 as f32) > number,
5036 DataValue::Double(number) => (left_value.member_names().len() as i32 as f64) > number,
5037
5038 _ => false
5039 }
5040 },
5041
5042 _ => false,
5043 }
5044}
5045pub fn is_less_than_or_equals(
5049 interpreter: &mut Interpreter,
5050 left_side_operand: &DataObjectRef,
5051 right_side_operand: &DataObjectRef,
5052 pos: CodePosition,
5053) -> bool {
5054 is_less_than(interpreter, left_side_operand, right_side_operand, pos) ||
5055 is_equals(interpreter, left_side_operand, right_side_operand, pos)
5056}
5057pub fn is_greater_than_or_equals(
5061 interpreter: &mut Interpreter,
5062 left_side_operand: &DataObjectRef,
5063 right_side_operand: &DataObjectRef,
5064 pos: CodePosition,
5065) -> bool {
5066 is_greater_than(interpreter, left_side_operand, right_side_operand, pos) ||
5067 is_equals(interpreter, left_side_operand, right_side_operand, pos)
5068}