From 0f938102cdd45c313b4decafef11f9308ddcb26b Mon Sep 17 00:00:00 2001
From: Bastien Orivel <eijebong@bananium.fr>
Date: Tue, 31 Oct 2017 17:57:46 +0100
Subject: [PATCH] Bump bitflags to 1.0
---
Cargo.lock | 2 +-
Cargo.toml | 2 +-
src/builtins/echo.rs | 24 ++---
src/parser/quotes.rs | 38 ++++----
src/parser/shell_expand/words/mod.rs | 136 +++++++++++++--------------
src/parser/statement/splitter.rs | 72 +++++++-------
src/shell/history.rs | 22 ++---
7 files changed, 148 insertions(+), 148 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 9b292005..36b078f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -116,7 +116,7 @@ version = "1.0.5"
dependencies = [
"ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
"app_dirs 1.1.1 (git+https://github.com/redox-os/app-dirs-rs.git)",
- "bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bitflags 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"calculate 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"errno 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/Cargo.toml b/Cargo.toml
index 774fb010..1cdfaa3b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,7 @@ ansi_term = "0.9"
version_check = "0.1.3"
[dependencies]
-bitflags = "0.9.1"
+bitflags = "1"
calculate = "0.5"
fnv = "1.0"
glob = "0.2"
diff --git a/src/builtins/echo.rs b/src/builtins/echo.rs
index 297d6ec8..1ec9c7f2 100644
--- a/src/builtins/echo.rs
+++ b/src/builtins/echo.rs
@@ -47,20 +47,20 @@ pub(crate) fn echo(args: &[&str]) -> Result<(), io::Error> {
for arg in args {
match *arg {
- "--help" => flags |= HELP,
- "--escape" => flags |= ESCAPE,
- "--no-newline" => flags |= NO_NEWLINE,
- "--no-spaces" => flags |= NO_SPACES,
+ "--help" => flags |= Flags::HELP,
+ "--escape" => flags |= Flags::ESCAPE,
+ "--no-newline" => flags |= Flags::NO_NEWLINE,
+ "--no-spaces" => flags |= Flags::NO_SPACES,
_ => if arg.starts_with('-') {
let mut is_opts = true;
let opts = &arg[1..];
let mut short_flags = Flags::empty();
for argopt in opts.chars() {
match argopt {
- 'e' => short_flags |= ESCAPE,
- 'n' => short_flags |= NO_NEWLINE,
- 's' => short_flags |= NO_SPACES,
- 'h' => short_flags |= HELP,
+ 'e' => short_flags |= Flags::ESCAPE,
+ 'n' => short_flags |= Flags::NO_NEWLINE,
+ 's' => short_flags |= Flags::NO_SPACES,
+ 'h' => short_flags |= Flags::HELP,
_ => {
is_opts = false;
break;
@@ -81,7 +81,7 @@ pub(crate) fn echo(args: &[&str]) -> Result<(), io::Error> {
let stdout = io::stdout();
let mut buffer = BufWriter::new(stdout.lock());
- if flags.contains(HELP) {
+ if flags.contains(Flags::HELP) {
buffer.write_all(MAN_PAGE.as_bytes())?;
buffer.flush()?;
return Ok(());
@@ -91,11 +91,11 @@ pub(crate) fn echo(args: &[&str]) -> Result<(), io::Error> {
for arg in data[1..].iter().map(|x| x.as_bytes()) {
if first {
first = false;
- } else if !flags.contains(NO_SPACES) {
+ } else if !flags.contains(Flags::NO_SPACES) {
buffer.write_all(&[b' '])?;
}
- if flags.contains(ESCAPE) {
+ if flags.contains(Flags::ESCAPE) {
let mut check = false;
for &byte in arg {
match byte {
@@ -154,7 +154,7 @@ pub(crate) fn echo(args: &[&str]) -> Result<(), io::Error> {
}
}
- if !flags.contains(NO_NEWLINE) {
+ if !flags.contains(Flags::NO_NEWLINE) {
buffer.write_all(&[b'\n'])?;
}
diff --git a/src/parser/quotes.rs b/src/parser/quotes.rs
index 6fdcb9d4..a07dd439 100644
--- a/src/parser/quotes.rs
+++ b/src/parser/quotes.rs
@@ -34,7 +34,7 @@ impl QuoteTerminator {
pub(crate) fn append(&mut self, input: String) {
if self.eof.is_none() {
- self.buffer.push_str(if self.flags.contains(TRIM) { input.trim() } else { &input });
+ self.buffer.push_str(if self.flags.contains(Flags::TRIM) { input.trim() } else { &input });
} else {
self.eof_buffer.push_str(&input);
}
@@ -58,9 +58,9 @@ impl QuoteTerminator {
b'\\' => {
let _ = bytes.next();
}
- b'\'' if !self.flags.intersects(DQUOTE) => self.flags ^= SQUOTE,
- b'"' if !self.flags.intersects(SQUOTE) => self.flags ^= DQUOTE,
- b'<' if !self.flags.contains(SQUOTE | DQUOTE) => {
+ b'\'' if !self.flags.intersects(Flags::DQUOTE) => self.flags ^= Flags::SQUOTE,
+ b'"' if !self.flags.intersects(Flags::SQUOTE) => self.flags ^= Flags::DQUOTE,
+ b'<' if !self.flags.contains(Flags::SQUOTE | Flags::DQUOTE) => {
let as_bytes = self.buffer.as_bytes();
if Some(&b'<') == as_bytes.get(self.read) {
self.read += 1;
@@ -69,59 +69,59 @@ impl QuoteTerminator {
str::from_utf8_unchecked(&as_bytes[self.read..])
};
self.eof = Some(eof_phrase.trim().to_owned());
- instance |= EOF;
+ instance |= Flags::EOF;
break;
}
}
}
- b'[' if !self.flags.intersects(DQUOTE | SQUOTE) => {
- self.flags |= ARRAY;
+ b'[' if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) => {
+ self.flags |= Flags::ARRAY;
self.array += 1;
}
- b']' if !self.flags.intersects(DQUOTE | SQUOTE) => {
+ b']' if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) => {
self.array -= 1;
if self.array == 0 {
- self.flags -= ARRAY
+ self.flags -= Flags::ARRAY
}
}
- b'#' if !self.flags.intersects(DQUOTE | SQUOTE) => if self.read > 1 {
+ b'#' if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) => if self.read > 1 {
let character = self.buffer.as_bytes().get(self.read - 2).unwrap();
if [b' ', b'\n'].contains(character) {
- instance |= COMM;
+ instance |= Flags::COMM;
break;
}
} else {
- instance |= COMM;
+ instance |= Flags::COMM;
break;
},
_ => (),
}
}
}
- if instance.contains(EOF) {
+ if instance.contains(Flags::EOF) {
self.buffer.push('\n');
return false;
- } else if instance.contains(COMM) {
+ } else if instance.contains(Flags::COMM) {
self.buffer.truncate(self.read - 1);
- return !self.flags.intersects(SQUOTE | DQUOTE | ARRAY);
+ return !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE | Flags::ARRAY);
}
}
- if self.flags.intersects(SQUOTE | DQUOTE | ARRAY) {
+ if self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE | Flags::ARRAY) {
if let Some(b'\\') = self.buffer.bytes().last() {
let _ = self.buffer.pop();
self.read -= 1;
- self.flags |= TRIM;
+ self.flags |= Flags::TRIM;
} else {
self.read += 1;
- self.buffer.push(if self.flags.contains(ARRAY) { ' ' } else { '\n' });
+ self.buffer.push(if self.flags.contains(Flags::ARRAY) { ' ' } else { '\n' });
}
false
} else {
if let Some(b'\\') = self.buffer.bytes().last() {
let _ = self.buffer.pop();
self.read -= 1;
- self.flags |= TRIM;
+ self.flags |= Flags::TRIM;
false
} else {
// If the last two bytes are either '&&' or '||', we aren't terminated yet.
diff --git a/src/parser/shell_expand/words/mod.rs b/src/parser/shell_expand/words/mod.rs
index 6cf6806a..5c644b27 100644
--- a/src/parser/shell_expand/words/mod.rs
+++ b/src/parser/shell_expand/words/mod.rs
@@ -90,7 +90,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
if character == b'}' {
let output = &self.data[start..self.read];
self.read += 1;
- return WordToken::Variable(output, self.flags.contains(DQUOTE), Select::All);
+ return WordToken::Variable(output, self.flags.contains(Flags::DQUOTE), Select::All);
}
self.read += 1;
}
@@ -191,11 +191,11 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
return if character == b'[' {
WordToken::Variable(
variable,
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
self.read_selection(iterator),
)
} else {
- WordToken::Variable(variable, self.flags.contains(DQUOTE), Select::All)
+ WordToken::Variable(variable, self.flags.contains(Flags::DQUOTE), Select::All)
};
}
_ => (),
@@ -203,7 +203,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
self.read += 1;
}
- WordToken::Variable(&self.data[start..], self.flags.contains(DQUOTE), Select::All)
+ WordToken::Variable(&self.data[start..], self.flags.contains(Flags::DQUOTE), Select::All)
}
fn read_selection<I>(&mut self, iterator: &mut I) -> Select
@@ -307,7 +307,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
b'[' => {
return WordToken::ArrayVariable(
&self.data[start..self.read],
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
self.read_selection(iterator),
)
}
@@ -315,7 +315,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
0...47 | 58...64 | 91...94 | 96 | 123...127 => {
return WordToken::ArrayVariable(
&self.data[start..self.read],
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
Select::All,
)
}
@@ -324,7 +324,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
self.read += 1;
}
- WordToken::ArrayVariable(&self.data[start..], self.flags.contains(DQUOTE), Select::All)
+ WordToken::ArrayVariable(&self.data[start..], self.flags.contains(Flags::DQUOTE), Select::All)
}
fn braced_array_variable<I>(&mut self, iterator: &mut I) -> WordToken<'a>
@@ -337,7 +337,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
b'[' => {
let result = WordToken::ArrayVariable(
&self.data[start..self.read],
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
self.read_selection(iterator),
);
self.read += 1;
@@ -354,7 +354,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
self.read += 1;
return WordToken::ArrayVariable(
output,
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
Select::All,
);
}
@@ -362,7 +362,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
0...47 | 58...64 | 91...94 | 96 | 123...127 => {
return WordToken::ArrayVariable(
&self.data[start..self.read],
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
Select::All,
)
}
@@ -370,7 +370,7 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
}
self.read += 1;
}
- WordToken::ArrayVariable(&self.data[start..], self.flags.contains(DQUOTE), Select::All)
+ WordToken::ArrayVariable(&self.data[start..], self.flags.contains(Flags::DQUOTE), Select::All)
}
/// Contains the logic for parsing subshell syntax.
@@ -381,27 +381,27 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
let mut level = 0;
while let Some(character) = iterator.next() {
match character {
- _ if self.flags.contains(BACKSL) => self.flags ^= BACKSL,
- b'\\' => self.flags ^= BACKSL,
- b'\'' if !self.flags.contains(DQUOTE) => self.flags ^= SQUOTE,
- b'"' if !self.flags.contains(SQUOTE) => self.flags ^= DQUOTE,
- b'$' if !self.flags.contains(SQUOTE) => {
+ _ if self.flags.contains(Flags::BACKSL) => self.flags ^= Flags::BACKSL,
+ b'\\' => self.flags ^= Flags::BACKSL,
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => self.flags ^= Flags::SQUOTE,
+ b'"' if !self.flags.contains(Flags::SQUOTE) => self.flags ^= Flags::DQUOTE,
+ b'$' if !self.flags.contains(Flags::SQUOTE) => {
if self.data.as_bytes()[self.read + 1] == b'(' {
level += 1;
}
}
- b')' if !self.flags.contains(SQUOTE) => if level == 0 {
+ b')' if !self.flags.contains(Flags::SQUOTE) => if level == 0 {
let output = &self.data[start..self.read];
self.read += 1;
return if let Some(&b'[') = self.data.as_bytes().get(self.read) {
let _ = iterator.next();
WordToken::Process(
output,
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
self.read_selection(iterator),
)
} else {
- WordToken::Process(output, self.flags.contains(DQUOTE), Select::All)
+ WordToken::Process(output, self.flags.contains(Flags::DQUOTE), Select::All)
};
} else {
level -= 1;
@@ -423,29 +423,29 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
let mut level = 0;
while let Some(character) = iterator.next() {
match character {
- _ if self.flags.contains(BACKSL) => self.flags ^= BACKSL,
- b'\\' => self.flags ^= BACKSL,
- b'\'' if !self.flags.contains(DQUOTE) => self.flags ^= SQUOTE,
- b'"' if !self.flags.contains(SQUOTE) => self.flags ^= DQUOTE,
- b'@' if !self.flags.contains(SQUOTE) => {
+ _ if self.flags.contains(Flags::BACKSL) => self.flags ^= Flags::BACKSL,
+ b'\\' => self.flags ^= Flags::BACKSL,
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => self.flags ^= Flags::SQUOTE,
+ b'"' if !self.flags.contains(Flags::SQUOTE) => self.flags ^= Flags::DQUOTE,
+ b'@' if !self.flags.contains(Flags::SQUOTE) => {
if self.data.as_bytes()[self.read + 1] == b'(' {
level += 1;
}
}
- b')' if !self.flags.contains(SQUOTE) => if level == 0 {
+ b')' if !self.flags.contains(Flags::SQUOTE) => if level == 0 {
let array_process_contents = &self.data[start..self.read];
self.read += 1;
return if let Some(&b'[') = self.data.as_bytes().get(self.read) {
let _ = iterator.next();
WordToken::ArrayProcess(
array_process_contents,
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
self.read_selection(iterator),
)
} else {
WordToken::ArrayProcess(
array_process_contents,
- self.flags.contains(DQUOTE),
+ self.flags.contains(Flags::DQUOTE),
Select::All,
)
};
@@ -470,16 +470,16 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
let mut elements = Vec::new();
while let Some(character) = iterator.next() {
match character {
- _ if self.flags.contains(BACKSL) => self.flags ^= BACKSL,
- b'\\' => self.flags ^= BACKSL,
- b'\'' if !self.flags.contains(DQUOTE) => self.flags ^= SQUOTE,
- b'"' if !self.flags.contains(SQUOTE) => self.flags ^= DQUOTE,
- b',' if !self.flags.intersects(SQUOTE | DQUOTE) && level == 0 => {
+ _ if self.flags.contains(Flags::BACKSL) => self.flags ^= Flags::BACKSL,
+ b'\\' => self.flags ^= Flags::BACKSL,
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => self.flags ^= Flags::SQUOTE,
+ b'"' if !self.flags.contains(Flags::SQUOTE) => self.flags ^= Flags::DQUOTE,
+ b',' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) && level == 0 => {
elements.push(&self.data[start..self.read]);
start = self.read + 1;
}
- b'{' if !self.flags.intersects(SQUOTE | DQUOTE) => level += 1,
- b'}' if !self.flags.intersects(SQUOTE | DQUOTE) => if level == 0 {
+ b'{' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => level += 1,
+ b'}' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => if level == 0 {
elements.push(&self.data[start..self.read]);
self.read += 1;
return WordToken::Brace(elements);
@@ -502,12 +502,12 @@ impl<'a, E: Expander + 'a> WordIterator<'a, E> {
let mut level = 0;
while let Some(character) = iterator.next() {
match character {
- _ if self.flags.contains(BACKSL) => self.flags ^= BACKSL,
- b'\\' => self.flags ^= BACKSL,
- b'\'' if !self.flags.contains(DQUOTE) => self.flags ^= SQUOTE,
- b'"' if !self.flags.contains(SQUOTE) => self.flags ^= DQUOTE,
- b'[' if !self.flags.intersects(SQUOTE | DQUOTE) => level += 1,
- b']' if !self.flags.intersects(SQUOTE | DQUOTE) => if level == 0 {
+ _ if self.flags.contains(Flags::BACKSL) => self.flags ^= Flags::BACKSL,
+ b'\\' => self.flags ^= Flags::BACKSL,
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => self.flags ^= Flags::SQUOTE,
+ b'"' if !self.flags.contains(Flags::SQUOTE) => self.flags ^= Flags::DQUOTE,
+ b'[' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => level += 1,
+ b']' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => if level == 0 {
let elements =
ArgumentSplitter::new(&self.data[start..self.read]).collect::<Vec<&str>>();
self.read += 1;
@@ -609,55 +609,55 @@ impl<'a, E: Expander + 'a> Iterator for WordIterator<'a, E> {
loop {
if let Some(character) = iterator.next() {
match character {
- _ if self.flags.contains(BACKSL) => {
+ _ if self.flags.contains(Flags::BACKSL) => {
self.read += 1;
- self.flags ^= BACKSL;
+ self.flags ^= Flags::BACKSL;
break;
}
b'\\' => {
- if !self.flags.intersects(DQUOTE | SQUOTE) {
+ if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) {
start += 1;
}
self.read += 1;
- self.flags ^= BACKSL;
+ self.flags ^= Flags::BACKSL;
break;
}
- b'\'' if !self.flags.contains(DQUOTE) => {
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => {
start += 1;
self.read += 1;
- self.flags ^= SQUOTE;
+ self.flags ^= Flags::SQUOTE;
break;
}
- b'"' if !self.flags.contains(SQUOTE) => {
+ b'"' if !self.flags.contains(Flags::SQUOTE) => {
start += 1;
self.read += 1;
- if self.flags.contains(DQUOTE) {
- self.flags -= DQUOTE;
+ if self.flags.contains(Flags::DQUOTE) {
+ self.flags -= Flags::DQUOTE;
return self.next();
}
- self.flags |= DQUOTE;
+ self.flags |= Flags::DQUOTE;
break;
}
- b' ' if !self.flags.intersects(DQUOTE | SQUOTE) => {
+ b' ' if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) => {
return Some(self.whitespaces(&mut iterator))
}
- b'~' if !self.flags.intersects(DQUOTE | SQUOTE) => {
+ b'~' if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) => {
tilde = true;
self.read += 1;
break;
}
- b'{' if !self.flags.intersects(DQUOTE | SQUOTE) => {
+ b'{' if !self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) => {
self.read += 1;
return Some(self.braces(&mut iterator));
}
- b'[' if !self.flags.intersects(SQUOTE | DQUOTE) => {
+ b'[' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => {
if self.glob_check(&mut iterator) {
glob = true;
} else {
return Some(self.array(&mut iterator));
}
}
- b'@' if !self.flags.contains(SQUOTE) => match iterator.next() {
+ b'@' if !self.flags.contains(Flags::SQUOTE) => match iterator.next() {
Some(b'(') => {
self.read += 2;
return Some(self.array_process(&mut iterator));
@@ -676,7 +676,7 @@ impl<'a, E: Expander + 'a> Iterator for WordIterator<'a, E> {
return Some(self.array_variable(&mut iterator));
}
},
- b'$' if !self.flags.contains(SQUOTE) => {
+ b'$' if !self.flags.contains(Flags::SQUOTE) => {
match iterator.next() {
Some(b'(') => {
self.read += 2;
@@ -721,10 +721,10 @@ impl<'a, E: Expander + 'a> Iterator for WordIterator<'a, E> {
while let Some(character) = iterator.next() {
match character {
- _ if self.flags.contains(BACKSL) => self.flags ^= BACKSL,
+ _ if self.flags.contains(Flags::BACKSL) => self.flags ^= Flags::BACKSL,
b'\\' => {
- self.flags ^= BACKSL;
- let end = if self.flags.intersects(DQUOTE | SQUOTE) {
+ self.flags ^= Flags::BACKSL;
+ let end = if self.flags.intersects(Flags::DQUOTE | Flags::SQUOTE) {
self.read + 1
} else {
self.read
@@ -733,22 +733,22 @@ impl<'a, E: Expander + 'a> Iterator for WordIterator<'a, E> {
self.read += 1;
return Some(WordToken::Normal(output, glob, tilde));
}
- b'\'' if !self.flags.contains(DQUOTE) => {
- self.flags ^= SQUOTE;
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => {
+ self.flags ^= Flags::SQUOTE;
let output = &self.data[start..self.read];
self.read += 1;
return Some(WordToken::Normal(output, glob, tilde));
}
- b'"' if !self.flags.contains(SQUOTE) => {
- self.flags ^= DQUOTE;
+ b'"' if !self.flags.contains(Flags::SQUOTE) => {
+ self.flags ^= Flags::DQUOTE;
let output = &self.data[start..self.read];
self.read += 1;
return Some(WordToken::Normal(output, glob, tilde));
}
- b' ' | b'{' if !self.flags.intersects(SQUOTE | DQUOTE) => {
+ b' ' | b'{' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => {
return Some(WordToken::Normal(&self.data[start..self.read], glob, tilde))
}
- b'$' | b'@' if !self.flags.contains(SQUOTE) => {
+ b'$' | b'@' if !self.flags.contains(Flags::SQUOTE) => {
if let Some(&character) = self.data.as_bytes().get(self.read) {
if character == b' ' {
self.read += 1;
@@ -763,17 +763,17 @@ impl<'a, E: Expander + 'a> Iterator for WordIterator<'a, E> {
return self.next();
};
}
- b'[' if !self.flags.intersects(SQUOTE | DQUOTE) => {
+ b'[' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => {
if self.glob_check(&mut iterator) {
glob = true;
} else {
return Some(WordToken::Normal(&self.data[start..self.read], glob, tilde));
}
}
- b'*' | b'?' if !self.flags.contains(SQUOTE) => {
+ b'*' | b'?' if !self.flags.contains(Flags::SQUOTE) => {
glob = true;
}
- b'~' if !self.flags.intersects(SQUOTE | DQUOTE) => {
+ b'~' if !self.flags.intersects(Flags::SQUOTE | Flags::DQUOTE) => {
let output = &self.data[start..self.read];
if output != "" {
return Some(WordToken::Normal(output, glob, tilde));
diff --git a/src/parser/statement/splitter.rs b/src/parser/statement/splitter.rs
index 4baac1ce..9c4b9f9a 100644
--- a/src/parser/statement/splitter.rs
+++ b/src/parser/statement/splitter.rs
@@ -125,68 +125,68 @@ impl<'a> Iterator for StatementSplitter<'a> {
self.read += 1;
bytes.next();
}
- _ if self.flags.contains(POST_MATHEXPR) => {
- self.flags -= POST_MATHEXPR;
+ _ if self.flags.contains(Flags::POST_MATHEXPR) => {
+ self.flags -= Flags::POST_MATHEXPR;
}
// [^A-Za-z0-9_:,}]
0...43 | 45...47 | 59...64 | 91...94 | 96 | 123...124 | 126...127
- if self.flags.contains(VBRACE) =>
+ if self.flags.contains(Flags::VBRACE) =>
{
// If we are just ending the braced section continue as normal
if error.is_none() {
error = Some(StatementError::InvalidCharacter(character as char, self.read))
}
}
- b'\'' if !self.flags.contains(DQUOTE) => {
- self.flags -= VARIAB | ARRAY;
+ b'\'' if !self.flags.contains(Flags::DQUOTE) => {
+ self.flags -= Flags::VARIAB | Flags::ARRAY;
self.read += self.single_quote(&mut bytes);
}
- // Toggle DQUOTE and disable VARIAB + ARRAY.
- b'"' => self.flags = (self.flags ^ DQUOTE) - (VARIAB | ARRAY),
- // Disable COMM_1 and enable COMM_2 + ARRAY.
+ // Toggle Flags::DQUOTE and disable Flags::VARIAB + Flags::ARRAY.
+ b'"' => self.flags = (self.flags ^ Flags::DQUOTE) - (Flags::VARIAB | Flags::ARRAY),
+ // Disable Flags::COMM_1 and enable Flags::COMM_2 + Flags::ARRAY.
b'@' => {
- self.flags = (self.flags - COMM_1) | (COMM_2 | ARRAY);
+ self.flags = (self.flags - Flags::COMM_1) | (Flags::COMM_2 | Flags::ARRAY);
continue;
}
b'$' => {
- self.flags = (self.flags - COMM_2) | (COMM_1 | VARIAB);
+ self.flags = (self.flags - Flags::COMM_2) | (Flags::COMM_1 | Flags::VARIAB);
continue;
}
- b'{' if self.flags.intersects(COMM_1 | COMM_2) => self.flags |= VBRACE,
- b'{' if !self.flags.contains(DQUOTE) => self.brace_level += 1,
- b'}' if self.flags.contains(VBRACE) => self.flags.toggle(VBRACE),
- b'}' if !self.flags.contains(DQUOTE) => if self.brace_level == 0 {
+ b'{' if self.flags.intersects(Flags::COMM_1 | Flags::COMM_2) => self.flags |= Flags::VBRACE,
+ b'{' if !self.flags.contains(Flags::DQUOTE) => self.brace_level += 1,
+ b'}' if self.flags.contains(Flags::VBRACE) => self.flags.toggle(Flags::VBRACE),
+ b'}' if !self.flags.contains(Flags::DQUOTE) => if self.brace_level == 0 {
if error.is_none() {
error = Some(StatementError::InvalidCharacter(character as char, self.read))
}
} else {
self.brace_level -= 1;
},
- b'(' if self.flags.contains(MATHEXPR) => {
+ b'(' if self.flags.contains(Flags::MATHEXPR) => {
self.math_paren_level += 1;
}
- b'(' if !self.flags.intersects(COMM_1 | VARIAB | ARRAY) => {
- if error.is_none() && !self.flags.contains(DQUOTE) {
+ b'(' if !self.flags.intersects(Flags::COMM_1 | Flags::VARIAB | Flags::ARRAY) => {
+ if error.is_none() && !self.flags.contains(Flags::DQUOTE) {
error = Some(StatementError::InvalidCharacter(character as char, self.read))
}
}
- b'(' if self.flags.intersects(COMM_1 | METHOD) => {
- self.flags -= VARIAB | ARRAY;
+ b'(' if self.flags.intersects(Flags::COMM_1 | Flags::METHOD) => {
+ self.flags -= Flags::VARIAB | Flags::ARRAY;
if self.data.as_bytes()[self.read] == b'(' {
- self.flags = (self.flags - COMM_1) | MATHEXPR;
+ self.flags = (self.flags - Flags::COMM_1) | Flags::MATHEXPR;
// The next character will always be a left paren in this branch;
self.math_paren_level = -1;
} else {
self.p_level += 1;
}
}
- b'(' if self.flags.contains(COMM_2) => {
+ b'(' if self.flags.contains(Flags::COMM_2) => {
self.ap_level += 1;
}
- b'(' if self.flags.intersects(VARIAB | ARRAY) => {
- self.flags = (self.flags - (VARIAB | ARRAY)) | METHOD;
+ b'(' if self.flags.intersects(Flags::VARIAB | Flags::ARRAY) => {
+ self.flags = (self.flags - (Flags::VARIAB | Flags::ARRAY)) | Flags::METHOD;
}
- b')' if self.flags.contains(MATHEXPR) => if self.math_paren_level == 0 {
+ b')' if self.flags.contains(Flags::MATHEXPR) => if self.math_paren_level == 0 {
if self.data.as_bytes().len() <= self.read {
if error.is_none() {
error = Some(StatementError::UnterminatedArithmetic)
@@ -194,7 +194,7 @@ impl<'a> Iterator for StatementSplitter<'a> {
} else {
let next_character = self.data.as_bytes()[self.read] as char;
if next_character == ')' {
- self.flags = (self.flags - MATHEXPR) | POST_MATHEXPR;
+ self.flags = (self.flags - Flags::MATHEXPR) | Flags::POST_MATHEXPR;
} else if error.is_none() {
error =
Some(StatementError::InvalidCharacter(next_character, self.read));
@@ -203,24 +203,24 @@ impl<'a> Iterator for StatementSplitter<'a> {
} else {
self.math_paren_level -= 1;
},
- b')' if self.flags.contains(METHOD) && self.p_level == 0 => {
- self.flags ^= METHOD;
+ b')' if self.flags.contains(Flags::METHOD) && self.p_level == 0 => {
+ self.flags ^= Flags::METHOD;
}
b')' if self.p_level + self.ap_level == 0 => {
- if error.is_none() && !self.flags.contains(DQUOTE) {
+ if error.is_none() && !self.flags.contains(Flags::DQUOTE) {
error = Some(StatementError::InvalidCharacter(character as char, self.read))
}
}
b')' if self.p_level != 0 => self.p_level -= 1,
b')' => self.ap_level -= 1,
- b';' if !self.flags.contains(DQUOTE) && self.p_level == 0 && self.ap_level == 0 => {
+ b';' if !self.flags.contains(Flags::DQUOTE) && self.p_level == 0 && self.ap_level == 0 => {
return match error {
Some(error) => Some(Err(error)),
None => Some(Ok(self.data[start..self.read - 1].trim())),
}
}
b'#' if self.read == 1
- || (!self.flags.contains(DQUOTE) && self.p_level + self.ap_level == 0
+ || (!self.flags.contains(Flags::DQUOTE) && self.p_level + self.ap_level == 0
&& match self.data.as_bytes()[self.read - 2] {
b' ' | b'\t' => true,
_ => false,
@@ -256,11 +256,11 @@ impl<'a> Iterator for StatementSplitter<'a> {
}
}
// [^A-Za-z0-9_]
- byte => if self.flags.intersects(VARIAB | ARRAY) {
- self.flags -= if is_invalid(byte) { VARIAB | ARRAY } else { Flags::empty() };
+ byte => if self.flags.intersects(Flags::VARIAB | Flags::ARRAY) {
+ self.flags -= if is_invalid(byte) { Flags::VARIAB | Flags::ARRAY } else { Flags::empty() };
},
}
- self.flags -= COMM_1 | COMM_2;
+ self.flags -= Flags::COMM_1 | Flags::COMM_2;
}
if start == self.read {
@@ -272,14 +272,14 @@ impl<'a> Iterator for StatementSplitter<'a> {
None if self.p_level != 0 || self.ap_level != 0 || self.a_level != 0 => {
Some(Err(StatementError::UnterminatedSubshell))
}
- None if self.flags.contains(METHOD) => {
+ None if self.flags.contains(Flags::METHOD) => {
Some(Err(StatementError::UnterminatedMethod))
}
- None if self.flags.contains(VBRACE) => {
+ None if self.flags.contains(Flags::VBRACE) => {
Some(Err(StatementError::UnterminatedBracedVar))
}
None if self.brace_level != 0 => Some(Err(StatementError::UnterminatedBrace)),
- None if self.flags.contains(MATHEXPR) => {
+ None if self.flags.contains(Flags::MATHEXPR) => {
Some(Err(StatementError::UnterminatedArithmetic))
}
None => {
diff --git a/src/shell/history.rs b/src/shell/history.rs
index 0917e89f..168e0d3b 100644
--- a/src/shell/history.rs
+++ b/src/shell/history.rs
@@ -9,13 +9,13 @@ bitflags! {
struct IgnoreFlags: u8 {
// Macro definition fails if last flag has a comment at the end of the line.
/// ignore all commands ("all")
- const IGNORE_ALL = (0b1 << 0);
+ const ALL = (0b1 << 0);
/// ignore commands with leading whitespace ("whitespace")
- const IGNORE_WHITESPACE = (0x1 << 1);
+ const WHITESPACE = (0x1 << 1);
/// ignore commands with status code 127 ("no_such_command")
- const IGNORE_NO_SUCH_COMMAND = (0b1 << 2);
+ const NO_SUCH_COMMAND = (0b1 << 2);
/// used if regexes are defined.
- const IGNORE_BASED_ON_REGEX = (0b1 << 3);
+ const BASED_ON_REGEX = (0b1 << 3);
}
}
@@ -119,12 +119,12 @@ impl ShellHistory for Shell {
let regex_prefix = "regex:";
for pattern in patterns {
match pattern.as_ref() {
- "all" => flags |= IGNORE_ALL,
- "no_such_command" => flags |= IGNORE_NO_SUCH_COMMAND,
- "whitespace" => flags |= IGNORE_WHITESPACE,
+ "all" => flags |= IgnoreFlags::ALL,
+ "no_such_command" => flags |= IgnoreFlags::NO_SUCH_COMMAND,
+ "whitespace" => flags |= IgnoreFlags::WHITESPACE,
// The length check is there to just ignore empty regex definitions
_ if pattern.starts_with(regex_prefix) && pattern.len() > regex_prefix.len() => {
- flags |= IGNORE_BASED_ON_REGEX;
+ flags |= IgnoreFlags::BASED_ON_REGEX;
let regex_string = &pattern[regex_prefix.len()..];
// We save the compiled regexes, as compiling them can be an expensive task
if let Ok(regex) = Regex::new(regex_string) {
@@ -148,19 +148,19 @@ impl ShellHistoryPrivate for Shell {
// without the second check the command which sets the local variable would also be
// ignored. However, this behavior might not be wanted.
- if ignore.contains(IGNORE_ALL) && !command.contains("HISTORY_IGNORE") {
+ if ignore.contains(IgnoreFlags::ALL) && !command.contains("HISTORY_IGNORE") {
return false;
}
// Here we allow to also ignore the setting of the local variable because we assume
// the user entered the leading whitespace on purpose.
- if ignore.contains(IGNORE_WHITESPACE) {
+ if ignore.contains(IgnoreFlags::WHITESPACE) {
if command.chars().next().map_or(false, |b| b.is_whitespace()) {
return false;
}
}
- if ignore.contains(IGNORE_NO_SUCH_COMMAND) && self.previous_status == NO_SUCH_COMMAND {
+ if ignore.contains(IgnoreFlags::NO_SUCH_COMMAND) && self.previous_status == NO_SUCH_COMMAND {
return false;
}
--
GitLab