mq-lang 0.5.28

Core language implementation for mq query language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::eval::runtime_value::RuntimeValue;

use super::{Error, MAX_RANGE_SIZE};

pub(super) fn generate_numeric_range(start: isize, end: isize, step: isize) -> Result<Vec<RuntimeValue>, Error> {
    if step == 0 {
        return Err(Error::Runtime("step for range must not be zero".to_string()));
    }

    let range_size = if (step > 0 && end >= start) || (step < 0 && end <= start) {
        let diff = (end as i128) - (start as i128);
        let step_i128 = step as i128;
        ((diff / step_i128).abs() + 1) as usize
    } else {
        0
    };

    if range_size > MAX_RANGE_SIZE {
        return Err(Error::Runtime(format!(
            "range size {} exceeds maximum allowed size of {}",
            range_size, MAX_RANGE_SIZE
        )));
    }

    let mut result = Vec::with_capacity(range_size);
    let mut current = start;

    if step > 0 {
        while current <= end {
            result.push(RuntimeValue::Number(current.into()));
            current += step;
        }
    } else {
        while current >= end {
            result.push(RuntimeValue::Number(current.into()));
            current += step;
        }
    }

    Ok(result)
}

pub(super) fn generate_char_range(
    start_char: char,
    end_char: char,
    step: Option<i32>,
) -> Result<Vec<RuntimeValue>, Error> {
    let step = step.unwrap_or(if start_char <= end_char { 1 } else { -1 });

    if step == 0 {
        return Err(Error::Runtime("step for range must not be zero".to_string()));
    }

    let range_size = if (step > 0 && end_char >= start_char) || (step < 0 && end_char <= start_char) {
        let diff = (end_char as i64) - (start_char as i64);
        let step_i64 = step as i64;
        ((diff / step_i64).abs() + 1) as usize
    } else {
        0
    };

    if range_size > MAX_RANGE_SIZE {
        return Err(Error::Runtime(format!(
            "range size {} exceeds maximum allowed size of {}",
            range_size, MAX_RANGE_SIZE
        )));
    }

    let mut result = Vec::with_capacity(range_size);
    let mut current = start_char as i32;
    let end = end_char as i32;

    if step > 0 {
        while current <= end {
            if let Some(ch) = char::from_u32(current as u32) {
                result.push(RuntimeValue::String(ch.to_string()));
            }
            current += step;
        }
    } else {
        while current >= end {
            if let Some(ch) = char::from_u32(current as u32) {
                result.push(RuntimeValue::String(ch.to_string()));
            }
            current += step;
        }
    }

    Ok(result)
}

pub(super) fn generate_multi_char_range(start: &str, end: &str) -> Result<Vec<RuntimeValue>, Error> {
    if start.len() != end.len() {
        return Err(Error::Runtime(
            "String range requires strings of equal length".to_string(),
        ));
    }

    let start_bytes = start.as_bytes();
    let end_bytes = end.as_bytes();

    let capacity_estimate = (end_bytes.iter().zip(start_bytes.iter()))
        .map(|(e, s)| (e.max(s) - e.min(s)) as usize)
        .try_fold(0usize, |acc, diff| {
            acc.checked_add(diff)
                .ok_or_else(|| Error::Runtime(format!("range size exceeds maximum allowed size of {}", MAX_RANGE_SIZE)))
        })?
        + 1;

    if capacity_estimate > MAX_RANGE_SIZE {
        return Err(Error::Runtime(format!(
            "range size {} exceeds maximum allowed size of {}",
            capacity_estimate, MAX_RANGE_SIZE
        )));
    }

    let mut result = Vec::with_capacity(capacity_estimate);
    let mut current = start_bytes.to_vec();

    loop {
        if let Ok(s) = String::from_utf8(current.clone()) {
            result.push(RuntimeValue::String(s));
        }

        if current.as_slice() == end_bytes {
            break;
        }

        let mut carry = true;
        for byte in current.iter_mut().rev() {
            if carry {
                if *byte < 255 {
                    *byte += 1;
                    carry = false;
                } else {
                    *byte = 0;
                }
            }
        }

        if carry || current.as_slice() > end_bytes {
            break;
        }
    }

    Ok(result)
}