Very Computer

I'm working on a bourne shell utility script that reads
a bourne shell script, modifies then outputs it.
Obviously, there're problems inherent in that process.
I've managed to avoid read's destruction of the input
when it encounters a backslash, but now I'm stuck at the
output. (Read on before you suggest an answer :-)

One criteria is that whatever command or utility I use
must work in plain, vanilla bourne shell and must be a
VERY common utility (sed, awk, etc.). Portability
across platforms is critical (Solaris, HP-UX, AIX,
Linux) and assuming that anything but the bare minimum
installation is in place would be trouble.

printf works great, but may not be available. So far,
my attempts to get awk to do the job have not been
pretty (I can't seem to get the quoting right to pass
the string as-is to awk). Here's an example line that
causes problems:
_ECHO='echo' ; [ "x`echo \"\n\"`" = 'x\n' ] && ECHO="echo -e"

As you can see, the presence of \n as well as single and
double quotes makes it tricky. All I want to do is output
it to a file as-is, but... (I can't process the line to
add backslashes since that usually involves echo-ing it
through sed or somesuch and echo would corrupt the line.)

Any suggestions? Tricks? I could include a small utility
with the script, one for each target platform, if I had
to as long as there were no legal restrictions on its
distribution (it wouldn't be part of our product, just
a necessary helper). -Wm

'read -r' will read it unmodified.  (tested and confirmed).

--

Linux solution for data management and processing.

Not sure I understood what you wanted but to safely and portably
print a string (with an additional linefeed), there's

cat << EOS
$string
EOS

or

expr "x$string" : 'x\(.*\)'

To print a string without an additional linefeed, provided the
string doesn't contain linefeeds itself, you can add a "| tr -d
\\12"

awk 'END{printf("%s", string)}' string="$string" < /dev/null

might be portable enough.

--
Stphane

in comp.unix.shell i read:

on a vanilla bourne shell?

--
bringing you boring signatures for 17 years

Are you sure, your solutions will output a file like

foo\bar
next\net
something\\more

_including_ all the backslashes as they are (ie: _unchanged_)?

