doio.c: Stop semop from modifying its argument

Perl_do_semop, which implements the Perl semop function, copies its
second argument to a new struct array, which it passes to the system’s
semop function.  It then copies the contents of the struct back into
the argument’s string buffer.

Neither the Darwin nor Linux documentation says that semop modifies
the structs passed to it, and, even if it did happen, perl has never
handle it correctly.  It would have to stringify its argument forcibly
(to avoid copying back into a temporary string buffer) and also call
get-magic.  And then it would fail with a read-only argument.

Since read-only arguments have always been permitted and the copy
ing-back has never worked correctly, and since this will cause prob-
lems if we upgrade modifications to COW buffers into crashes (the
PERL_DEBUG_READONLY_COW mode I am working in), this commit removes
that code.
cflags.SH - add commentary

Add comments to the top of cflags.SH to explain what it does.
Also make it output comments at the top of the generated cflags
script explaining that its auto-generated.
cflags/cflags.SH: use '#' comments

These scripts had a mixture of old-style ':' comments and new-style
'#' comments. Since they have both, the old ones can't be needed for
portability reasons, so standardise on the modern form.

The old-style were just too confusing, especially as my syntax highlighter
didn't know about them.
do cflags on stdout, not stderr

The current UNIX build system does a strange thing to generate the
appropriate command-line to compile a particular src file. It calls
the cflags shell script, which
1) echoes to stdout the command line needed to compile the specified
   file (excluding the name of the src file itself), e.g.
        cc -c -Dfoo -Wbar ...
2) echoes the same thing to stderr, prefixied with '	  CCCMD ='

Make then does

    `sh cflags foo.o`  foo.c

the cflags output to stdout is captured by the backticks, and is used
by make as the command line to run (with the foo.c appended). This run is
silent. The output to stderr isn't captured, and gets displayed. So the
user sees:

    $ make
    `sh cflags foo.o` foo.c
    	  CCCMD = cc -c -Dfoo -Wbar ...
    ...

This is annoying for 2 reasons:
1) you don't get a simple command-line displayed which you could do a
simple cut and paste with (e.g. when you want to recompile a specific
source file, but alter the flags).
2) The make generates output on stderr, even when then there aren't any
errors. So "make 2>errs" can't be used to quickly spot warnings and
errors.

This commit fixes this by making cflags just output the cc command and
flags to stdout, then get Makefile to call it twice, once to echo
the command-line (on stdout), and once to execute it with backticks.
So the make output is now:

    $ make
    cc -c -Dfoo -Wbar ... foo.c
    ...

There is some stuff in Makefile.SH related to cross-compiling, which this
commit make have broken. Specifically the CCCMD and CCCMDSRC macros
have been changed in the normal case to remove backticks (and add them to
the make rules instead), but not for the cross compilation route.
The CC* defs in the cross-compilation case have a trailing -I$(CROSS_LIB)
outside of the backticks, which compilates matters.

However, in the subdir Cross/, there appears to be separate (and
divergent) copies of Makefile.SH and cflags, so maybe the files
I edited are no longer used for cross-compilation????

(followup: according to
   <20131204170112.GA2490@iabyn.com>
the cross-compiling stuff I mentioned above has bit-rotted, and I don't
need to worry about it)
[perl #120426] atof() small value rounding errors

For something like 0.153e-305, which is small, but not quite the smallest
number (which is around 2.2e-308), adding extra digits to the fractional part
could cause unnecessary rounding to zero.

From the bug report:

    $ echo 0.1530e-305 | perl -e '$v = <STDIN>; print "v=", $v + 0, "\n";'
    v=0
    $ echo 0.153e-305  | perl -e '$v = <STDIN>; print "v=", $v + 0, "\n";'
    v=1.53e-306

This was because 0.1234e-305 is calculated as

    1234 / (10^309)

and 10^309 becomes infinity. In these edge cases, repeatedly decrement
the exponent and divide the mantissa by 10 until the exponent becomes in
range; in this case we instead calculate

    123 / (10^308)
Revert "[perl #119801] Stop @DB::dbline modifications from crashing"

This reverts commit c1cec775e9019cc8ae244d4db239a7ea5c0b343e.

See ticket #120864.