Tips For Gracefully Handling Errors In Sed Scripts

Catching Errors in sed

Detecting errors is the first step towards handling them gracefully in sed scripts. The exit code of the last command executed is stored in the $? variable. Checking this variable after running sed allows detecting errors via non-zero exit codes.

Using Exit Codes to Detect Errors

A simple way to check for errors after running any sed command or script is to check the value of the $? variable in the shell environment sed executed in.

For example:

Table of Contents

sed 's/foo/bar/' file.txt
echo $?

If sed encountered no errors during execution, running the echo command will print 0. Any other value indicates an error occurred in the sed script.

Some common non-zero exit codes include:

1 – Unmatched syntax errors from illegal or malformed sed commands
2 – Errors accessing input files and data
126 – Permission issues accessing files or executing sed
127 – Could not find or execute the sed binary itself

The exact exit code helps determine what type of error was encountered.

Trapping Execution Halts

Without any special options, sed will stop executing a script immediately if it encounters a fatal error. This will lead to partial completion of the intended transformation or no output at all.

To avoid this behavior, the -e option can be used to tell sed to continue processing input even if execution of the script fails due to an error.

sed -e 's/foo/bar/; s/abc/xyz/' file.txt

In this example, if substituting “foo” fails, sed will go ahead and try substituting “abc” as well. This ensures the script is not halted completely due to errors.

Of course simply continuing with more commands does not handle or fix whatever underlying issue caused the initial failure. Robust error handling procedures should still be used in combination with -e to deal with errors gracefully.

Ignoring Selected Errors

Sometimes error messages themselves are not useful or needed, even when errors are being appropriately handled in the sed logic. Errors can be silenced by redirecting standard error output to /dev/null instead of displaying it.

Use /dev/null to Ignore Specific Error Messages

This Linux device file serves as a bit bucket to discard any data written to it. Redirecting sed’s standard error to /dev/null effectively ignores those error messages.

sed 's/foo/bar/' file.txt 2>/dev/null

With this simple tweak, any errors encountered while substituting “foo” with “bar” will not print any messages. Exit codes can still be checked separately to determine if an error took place.

Suppressing errors in this way keeps console or log output clean while allowing sed scripts to take other actions conditional upon errors occurring.

Debugging sed Scripts

Bugs in sed scripts can lead to subtle issues that may not directly trigger errors. Debugging scripts is crucial to fix these logical flaws in program flow or sed commands.

Use sed Options Like -n and -v for Debugging

sed provides options ideal for debugging script execution and narrowing down problems:

-n – Disable default printing of pattern space. Allows debug print statements to be added instead.
-v – Verbose mode showing decoded sed commands before they run.

For example, excessive output can be controlled with -n while -v traces script execution step-by-step:

sed -n -v '
  s/foo/bar/
  p
' file.txt

Debugging this way guides adding/fixing parts of the script until it operates as originally intended.

Example Debugging Script Step-By-Step

Consider debugging a sed script that has logical errors in substitution order and input file handling:

sed 's/red/green/; s/green/blue/' input.txt > output.txt

This script tries replacing “red” with “green” first, then “green” with “blue” in input.txt before writing to output.txt.

However, debugging reveals that the output still contains “red”:

sed -n -v 's/red/green/; s/green/blue/' input.txt > output.txt
+ s/red/green/
+ s/green/blue/

The verbose output shows that the first substitution command ran successfully. But because “green” did not exist in input.txt yet, the second command did nothing.

Changing the order of substitutions fixes the logic:

  
sed -n -v 's/green/blue/; s/red/green/' input.txt > output.txt
+ s/green/blue
+ s/red/green/

Now the script works as originally intended, revealed clearly through step-by-step debugging with sed options.

Recovering Gracefully

Simply being able to detect errors is not enough for robust sed scripting. Built-in error handling and recovery procedures are needed as well.

Use Conditionals and Control Flow to Handle Errors

sed has basic control flow statements to execute blocks of commands conditionally:

{ } – Group commands together in blocks.
b label – Unconditional branch to label.
t label – Branch to label only if s/// substitution was successful.
T label – Branch to label only if s/// substitution failed.

These statements allow executing specific error handling routines upon substitution failures and other errors:

/pattern/ {
  s/foo/bar/
  T recovery
  :success 
}

:recovery
  s/error/fixed/
  b success

Here T jumps to a recovery block if the s command fails, fixes an error, and loops back. This script now gracefully handles when the initial substitution encounters an error.

Print Custom Error Messages

In addition to automated error recovery procedures, sed can also be made to print custom error messages:

  
s/foo/bar/
T handle_error
b end

:handle_error
echo "SED: Error substituting foo with bar" >&2

:end

The T command branches to print an error message on stderr if the substitution fails, while allowing the overall script to continue.

Example Resilient Script with Recovery Procedures

Putting together conditional error handling, messages, and recovery logic results in resilient sed scripts:

/red/ {
  s/red/blue/
  T handle_red_error

  s/green/cyan/
  T handle_green_error  

  b colors_converted
}

:handle_red_error
echo "Error replacing red, reverting change" >&2
s/blue/red/
b colors_converted

:handle_green_error
echo "Error replacing green, aborting script" >&2 
q1  

:colors_converted
# Continue processing

This script attempts to replace multiple color names in input lines. If a substitution fails, custom error messages are printed. Recovery attempts made where possible, or quit script execution for unrecoverable failures.

Structured in this manner, even buggy sed scripts can fail gracefully!