That was OP's main point: process a file through $YET_TO_BE_DEFINED_TOOL
  doing some clever things but maintain the specials (quotes, backticks,
dollars, backslashes, you name it, they've got it).

cheers
robert

Quote:> Not sure I understood what you wanted but to safely and portably
> print a string (with an additional linefeed), there's

> cat << EOS
> $string
> EOS

Do'h! After all my head scratching, it never occured to me
to use cat and a here document to solve the problem. Looks
like that does the trick.

Testing my "bad boy" line:
 Input: _ECHO='echo' ; [ "x`echo \"\n\"`" = 'x\n' ] && _ECHO="echo -e"
Output: _ECHO='echo' ; [ "x`echo \"\n\"`" = 'x\n' ] && _ECHO="echo -e"

Huzzah!

Thanks! -Wm

Why not:
#include <stdio.h>
int main(int argc, char *argv[]){
        int i;
        for(i = 1; i<argc;i++)
                printf("%s",argv[i]);
        return 0;

Quote:}

Example usage:
./stupidecho 'Hello\n' "\n"
Will echo:
Hello\n

Also, echo -E may work. Or:
cat << EOF
Hello\n
EOF

--
Replace spamtrap with bd to reply.
"They that can give up essential liberty to obtain a little temporary
safety deserve neither liberty nor safety."
                -- Benjamin Franklin, 1759

in comp.unix.shell i read:

[snip a c program]

not all systems provide c compilers.

Quote:>cat << EOF
>Hello\n
>EOF

no need for the `\n'.

--
bringing you boring signatures for 17 years

That was to demonstrate it wouldn't expand it.
--
Replace spamtrap with bd to reply.
Your good nature will bring unbounded happiness.

in comp.unix.shell i read:

ahh, right.  that was one of the needs.  sorry.

--
bringing you boring signatures for 17 years

Quote:

> Why not:
> #include <stdio.h>
> int main(int argc, char *argv[]){
>         int i;
>         for(i = 1; i<argc;i++)
>                 printf("%s",argv[i]);
>         return 0;
> }

I'd considered that. (Actually, if I went that route,
I'd incorporate a few other simple string tasks into
it.) We'd have to pre-compile the utility and stash it
on our distribution disk, but we already do that for
another one, so it is feasible.

My main reasons for doing it in bourne shell are:
   1. It's more painful (well, OK, it's a growth
      experience and a learning exercise).
   2. Ease of maintenance (anyone with a text editor
      can muck around with it).
   3. It can easily interface with or be incorporated
      into our other scripts as needed. (One file to
      copy/include rather than a script plus one or
      more OS-dependant utilities.)

It's quite possible that I'll just rewrite the whole
thing in C eventually, but I've got to tell you, figuring
out the bourne shell tricks needed to make it work has
been fun. (Though "nailing jelly to a tree" describes
a large part of the process.) -Wm

So far cat does the trick. The first major test was passing
the filter script through itself then running the result.
Worked. (I was holding my breath.) Here's a sample function
that passes through it successfully (not pretty, but...):

PP_ParseFile ()
{
 if [ -f "$1" ] ; then
  PP_CURFILE="$1"
  PP_USEREND=0
  PP_LINECNT=0
  [ $PP_CFD -lt 8 ] || PP_ErrorExit "File descriptor allowance exceeded."
  PP_IncVar PP_CFD
  $PP_SED "$PP_NOSPACE"'s/\\/&&/g' "$1" > "$PP_TMPDIR/${1}.pptf.$PP_CFD"
  eval "exec $PP_CFD<'$PP_TMPDIR/${1}.pptf.$PP_CFD'"
  eval 'while IFS= read PP_RAW 0<&'"$PP_CFD"'
  do
   IFS="$PP_IFS"
   $PP_CNTLNS
   case "${PP_NOBLANKS}${PP_IFSKIP}${PP_KEEPCOMS}$PP_RAW" in
    1?? ) ;;
    0?? ) PP_PrintVal "$PP_RAW" "$PP_OUTFILE" ;;
    *\#* )
     set -- $PP_RAW
     case "${PP_IFSKIP}${PP_KEEPCOMS}$1" in
      ??\#[a-z]* ) PP_ParseLine "$1" "$PP_RAW" || break ;;
      00\#* )  ;;
      0?* ) PP_PrintVal "$PP_RAW" "$PP_OUTFILE" ;;
      * ) ;;
     esac
     ;;
    ?0* ) PP_PrintVal "$PP_RAW" "$PP_OUTFILE" ;;
   esac
  done'
  IFS="$PP_IFS"
  eval "exec $PP_CFD<&-"
  PP_DecVar PP_CFD
  [ "0$PP_USEREND" -eq 0 -a -n "$PP_IFSTK" ] && PP_ErrorExit "Missing
#endif"
  return 0
 fi
 return 1

Quote:}

BTW, the PP_PrintVal function contains the cat << EOS stuff.
-Wm

Just in case anyone else can use it, here's what I
finally came up with. I started with Robert's suggestion,
but needed a little additional processing, so I used sed
instead (bourne shell):

#----------------------------------------------------------------
# Prints the value without any interpretation. A destination file
# can be spcified, otherwise it goes to stdout. If the
# substitutions argument has sed-type patterns in it (s/xxx/yyy/),
# those are applied before the value is output.
PrintVal () # value [substitutions [destfile]]
{
    eval sed "${2:+-e '$2'}"' <<- EOV '"${3:+>>'$3'}"'
$1
EOV'

Quote:}

Note: The first line extends from eval to $3'}"', ignore any
spurious wrapping within it. The $1 and EOV are against the
left margin (though they can be indented with tabs if you
want thanks to the '-' in '<<-'). -Wm

[Correction:]

Quote:> PrintVal () # value [substitutions [destfile]]
> {
>     eval sed -n "${2:+-e '$2'} -e 'p' <<- EOV ${3:+>>'$3'}"'
> $1
> EOV'
> }

The previous version worked IF there was a substitution
string, but not otherwise - just didn't print anything. -Wm

Yet another tweak (it's a work in progress, what can I
say):

PrintVal () # value [substitutions [destfile]]
{
    eval sed -n "${2:+-e '$2'} -e 'p' <<- EOV ${3:+>>'$3'}"'
$1
EOV
' # <-- Put the closing quote on its own line

Quote:}

Without that change it worked on Solaris, but not
under cygwin's shell (and, presumably others). The
same problem occured with backticks. I assume it
has to do with the EOL being inside or outside the
quotes and some shells caring about it. -Wm