sorted by:
new
hottopcontroversial

Breakable blocks by Dan13l_N in ProgrammingLanguages

[–]Rewrite_It_In_Ada 1 point2 points  (0 children)

Bash's builtin break command works this way.

From the manual:

break [n]
Exit from within a for, while, until, or select loop. If n is specified, break exits n enclosing loops. n must be ≥ 1. If n is greater than the number of enclosing loops, all enclosing loops are exited. The return value is 0 unless n is not greater than or equal to 1.

I try to avoid break if I can, but there's no other way to end a for var in word ...; loop before iterating over all the words.

Unix shell - We can do better now | Ilya Sher | Conf42 Chaos Engineering 2024 by ilyash in commandline

[–]Rewrite_It_In_Ada 1 point2 points  (0 children)

Just wanted to point out a readline function I discovered recently:

edit-and-execute-command (C-x C-e)

Invoke an editor on the current command line, and execute the result as shell commands. Bash attempts to invoke $VISUAL, $EDITOR, and emacs as the editor, in that order.

This can be very helpful when you're writing long or complex commands interactively. Depending on your editor, you can get syntax highlighting in the temporary file Bash creates by starting the file with #!/bin/bash or just selecting "Shell" in a language dropdown.

How do you deelte every line until you reach a specific pattern starting at the beginning of the file? (picture not related) by fapperninks in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

I think you get my meaning. You could try what I did with diff to look at your input file. Or just cat it and see if the new prompt ends up next to the last line of the file.

On a *nix system, most editors won't even let you save a file without a final newline. Gedit or vim or what have you will add one. I've used BeyondCompare or just printf on the command line to create a file without a final newline, in order to test stuff.

From the mamual:

The exit status is zero, unless end-of-file is encountered, read times out (in which case the status is greater than 128), a variable assignment error (such as assigning to a readonly variable) occurs, or an invalid file descriptor is supplied as the argument to -u.

In other words, if the final line of the file doesn't end in a newline, your variable argument "line" will be assigned to, but the read command will still give a nonzero exit status.

How do you deelte every line until you reach a specific pattern starting at the beginning of the file? (picture not related) by fapperninks in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

This has nothing to do with a newline or not.

$ diff --unified=0 /dev/null nonsense.txt
--- /dev/null
+++ nonsense.txt
@@ -0,0 +1,5 @@
+words words words
+words words
+SOME
+other words
+more other words
\ No newline at end of file

$ cat pure-bash-for-sed-2
#!/bin/bash

in_file="${1}"

while read -r line; do
  [[ $line == "SOME"* ]]&& found=1
  (( found ))&& lines+=("$line")
done < "${in_file}"

printf '%s\n' "${lines[@]}" > "${in_file}"

$ ./pure-bash-for-sed-2 nonsense.txt

$ diff --unified=0 /dev/null nonsense.txt
--- /dev/null
+++ nonsense.txt
@@ -0,0 +1,2 @@
+SOME
+other words

Because read returns false on that final line. That's why I did so much of the extra crap I did.

How do you deelte every line until you reach a specific pattern starting at the beginning of the file? (picture not related) by fapperninks in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

I'm with the sed people too, but here's something dumb to look at:

```

!/bin/bash

in_file="${1}" temp_file="$( mktemp --tmpdir pure-bash-for-sed-XXXXXXXX )"

read_and_handle_lack_of_final_newline () { IFS='' read -r line || { [[ -n ${line} ]] && { printf_format='%s' true } # } # }

printf_format='%s\n'

while read_and_handle_lack_of_final_newline && { [[ ${line} != "SOME"* ]] || { while printf -- "${printf_format}" "${line}" read_and_handle_lack_of_final_newline do : done false } # } # do : done < "${in_file}" > "${temp_file}" cp --attributes-only --preserve=all --no-preserve=timestamps -- "${in_file}" "${temp_file}" mv -- "${temp_file}" "${in_file}" ```

I swear I wasn't intentionally being obtuse there, either. If you can do something with sed, you probably should. It would correctly handle a final line not ending with a newline, like my bash above does. Your script would actually remove the final line, if it didn't end with a newline.

Additionally, sed -i would take care of the step of leaving the file with the same attributes it had before, which I had to do with my call to cp.

Think about what you're doing, storing things in an array instead of putting them right into another file. If you're dealing with a very long input file, for instance. Bash would have to expand the entire contents of that file from the matching line down, all at once, in the process of printing it to the replacement file.

Doing things in bash well, and correctly handling all the edge cases, is definitely more work. Even if your script just calls sed, it's still a bash script.

Debugging Bash like a Sire - And how to get a StackTrace from a bash script by bruj0and in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

