lang_interpreter/interpreter/
operators.rs

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
97//General operation functions
98
99/// Operator definition of the [LEN] operator (`@`)
100///
101/// [LEN]: crate::parser::ast::Operator::Len
102pub 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}
157/// Operator definition of the [DEEP_COPY] operator (`^`)
158///
159/// [DEEP_COPY]: crate::parser::ast::Operator::DeepCopy
160pub 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}
266/// Operator definition of the [CONCAT] operator (`|||`)
267///
268/// [CONCAT]: crate::parser::ast::Operator::Concat
269pub 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}
443/// Operator definition of the [SPACESHIP] operator (`<=>`)
444///
445/// [SPACESHIP]: crate::parser::ast::Operator::Spaceship
446pub 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
469//Math operation functions
470
471/// Operator definition of the [INC] operator (`+|`)
472///
473/// [INC]: crate::parser::ast::Operator::Inc
474pub 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}
567/// Operator definition of the [DEC] operator (`-|`)
568///
569/// [DEC]: crate::parser::ast::Operator::Dec
570pub 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}
665/// Operator definition of the [POS] operator (`+`)
666///
667/// [POS]: crate::parser::ast::Operator::Pos
668pub 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}
687/// Operator definition of the [INV] operator (`-`)
688///
689/// [INV]: crate::parser::ast::Operator::Inv
690pub 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}
757/// Operator definition of the [ADD] operator (`+`)
758///
759/// [ADD]: crate::parser::ast::Operator::Add
760pub 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}
1002/// Operator definition of the [SUB] operator (`-`)
1003///
1004/// [SUB]: crate::parser::ast::Operator::Sub
1005pub 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}
1207/// Operator definition of the [MUL] operator (`*`)
1208///
1209/// [MUL]: crate::parser::ast::Operator::Mul
1210pub 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}
1370/// Operator definition of the [POW] operator (`**`)
1371///
1372/// [POW]: crate::parser::ast::Operator::Pow
1373pub 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}
1605/// Operator definition of the [DIV] operator (`/`)
1606///
1607/// [DIV]: crate::parser::ast::Operator::Div
1608pub 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}
1790/// Operator definition of the [TRUNC_DIV] operator (`~/`)
1791///
1792/// [TRUNC_DIV]: crate::parser::ast::Operator::TruncDiv
1793pub 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}
2147/// Operator definition of the [FLOOR_DIV] operator (`//`)
2148///
2149/// [FLOOR_DIV]: crate::parser::ast::Operator::FloorDiv
2150pub 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}
2420/// Operator definition of the [CEIL_DIV] operator (`^/`)
2421///
2422/// [CEIL_DIV]: crate::parser::ast::Operator::CeilDiv
2423pub 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}
2693/// Operator definition of the [MOD] operator (`%`)
2694///
2695/// [MOD]: crate::parser::ast::Operator::Mod
2696pub 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}
2876/// Operator definition of the [BITWISE_AND] operator (`&`)
2877///
2878/// [BITWISE_AND]: crate::parser::ast::Operator::BitwiseAnd
2879pub 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}
2937/// Operator definition of the [BITWISE_OR] operator (`|`)
2938///
2939/// [BITWISE_OR]: crate::parser::ast::Operator::BitwiseOr
2940pub 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}
3007/// Operator definition of the [BITWISE_XOR] operator (`^`)
3008///
3009/// [BITWISE_XOR]: crate::parser::ast::Operator::BitwiseXor
3010pub 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}
3068/// Operator definition of the [BITWISE_NOT] operator (`~`)
3069///
3070/// [BITWISE_NOT]: crate::parser::ast::Operator::BitwiseNot
3071pub 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}
3102/// Operator definition of the [LSHIFT] operator (`<<`)
3103///
3104/// [LSHIFT]: crate::parser::ast::Operator::Lshift
3105pub 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}
3163/// Operator definition of the [RSHIFT] operator (`>>`)
3164///
3165/// [RSHIFT]: crate::parser::ast::Operator::Rshift
3166pub 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}
3233/// Operator definition of the [RZSHIFT] operator (`>>>`)
3234///
3235/// [RZSHIFT]: crate::parser::ast::Operator::Rzshift
3236pub 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
3305//All operation functions
3306
3307/// Operator definition of the `CAST` operator
3308pub 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}
3390/// Operator definition of the [GET_ITEM] operator (`[...]`)
3391///
3392/// [GET_ITEM]: crate::parser::ast::Operator::GetItem
3393pub 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}
3550/// Operator definition of the [OPTIONAL_GET_ITEM] operator (`?.[...]`)
3551///
3552/// [OPTIONAL_GET_ITEM]: crate::parser::ast::Operator::OptionalGetItem
3553pub 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}
3565/// Operator definition of the [SLICE] operator (`[...:...]`)
3566///
3567/// [SLICE]: crate::parser::ast::Operator::Slice
3568pub 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}
3860/// Operator definition of the [OPTIONAL_SLICE] operator (`?.[...:...]`)
3861///
3862/// [OPTIONAL_SLICE]: crate::parser::ast::Operator::OptionalSlice
3863pub 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}
3876/// Operator definition of the `SET_ITEM`
3877pub 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
4003//Special operator functions
4004
4005/// Operator definition of the `ABS` (`func.abs(...)`)
4006pub 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}
4049/// Operator definition of the `ITER` (`func.iter(...)`)
4050pub 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}
4079/// Operator definition of the `HAS_NEXT` (`func.hasNext(...)`)
4080pub 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}
4096/// Operator definition of the `NEXT` (`func.next(...)`)
4097pub 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
4110/// Operator definition of the `CALL` (`...(...)`)
4111pub 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
4244//Comparison functions
4245
4246/// Operator definition of the [EQUALS] operator (`==`)
4247///
4248/// [EQUALS]: crate::parser::ast::Operator::Equals
4249pub 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                //Check for same reference only (For classes and objects if "op:isEquals()" is not defined)
4434                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                //Check for same reference only
4441                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}
4496/// Operator definition of the [STRICT_EQUALS] operator (`===`)
4497///
4498/// [STRICT_EQUALS]: crate::parser::ast::Operator::StrictEquals
4499pub 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            //Check for same reference only (For classes and objects if "op:isStrictEquals()" is not defined)
4645            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            //Check for same reference only
4653            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}
4681/// Operator definition of the [LESS_THAN] operator (`<`)
4682///
4683/// [LESS_THAN]: crate::parser::ast::Operator::LessThan
4684pub 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}
4863/// Operator definition of the [GREATER_THAN] operator (`>`)
4864///
4865/// [GREATER_THAN]: crate::parser::ast::Operator::GreaterThan
4866pub 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}
5045/// Operator definition of the [LESS_THAN_OR_EQUALS] operator (`<=`)
5046///
5047/// [LESS_THAN_OR_EQUALS]: crate::parser::ast::Operator::LessThanOrEquals
5048pub 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}
5057/// Operator definition of the [GREATER_THAN_OR_EQUALS] operator (`>=`)
5058///
5059/// [GREATER_THAN_OR_EQUALS]: crate::parser::ast::Operator::GreaterThanOrEquals
5060pub 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}