Function partial_parse

src/helper.rs:266–314

(line: &str, pos: usize, helper: &MyHelper)

}

fn partial_parse(line: &str, pos: usize, helper: &MyHelper) -> Option<(usize, Partial)> {
    let (start, _) = extract_word(line, pos, None, |c| c == ' ');
    let iter = Tokenizer::new(&line[start..pos]);
    let mut tokens = Vec::new();
    let mut pos_start = 0;
    for v in iter {
        let v = v.ok()?;
        if pos_start == 0
            && matches!(
                v.1,
                Token::Equals | Token::TestEqual | Token::SubEqual | Token::NotEqual
            )
        {
            pos_start = v.2;
        }
        let tok = if let Token::Text(id) = v.1 {
            Token::Id(id)
        } else {
            v.1
        };
        tokens.push((v.0, tok));
    }
    match tokens.as_slice() {
        [(_, Token::Id(id))] => match str_to_principal(id, helper) {
            Ok(id) => Some((pos, Partial::Call(id, "".to_string()))),
            Err(_) => parse_value(&line[..pos], start, pos, helper),
        },
        [(_, Token::Id(id)), (pos_tail, Token::Dot)]
        | [(_, Token::Id(id)), (pos_tail, Token::Dot), (_, _)] => {
            match str_to_principal(id, helper) {
                Ok(id) => Some((
                    start + pos_tail,
                    Partial::Call(id, line[start + pos_tail + 1..pos].to_string()),
                )),
                Err(_) => parse_value(&line[..pos], start + pos_start, start + pos_tail, helper),
            }
        }
        [.., (_, Token::RSquare)] | [.., (_, Token::Question)] => {
            parse_value(&line[..pos], start + pos_start, pos, helper)
        }
        [.., (pos_tail, Token::Dot)]
        | [.., (pos_tail, Token::Dot), (_, _)]
        | [.., (pos_tail, Token::LSquare)]
        | [.., (pos_tail, Token::LSquare), (_, Token::Decimal(_))] => {
            parse_value(&line[..pos], start + pos_start, start + pos_tail, helper)
        }
        _ => None,
    }
}
fn parse_value(
    line: &str,
    start: usize,