Allow numeric literals to be checked for a decimal point.

src/scanner.cc

Index: src/scanner.cc
diff --git a/src/scanner.cc b/src/scanner.cc
index a2ca30a9be5df0b08eede51835eb506ff78752a1..55a3ab181ad01eb12a8c697d4da24d1bcd90444a 100644
--- a/src/scanner.cc
+++ b/src/scanner.cc
@@ -1433,6 +1433,17 @@ double Scanner::DoubleValue() {
 }
 
 
+bool Scanner::ContainsDot() {

[Sven Panne, 2015/06/22 07:53:43]

Instead of using caveman-style loops, the right way to implement this is to make
Scanner/LiteralBuffer obey the iterator protocol. With that, everything is more
flexible and ContainsDot would be a one-liner with std::find, so it's probably
not even worth having as a separate function.

[bradn, 2015/06/23 06:54:07]

Turns out Vector<> provides begin/end, which allow some greater brevity.

LiteralBuffer manages providing subranges (in multiple byte sizes), which it
returns as Vector<>.

I suppose it could provide these via two separate methods, but these in turn
would have to be carried through two layers of wrapper out to Scanner. (The
convience methods in Scanner are presumably due to the number of uses, i.e.
many).

Having this as a method allows the DCHECK (which judging by the underlying
implementation seems to be allowed to be null under some circumstances?)
It might be worth incorporating into DoubleValue(), but see below.

+  DCHECK(is_literal_one_byte());
+  Vector<const uint8_t> literal_string = literal_one_byte_string();

[titzer, 2015/06/22 07:08:16]

Does this make a copy of the bytes underneath?

[bradn, 2015/06/23 06:54:07]

No, it copies a reference to the underying buffer and size (And is a weak
reference in contrast to ScopedVector).

When I'd asked about leaning on the compiler though, what I'd meant was how
frugal about copies of Vector<>? (The other functions here, DoubleValue for
instance seem to assume instantiating a Vector<> (costing 2 pointers, times 2
layers of return), is an acceptable cost, presumably hoping for optimization.)

DoubleValue() is only used twice, once needing to know about dots, the other
not. So I could add a bool* with_dot parameter to it, but that struck me as odd.

Trying to calibrate my micro-optimization instincts for this code base. Sorry
coming from NaCl core, which is filled with C code (for instance, we're
literally having a should we allow any C++ in corner X of the codebase
discussion next week :-).

+  bool with_dot = false;
+  for (int i = 0; !with_dot && i < literal_string.length(); ++i) {
+    with_dot |= (literal_string[i] == '.');

[titzer, 2015/06/22 07:08:16]

Early return?

[bradn, 2015/06/23 06:54:07]

Replaced.
FWIW was lifted wholesale from a prototype CL Andreas pointed me at :-)

+  }
+  return with_dot;
+}
+
+
 int Scanner::FindSymbol(DuplicateFinder* finder, int value) {
   if (is_literal_one_byte()) {
     return finder->AddOneByteSymbol(literal_one_byte_string(), value);