csvx 0.1.17

Comma-Separated Values eXtended
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

use super::*;
use std::borrow::Borrow;

pub fn primitive_parse<T: Borrow<str>>(raw_string: &T) -> Result<Vec<PrimitiveToken>, ()> {
    let mut tokens = vec![];

    let chars: Vec<char> = raw_string.borrow().chars().collect();
    let mut i = 0;
    while i < chars.len() {
        match chars[i] {
            ' ' | '\t' => {}
            '\"' => {
                let mut chars_pending = vec![];
                let mut is_being_escaped = false;

                loop {
                    i += 1;
                    if i >= chars.len() {
                        return Err(());
                    }

                    if is_being_escaped {
                        match chars[i] {
                            'n' => chars_pending.push('\n'),
                            'r' => chars_pending.push('\r'),
                            't' => chars_pending.push('\t'),
                            '\\' => chars_pending.push('\\'),
                            '\0' => chars_pending.push('\0'),
                            '\'' => chars_pending.push('\''),
                            '\"' => chars_pending.push('\"'),
                            _ => chars_pending.push(chars[i]),
                        }
                        is_being_escaped = false;
                    } else {
                        match chars[i] {
                            '\"' => break,
                            '\\' => is_being_escaped = true,
                            _ => chars_pending.push(chars[i]),
                        }
                    }
                }

                tokens.push(PrimitiveToken::Parsed(Token::String(
                    chars_pending.iter().collect(),
                )));
            }
            '+' => tokens.push(PrimitiveToken::Parsed(Token::Add)),
            '-' => tokens.push(PrimitiveToken::Parsed(Token::Sub)),
            '*' => tokens.push(PrimitiveToken::Parsed(Token::Mul)),
            '/' => tokens.push(PrimitiveToken::Parsed(Token::Div)),
            '%' => tokens.push(PrimitiveToken::Parsed(Token::Mod)),
            '^' => tokens.push(PrimitiveToken::Parsed(Token::Xor)),
            '&' => {
                if i + 1 < chars.len() && chars[i + 1] == '&' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::LogicalAnd));
                } else {
                    tokens.push(PrimitiveToken::Parsed(Token::BitwiseAnd));
                }
            }
            '|' => {
                if i + 1 < chars.len() && chars[i + 1] == '|' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::LogicalOr));
                } else {
                    tokens.push(PrimitiveToken::Parsed(Token::BitwiseOr));
                }
            }
            '=' => {
                if i + 1 < chars.len() && chars[i + 1] == '=' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::Equal));
                } else {
                    return Err(());
                }
            }
            '!' => {
                if i + 1 < chars.len() && chars[i + 1] == '=' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::NotEqual));
                } else {
                    tokens.push(PrimitiveToken::Parsed(Token::Not));
                }
            }
            '<' => {
                if i + 1 < chars.len() && chars[i + 1] == '=' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::LessThanEqual));
                } else if i + 1 < chars.len() && chars[i + 1] == '<' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::LeftShift));
                } else {
                    tokens.push(PrimitiveToken::Parsed(Token::LessThan));
                }
            }
            '>' => {
                if i + 1 < chars.len() && chars[i + 1] == '=' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::GreaterThanEqual));
                } else if i + 1 < chars.len() && chars[i + 1] == '>' {
                    i += 1;
                    tokens.push(PrimitiveToken::Parsed(Token::RightShift));
                } else {
                    tokens.push(PrimitiveToken::Parsed(Token::GreaterThan));
                }
            }
            '(' => tokens.push(PrimitiveToken::Parsed(Token::ParenthesisBegin)),
            ')' => tokens.push(PrimitiveToken::Parsed(Token::ParenthesisEnd)),
            ',' => tokens.push(PrimitiveToken::Parsed(Token::Comma)),
            _ => {
                let mut chars_pending = vec![chars[i]];

                while i + 1 < chars.len()
                    && !matches!(
                        chars[i + 1],
                        ' ' | '\t'
                            | '\"'
                            | '+'
                            | '-'
                            | '*'
                            | '/'
                            | '%'
                            | '^'
                            | '&'
                            | '|'
                            | '='
                            | '!'
                            | '<'
                            | '>'
                            | '('
                            | ')'
                            | ','
                    )
                {
                    chars_pending.push(chars[i + 1]);
                    i += 1;
                }

                tokens.push(PrimitiveToken::Raw(chars_pending.iter().collect()));
            }
        }
        i += 1;
    }

    Ok(tokens)
}