Allow numeric literals to be checked for a decimal point.

src/scanner.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #include <stdint.h>
 
 #include <cmath>
 
@@ skipping 1415 matching lines @@
 
 double Scanner::DoubleValue() {
   DCHECK(is_literal_one_byte());
   return StringToDouble(
       unicode_cache_,
       literal_one_byte_string(),
       ALLOW_HEX | ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY);
 }
 
 
+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);
   }
   return finder->AddTwoByteSymbol(literal_two_byte_string(), value);
 }
 
 
 bool Scanner::SetBookmark() {
   if (c0_ != kNoBookmark && bookmark_c0_ == kNoBookmark &&
@@ skipping 179 matching lines @@
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 }  // namespace internal
 }  // namespace v8