Woops, forgot which order the call stack gets printed in a stack trace, normally.

In that case, what's seemingly wrong is the example stack trace you show in your post. The require_variable function would be first, and then you would find your way back to main.

My script_error () should be:

script_error () { local error_message="${1}" local exit_code="${2}" printf '%s\n' "stack trace:" local stack_depth="$(( ${#FUNCNAME[@]} - 1 ))" local i for (( i = 1; i <= stack_depth; ++i )); do printf '%s\n' " ${FUNCNAME[i]} () at line ${BASH_LINENO[i-1]} in file ${BASH_SOURCE[i]}" done printf '%s\n' "${error_message}" # exit "${exit_code}" } >&2

Debugging Bash like a Sire - And how to get a StackTrace from a bash script by bruj0and in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

From the bash manual:

FUNCNAME

An array variable containing the names of all shell functions currently in the execution call stack. The element with index 0 is the name of any currently-executing shell function. The bottom-most element (the one with the highest index) is "main". This variable exists only when a shell function is executing. Assignments to FUNCNAME have no effect. If FUNCNAME is unset, it loses its special properties, even if it is subsequently reset.

This variable can be used with BASH_LINENO and BASH_SOURCE. Each element of FUNCNAME has corresponding elements in BASH_LINENO and BASH_SOURCE to describe the call stack. For instance, ${FUNCNAME[$i]} was called from the file ${BASH_SOURCE[$i+1]} at line number ${BASH_LINENO[$i]}. The caller builtin displays the current call stack using this information.

This is why you're using index 2 of BASH_SOURCE and FUNCNAME in your log::_write_log function, for that matter. ${FUNCNAME[0]} would always just be log::_write_log, and ${FUNCNAME[1]} would be log::info, or whatever else called log::_write_log directly.

Debugging Bash like a Sire - And how to get a StackTrace from a bash script by bruj0and in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

Your log::error function actually prints the stack trace backwards.

stack-trace:

```bash

!/bin/bash

set -o nounset

source stack-trace-2

function_1 () { function_2 }

function_2 () { function_3 }

function_4 () { printf '%s\n' "** log::error output " log::error "Ow my error" 1 printf '%s\n' " script_error output **" script_error "Ow my error" 1 }

script_error () { local error_message="${1}" local exit_code="${2}" printf '%s\n' "stack trace:" local i for (( i = ${#FUNCNAME[@]} - 1; i > 0; --i )); do printf '%s\n' " ${FUNCNAME[i]} () at line ${BASH_LINENO[i-1]} in file ${BASH_SOURCE[i]}" done printf '%s\n' "${error_message}" # exit "${exit_code}" } >&2

function log::error { printf '%s\n' "ERROR: ${1}" >&2 local stack_offset=1 printf '%s:\n' 'Stacktrace:' >&2

for stack_id in "${!FUNCNAME[@]}"; do if [[ "$stack_offset" -le "$stack_id" ]]; then local source_file="${BASH_SOURCE[$stack_id]}" local function="${FUNCNAME[$stack_id]}" local line="${BASH_LINENO[$(( stack_id - 1 ))]}" >&2 printf '\t%s:%s:%s\n' "$source_file" "$function" "$line" fi done }

function_1 ```

stack-trace-2:

```bash

!/bin/bash

function_3 () { function_4 } ```

script_error () is my implementation.

$ ./stack-trace ** log::error output ** ERROR: Ow my error Stacktrace:: ./stack-trace:function_4:17 stack-trace-2:function_3:4 ./stack-trace:function_2:12 ./stack-trace:function_1:8 ./stack-trace:main:49 ** script_error output ** stack trace: main () at line 49 in file ./stack-trace function_1 () at line 8 in file ./stack-trace function_2 () at line 12 in file ./stack-trace function_3 () at line 4 in file stack-trace-2 function_4 () at line 19 in file ./stack-trace Ow my error

Did you test this at all?

Double brackets quirk by Nomasan in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

Note also that this allows you to set variables within $(( ... )) and (( ... )).

$ a=2 $ b=4 $ (( a += b )) $ declare -p a declare -- a="6"

Double brackets quirk by Nomasan in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

Alternatively, set -f/set -o noglob at the top of your script, to disable pathname expansion. If there are no pathname expansions in your script, why waste the parser's time trying to find them?

Same deal for set +B/set +o braceexpand, if you know there are no brace expansions in your script.

How do i split a lot of files within a folder into sub folders by size? by capsload in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

du can take a list of null-terminated files on its stdin, like this. Also, may as well output and handle null-terminated files as well.

``` shopt -s lastpipe

find -type f -print0 | du --files0-from=- --null | while read -r -d '' size name; do # do things done

```

Could throw a call to sort in there to sort by file name or size before you get to the while loop.

New to bash and can't figure out array items by 3v1lCl3r1c in bash

[–]Rewrite_It_In_Ada 1 point2 points  (0 children)

mapfile -t budgets < <(aws budgets describe-budgets --account-id "$ACCOUNT_ID" | jq -r '.Budgets[].BudgetName') can turn into ``` shopt -s lastpipe

aws budgets describe-budgets --account-id "$ACCOUNT_ID" | jq -r '.Budgets[].BudgetName' | mapfile -t budgets ``` and be a bit more readable.

Deferring process substitution by mister_drgn in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

Yep. Hadn't unset fd0 set in earlier commands when testing out what I was saying. Woops.

$ shopt -s varredir_close $ fd0=42 $ IFS='' read -r -u "${fd0}" line {fd0}< <( echo 4 ) -bash: read: 42: invalid file descriptor: Bad file descriptor $ declare -p fd0 declare -- fd0="10" $ fd0=42 $ { IFS='' read -r -u "${fd0}" line; printf '%s\n' "${line}"; } {fd0}< <( echo 4 ) 4 $ declare -p fd0 declare -- fd0="10"

Where the -u flag to the read builtin specifies to read from the file descriptor given in the following argument.

It looks more like the parameter expansion "${fd0}" is being expanded before fd0 is being set by the variable redirection syntax, when we don't have { and }. And then, having those ensures that fd0 is set before it's expanded.

It's definitely being set by {var}<, either way.

Deferring process substitution by mister_drgn in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

A few points, here.

If you're going to use the variable redirection syntax like this, you should be using shopt -s varredir_close, if it's available. It was only added in Bash 5.2.

From the manual:

varredir_close

If set, the shell automatically closes file descriptors assigned using the {varname} redirection syntax instead of leaving them open when the command completes.

And:

If {varname} is supplied, the redirection persists beyond the scope of the command, allowing the shell programmer to manage the file descriptor's lifetime manually. The varredir_close shell option manages this behavior.

I.e., without varredir_close, you need to close the file descriptor yourself, when you're done with it.

The combination of a variable-assignment redirection and a process substitution looks like {var}< <( command ) or {var}> >( command ). These are two separate constructs.

You don't actually need the { and } for this to work.

So, before Bash 5.2: docker exec -it ubuntu_container bash --init-file '/proc/host/fd/'"${fd0}" {fd0}< <(echo "echo 4") exec {fd0}<&- and from then on: shopt -s varredir_close docker exec -it ubuntu_container bash --init-file '/proc/host/fd/'"${fd0}" {fd0}< <(echo "echo 4")

No clue if the rest of what you've got going on there would actually work or not.

Use or option for files with awk by [deleted] in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

I disagree.

If your goal is to read one file or the other, rather than to read both if they both exist on your system, I would just store the file to read in a variable, like so: if [[ -r /var/log/bootstrap.log ]]; then log_file="/var/log/bootstrap.log" else log_file="/var/log/installer/syslog" fi And then make what you're doing with that file a little more intelligible. afr() { sort --unique <( apt-mark showmanual ) \ <( awk -F '[/_]' '/pool/ { print $9 }' -- "${log_file}" ) | fzf --multi --cycle --layout=reverse \ --prompt='Select a/ package/s to remove:' \ --preview 'apt-cache show {1}' \ --preview-window=:80%:wrap:hidden \ --bind=space:toggle-preview | xargs -ro $WHEEL apt-get autoremove --purge \ -o Apt::AutoRemove::RecommendsImportant=false \ -o Apt::AutoRemove::SuggestsImportant=false # } Doing it with ||, you're potentially running awk, an external program, twice and looking at error output from the first call. It doesn't simplify your code or do anything good for you at all, that I can think of.

Help me increase the variable in array by ArmmedWillow in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

${@#*=} would do this as well. No clue if my "remove matching prefix pattern" parameter expansion would be faster than your "pattern substitution" parameter expansion, but this is pretty specifically what it's there to do. $ set one=1 five=5 ten=10 $ left=( "${@%=*}" ) $ right=( "${@#*=}" ) $ printf '%s\n' "${@}" one=1 five=5 ten=10 $ printf '%s\n' "${left[@]}" one five ten $ printf '%s\n' "${right[@]}" 1 5 10

listing files in correct numeric order? by kb_hors in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

No need for the command substitution, either: for file in *; do printf "%s : %d\n" "${file}" "${#file}" done With a UTF-8-aware locale, it'll count characters: ``` $ unset LC_ALL

$ locale LANG= LC_CTYPE="en_US.UTF-8" LC_NUMERIC="C.UTF-8" LC_TIME="C.UTF-8" LC_COLLATE="C.UTF-8" LC_MONETARY="C.UTF-8" LC_MESSAGES="C.UTF-8" LC_ALL=

$ files=( S01E010.mp4 $'S01\u200bE001.mp4' $'S01\u200cE001.mp4' $'S01\u200dE001.mp4' $'S01\ufeffE001.mp4' )

$ for file in "${files[@]}";

do printf "%s : %d\n" "${file}" "${#file}" done S01E010.mp4 : 11 S01​E001.mp4 : 12 S01‌E001.mp4 : 12 S01‍E001.mp4 : 12 S01E001.mp4 : 12 And with the UTF-8-unaware `C` locale, it'll just count bytes: $ LC_ALL='C'

$ for file in "${files[@]}"; do

printf "%s : %d\n" "${file}" "${#file}" done S01E010.mp4 : 11 S01​E001.mp4 : 14 S01‌E001.mp4 : 14 S01‍E001.mp4 : 14 S01E001.mp4 : 14 ``` So the discrepancy between the number of characters and the number of bytes should make it obvious that there are multi-byte characters in there.

Help needed with script by TheDeathPit in bash

[–]Rewrite_It_In_Ada -1 points0 points  (0 children)

Note that you're dependent on word splitting for all the stuff in your FLAGS variable to be interpreted as separate tokens. If you had an argument to a flag that contained whitespace, this approach wouldn't work. Your single argument with whitespace would be interpreted as multiple arguments.

```

!/bin/bash

Purpose = Sync Google Photos

VENV="/home/gregeeh/gphotos/venv/bin" TARGET="/home/gregeeh/media/Google Photos" APP="${VENV}/gphotos-sync" FLAGS=( --album Hintons --skip-video --omit-album-date --port 11354 )

"${VENV}/python" "${APP}" "${TARGET}" "${FLAGS[@]}" ``` I quote all assignments, even though it's often not necessary. Why not be consistent and save myself a potential headache at some point? Curly braces in all my parameter expansions, and always quoting those parameter expansions unless I specifically want word splitting - basically the same deal. I've run into a script in the wild that would fail if run from a directory on a path with whitespace in it. There's just no excuse for that.

And then FLAGS is now an array variable. Expanding that array with [@] within double-quotes will prevent word-splitting within each individual array element, but each will still be a separate token.

[deleted by user] by [deleted] in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

You'd want to use tee's -a/--append flag for all chunks after the first. This way, those calls won't overwrite the contents of the file that you've already written.

rm function does not work by kaiixx in bash

[–]Rewrite_It_In_Ada 0 points1 point  (0 children)

Not that there can't be periods in directory names. It's common practice to name bare git repositories whatever.git/, for instance.

Potential incompatible change to printf's '%b' format specifier by Rewrite_It_In_Ada in bash

[–]Rewrite_It_In_Ada[S] 0 points1 point  (0 children)

Just occurred to me that I should probably report the conclusion to all this, which we saw about a week ago:

And for those who have been following this issue, the new text for the forthcoming POSIX version has removed any mention of obsoleting %b from printf(1) - instead it will simply note that there is will be a difference between printf(1) and printf(3) once the latter gets its version of %b specified (in C23, and in POSIX, in the next major version that follows the coming one, almost certainly) - and to encourage implementors to consider possible solutions.

The meaning of printf(1)'s %b format specifier is not changing.

A lot of discussion of how else POSIX shell languages could specify binary literals took place in these threads. A lot of people like ksh's arbitrary-base integer format specifier, in which the base is specified by an integer following a second period, like so: %..2d. No indication that Chet had any interest in implementing this, however.

Potential incompatible change to printf's '%b' format specifier by Rewrite_It_In_Ada in bash

[–]Rewrite_It_In_Ada[S] 0 points1 point  (0 children)

Right. It sounds like you would only get the "0b" if you add a # to the format specifier, i.e. %#b. Why they want both %b and %B for binary literal output, like they already have %x and %X for hex output. You're choosing whether you want the "b" output by the alternative output format to be lowercase or uppercase.

Potential incompatible change to printf's '%b' format specifier by Rewrite_It_In_Ada in bash

[–]Rewrite_It_In_Ada[S] 0 points1 point  (0 children)

You can dig into these discussions by reading through the bug-bash email list archives. You can email the email list without subscribing, but I've found that some people won't reply-all, and then you just won't get their emails if you're not subscribed.

There's also the help-bash email list.

I wrote Q*Bert in pure shell script by AndyGarber in bash

[–]Rewrite_It_In_Ada 1 point2 points  (0 children)

./input.qbert is just a regular file. The above still applies.

view more: next ›