A="`echo | tr '\012' '\001' `"
sed -e "s$A$1$A$2$A" $file

I am not able to understand the first line of the script.how is it working?

Warm Regards
Kamalpreet Singh

The new-line character is being replaced by control-a

You are displaying the guts of the 'gres' script from page 51 of "sed & awk" by Robbins and Dougherty:

http://www.amazon.com/gp/product/15...

gres stands for Global Regular Expression Substitution. According to the authors:

"The echo|tr ... line is a complicated but portable way to generate a Control-A character to use as the separator for the sed substitue command."

The shell variable "$A" is then used as the separator on the sed command. Using this method is better than embedding a control-a in the script.

Yes its the same book(first edi.),anyways what I fail to understand is how its generating CNTL A .using that command.pls eloborate
Also why is he not usung the any visible(printable) seprator that can be used like (|or/).

Warm Regards
Kamalpreet Singh

The echo command is echoing just an empty line, and each line in unix/linux terminates with one character referred to as a newline character. On other platforms it may be referred to as the linefeed or LF character. Code-wise, this is the decimal value 10, which is also octal value 12.

Let's echo an empty line and send it to a file:

echo > emptyline
wc -l < emptyline
ls -l emptyline

You can see from the above that we created a file with a single line, and the total size of that file is one character. That one character is the newline character that terminates that one empty line.

For the command string in question, the output of the echo (the empty line terminated by a linefeed) is not being sent to a disk file, but instead it is sent (piped) forward as input to the next command, which in this case is a tr command.

This particular tr command will change each linefeed character to a Ctrl-A character. An easy way to specify these special characters is via their octal values of 12 and 1 respectively.

The output of this entire pipe (a single Ctrl-A character) is captured in a shell variable named A. Another way to see what is going on is break it apart like this:

echo > emptyline
cat emptyline | tr '\012' '\001' > controlA
ls -l emptyline controlA
A=`cat controlA`

The ls command shows that both the emptyline and controlA files have a total size of one character. That character for emptyline is a newline (octal value 12), and the character for controlA is a Ctrl-A (octal value 1).

If you call each of these files up in vi, you will see nothing in emptyline because vi does not show the newline characters that terminate each line. But when you vi controlA, you will probably see the Ctrl-A character, represented on the screen as ^A. But there is a vi setting that tells whether it should visibly show non-graphical characters or not.

And you ask why he wants to use a non-printable character as a separator. If your old and new text strings are hard-coded, then of course you would know what they are, so you can use a separator (maybe a slash) that is not contained in either your old or new strings. But in this case, the old and new strings are coming in as variables $1 and $2. We do not know what these strings will be ahead of time. If you use a slash such as s/$1/$2/ then there will be an error if either $1 or $2 contains a slash.

So he wants to use a special separator that will never appear in a normal ascii data file.

James:

That's a most excellent explanation!

I get every BIT of it.Thanks for your time and effort for explaning it to me in such detail

Warm Regards
Kamalpreet Singh

No problem, kamalpreet. And thanks nails for the feedback - means a lot.

And here is an alternative for capturing an ascii character into a variable. I will use a lowercase "a" instead of the non-printing Ctrl-A because a printable character is easier to test with.

First, note that the following does NOT work:

A="\141"
echo $A
\141
echo ${#A}
4

Above, I attempt to store the letter a (as specified by its octal value 141) into the variable A.  But this actually stores the 4-character string \141, as shown by the first echo, and the second echo confirms that $A does in fact have a length of 4.

echo -e $A
a

Above, note that the echo -e option evaluates backslash-escaped character strings, so the output of this echo command is our desired letter a.  So we can take advantage of the echo conversion:

A=$(echo -e "\141")
echo $A
A
echo ${#A}
1

So the following will capture a Ctrl-A:

A=$(echo -e "\001")

Report Offensive Follow Up For Removal

Jim:

Since you've expanded the discussion on special characters: I once needed to know if a user pressed the TAB key and then pressed return. I deleted the TAB key from the string and if the resulting string were null, I knew the user had:

read variable # enter TAB key and press return

if [[ -z $(echo "$variable"|tr -d '\011') ]]
then # this statement executes if user enters a tab key
echo "variable is a TAB key"
fi
# end stub

Maybe there's a better way .....

We can capture a tab character into a variable if we first disable white space (spaces and tabs) as the word delimiter:

IFS=
tab=$(echo -e "\011")

or

IFS=
tab=$(echo -e '\t')

Then our check for a tab (and a script might have a bunch of these checks) is simple:

if [ "$variable" = $tab ] ...