Experimental scanner: keeping track of octal numbers octal escapes.

src/lexer/experimental-scanner.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 49 matching lines @@
     int beg_pos;
     int end_pos;
   };
 
   explicit ScannerBase(Isolate* isolate)
     : isolate_(isolate),
       unicode_cache_(isolate->unicode_cache()),
       has_line_terminator_before_next_(true),
       current_literal_(&literals_[0]),
       next_literal_(&literals_[1]),
-      octal_pos_(Location::invalid()),
       harmony_numeric_literals_(false),
       harmony_modules_(false),
       harmony_scoping_(false) {
     if (!scanners_) {
       scanners_ = new std::set<ScannerBase*>();
       isolate->heap()->AddGCEpilogueCallback(&ScannerBase::UpdateBuffersAfterGC,
                                              kGCTypeAll, false);
     }
     scanners_->insert(this);
   }
@@ skipping 129 matching lines @@
     return next_literal_->is_ascii;
   }
 
   bool is_next_contextual_keyword(Vector<const char> keyword) {
     if (!is_next_literal_ascii()) return false;
     Vector<const char> literal = next_literal_ascii_string();
     return literal.length() == keyword.length() &&
         (memcmp(literal.start(), keyword.start(), literal.length()) == 0);
   }
 
-  // Returns the location of the last seen octal literal.
-  Location octal_position() const { return octal_pos_; }
-  void clear_octal_position() { octal_pos_ = Location::invalid(); }
-
   // Seek forward to the given position. This operation works for simple cases
   // such as seeking forward until simple delimiter tokens, which is what it is
   // used for. After this call, we will have the token at the given position as
   // the "next" token. The "current" token will be invalid. FIXME: for utf-8,
   // we need to decide if pos is counted in characters or in bytes.
   virtual void SeekForward(int pos) = 0;
   virtual void SetEnd(int pos) = 0;
 
   // Scans the input as a regular expression pattern, previous character(s) must
   // be /(=). Returns true if a pattern is scanned. FIXME: this won't work for
   // utf-8 newlines.
   virtual bool ScanRegExpPattern(bool seen_equal) = 0;
   // Returns true if regexp flags are scanned (always since flags can
   // be empty).
   virtual bool ScanRegExpFlags() = 0;
 
+  // Returns the location of the last seen octal literal.
+  virtual Location octal_position() const = 0;
+  virtual void clear_octal_position() = 0;
+
  protected:
   struct TokenDesc {
     Token::Value token;
     int beg_pos;
     int end_pos;
     bool has_escapes;
   };
 
   struct LiteralDesc {
     int beg_pos;
@@ skipping 16 matching lines @@
 
   bool has_line_terminator_before_next_;
 
   TokenDesc current_;  // desc for current token (as returned by Next())
   TokenDesc next_;     // desc for next token (one token look-ahead)
 
   LiteralDesc* current_literal_;
   LiteralDesc* next_literal_;
   LiteralDesc literals_[2];
 
-  Location octal_pos_;
-
   bool harmony_numeric_literals_;
   bool harmony_modules_;
   bool harmony_scoping_;
 
  private:
   static std::set<ScannerBase*>* scanners_;
 };
 
 
 template<typename Char>
 class ExperimentalScanner : public ScannerBase {
  public:
   explicit ExperimentalScanner(
       Handle<String> source,
       Isolate* isolate)
       : ScannerBase(isolate),
         source_handle_(source),
         buffer_(NULL),
         buffer_end_(NULL),
         start_(NULL),
         cursor_(NULL),
-        marker_(NULL) {
+        marker_(NULL),
+        last_octal_end_(NULL) {
     ASSERT(source->IsFlat());
     SetBufferBasedOnHandle();
     Scan();
   }
 
   virtual ~ExperimentalScanner() { }
 
- protected:
-  virtual void Scan();
   virtual void SeekForward(int pos);
   virtual void SetEnd(int pos);
   virtual bool ScanRegExpPattern(bool seen_equal);
   virtual bool ScanRegExpFlags();
+  virtual Location octal_position() const;
+  virtual void clear_octal_position() {
+    last_octal_end_ = NULL;
+  }
+
+ protected:
+  virtual void Scan();
 
   virtual void SetBufferBasedOnHandle() {
     // We get a raw pointer from the Handle, but we also update it every time
     // there is a GC, so it is safe.
     DisallowHeapAllocation no_gc;
     const Char* new_buffer = GetNewBufferBasedOnHandle();
     if (new_buffer != buffer_) {
       int start_offset = start_ - buffer_;
       int cursor_offset = cursor_ - buffer_;
       int marker_offset = marker_ - buffer_;
@@ skipping 33 matching lines @@
   const Char* ScanEscape(const Char* start,
                          const Char* end,
                          LiteralBuffer* literal);
 
   Handle<String> source_handle_;
   const Char* buffer_;
   const Char* buffer_end_;
   const Char* start_;
   const Char* cursor_;
   const Char* marker_;
+
+  // Where we have seen the last octal number or an octal escape inside a
+  // string. Used by octal_position().
+  const Char* last_octal_end_;
 };
 
 
 template<typename Char>
 void ExperimentalScanner<Char>::SeekForward(int pos) {
   cursor_ = buffer_ + pos;
   start_ = cursor_;
   marker_ = cursor_;
   has_line_terminator_before_next_ = false;
   Scan();  // Fills in next_.
@@ skipping 105 matching lines @@
     const Char* start, const Char* end, uc32* result) {
   uc32 x = *result - '0';
   const Char* cursor;
   for (cursor = start; cursor < end; cursor++) {
     int d = *cursor - '0';
     if (d < 0 || d > 7) break;
     int nx = x * 8 + d;
     if (nx >= 256) break;
     x = nx;
   }
-  // Anything except '\0' is an octal escape sequence, illegal in strict mode.
-  // Remember the position of octal escape sequences so that an error
-  // can be reported later (in strict mode).
-  // We don't report the error immediately, because the octal escape can
-  // occur before the "use strict" directive.
-  if (*result != '0' || cursor > start) {
-    octal_pos_ = Location(start - 1 - buffer_, cursor - 1 - buffer_);
-  }
   *result = x;
   return cursor;
 }
 
 
 template<typename Char>
 bool ExperimentalScanner<Char>::ScanLiteralUnicodeEscape() {
   ASSERT(cursor_ < buffer_end_);
   Char primary_char = *(cursor_);
   ASSERT(primary_char == '\\');
@@ skipping 77 matching lines @@
       cursor = ScanOctalEscape(cursor, end, &c); break;
   }
 
   // According to ECMA-262, section 7.8.4, characters not covered by the
   // above cases should be illegal, but they are commonly handled as
   // non-escaped characters by JS VMs.
   literal->AddChar(c);
   return cursor;
 }
 
+template<typename Char>
+ScannerBase::Location ExperimentalScanner<Char>::octal_position() const {
+  if (!last_octal_end_)
+    return Location::invalid();
+  // The last octal might be an octal escape or an octal number. Whichever it
+  // is, we'll find the start by just scanning back until we hit a non-octal
+  // character.
+  const Char* temp_cursor = last_octal_end_ - 1;
+  while (temp_cursor >= buffer_ && *temp_cursor >= '0' && *temp_cursor <= '7')
+    --temp_cursor;
+  return Location(temp_cursor - buffer_ + 1, last_octal_end_ - buffer_);
+}
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H