zsh 0.8.13

Zsh interpreter and parser in Rust
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

//! Functions having to do with parser keywords, like testing if a function is a block command.

use crate::prelude::*;

struct ReservedWord {
    text: &'static wstr,
    is_reserved: bool,
    is_super_command: bool,
}

macro_rules! rw {
    ( ( $text:literal ) ) => {
        ReservedWord {
            text: L!($text),
            is_reserved: true,
            is_super_command: false,
        }
    };
    ( ( $text:literal, [subcommand] ) ) => {
        ReservedWord {
            text: L!($text),
            is_reserved: true,
            is_super_command: true,
        }
    };
    ( ( $text:literal, [subcommand], not reserved ) ) => {
        ReservedWord {
            text: L!($text),
            is_reserved: false,
            is_super_command: true,
        }
    };
}
macro_rules! reserved_words {
    ( $( $reserved_word:tt , ) * ) => {
        &[ $( rw!($reserved_word), )* ]
    }
}

// Don't forget to add any new reserved keywords to the documentation
const RESERVED_WORDS: &[ReservedWord] = reserved_words!(
    ("!", [subcommand], not reserved),
    ("["),
    ("_"),
    ("and", [subcommand]),
    ("argparse"),
    ("begin", [subcommand]),
    ("break"),
    ("builtin", [subcommand]),
    ("case"),
    ("command", [subcommand]),
    ("continue"),
    ("else", [subcommand]),
    ("end"),
    ("eval"),
    ("exec", [subcommand]),
    ("for"),
    ("function"),
    ("if", [subcommand]),
    ("not", [subcommand]),
    ("or", [subcommand]),
    ("read"),
    ("return"),
    ("set"),
    ("status"),
    ("string"),
    ("switch"),
    ("test"),
    ("time", [subcommand]),
    ("while", [subcommand]),
);

fn reserved_word(cmd: &wstr) -> Option<&'static ReservedWord> {
    RESERVED_WORDS
        .iter()
        .find(|reserved_word| reserved_word.text == cmd)
}

/// Tests if the specified command's parameters should be interpreted as another command.
pub fn parser_keywords_is_subcommand(cmd: &impl AsRef<wstr>) -> bool {
    reserved_word(cmd.as_ref()).is_some_and(|reserved_word| reserved_word.is_super_command)
}

/// Tests if the specified command is a reserved word, i.e. if it is the name of one of the builtin
/// functions that change the block or command scope, like 'for', 'end' or 'command' or 'exec'.
/// These functions may not be overloaded, so their names are reserved.
pub fn parser_keywords_is_reserved(word: &wstr) -> bool {
    reserved_word(word).is_some_and(|reserved_word| reserved_word.is_reserved)
}