The 'new' syntax for literal strings had these two bugs.

1) Unterminated strings were not correctly handled, resulting in out
   of bounds reads. Note: cpp_error does not throw, it simply prints
   an error message.
2) Newlines inside literal strings did not increment the current
   line number, which resulted in incorrect information in e.g. error
   messages.

They will all start and end a literal string.

A literal string can contain any characters except the end sequence.

The main usecase is writing code in a string.

As an example:

string test = #{
This is a literal string.
They can contain any characters, no de-quoting is done at all.

So, as an example, foo "bar" 'gazonk' \

Valid quote sequences are #{, #( and #[.
They are ended by # followed by }, ) and ], respectively.

So, you can use the two other quotes inside the string, if you want to, like:

Also, no preprocessing is done inside the string.

The main usecase for these strings is to write code in code.

Especially in error handling, and code that does a lot of other string
operations anyway the speed gain is not wort the 100+ bytes code size
of each instance of push_constant_text

This saves about 20K of code size (main pike binary), while not really
changing the speed much.

push_constant_text that seemed to be in at least pseudo-time-critical
code was kept as they were.

On a related note, push_constant_text(":") four times in a row creates
four different string variables, for obvious reasons.

Some of the remaining push_constant_text really should have a
module/file local string variable, even though that is more bothersome
to create.

It might be nice to have this in .cmod files automatically.

Shaves of about 50% of the remaining code size.  Now down to about
50Kb, which seems more reasonable than 200k.

There is still a lot of code duplication, though, like the places that
insert the current file as a #line, the code that handles quoted
newlines etc.

But it is better.

I also removed macros that were only used once and inlined them.

I also fixed five errors that hopefully did not really matter all that
much in calc(*):

o Two instances of data[1] instead of data[pos+1]
o Three instances of data[pos]+1 instead of data[pos+1]

The first error would be triggered if you used '/' in an #if and the
second character of the current cpp work area was '/'.

The second one is probably harmless. Or not, it was in the code for
'&' and '|': basically the detection of && and || there was broken.

However, I think that would be handled by the calling order of the
calc* functions.

Anyway, cpp.o is now less than 100k, about 45% of its original size
(OSX 64-bit).

Also made all the constant strings used for comparison 8bit.

This saves about 20% binary size in cpp.o (soon down below 100k from
200k), although the large functions (calc*+lower_cpp) have not been
rewritten yet.

Changed all the macros to functions.

There are still one copy per shift level, but at least this
removed a third or so of the binary size.

Most builtin stuff should now be documented.

down on compiler warnings. The macro also renames parameters to catch accidental use.
(There are more places to clean up but I don't want to modify code that isn't compiling
on my machine.)