Strict mode octal literals.

src/scanner-base.cc

 // Copyright 2010 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 80 matching lines @@
     Advance();
   }
 
   return x;
 }
 
 
 // Octal escapes of the forms '\0xx' and '\xxx' are not a part of
 // ECMA-262. Other JS VMs support them.
 uc32 Scanner::ScanOctalEscape(uc32 c, int length) {
+  octal_loc_.beg_pos = source_pos() - 1;    // Already advanced

[Lasse Reichstein, 2011/01/21 11:20:20]

It seems like overkill to store both beg and end pos for an octal literal.
Just store the beginning (and initialize it to -1 until the first one is found,
that will be outside the range of all source code).

[Martin Maly, 2011/01/21 23:32:57]

Done.

   uc32 x = c - '0';
   for (int i = 0; i < length; i++) {
     int d = c0_ - '0';
     if (d < 0 || d > 7) break;
     int nx = x * 8 + d;
     if (nx >= 256) break;
     x = nx;
     Advance();
   }
+  octal_loc_.end_pos = source_pos();
   return x;
 }
 
 
 // ----------------------------------------------------------------------------
 // JavaScriptScanner
 
 JavaScriptScanner::JavaScriptScanner() : Scanner() {}
 
 
@@ skipping 470 matching lines @@
           // we must have at least one hex digit after 'x'/'X'
           return Token::ILLEGAL;
         }
         while (IsHexDigit(c0_)) {
           AddLiteralCharAdvance();
         }
       } else if ('0' <= c0_ && c0_ <= '7') {
         // (possible) octal number
         kind = OCTAL;
         while (true) {
+          // TODO(mmaly): Do we want to keep the auto-upgrade to decimal?

[Lasse Reichstein, 2011/01/21 11:20:20]

Alas, yes.
Unless it turns out that Safari has changed on that too.
It's only octal escapes that are disallowed as grammar extensions, not decimal
escapes. 

[Martin Maly, 2011/01/21 23:32:57]

Done.

           if (c0_ == '8' || c0_ == '9') {
             kind = DECIMAL;
             break;
           }
-          if (c0_  < '0' || '7'  < c0_) break;
+          if (c0_  < '0' || '7'  < c0_) {
+            // Octal literal finished.
+            octal_loc_.beg_pos = next_.location.beg_pos;
+            octal_loc_.end_pos = source_pos();
+            break;
+          }
           AddLiteralCharAdvance();
         }
       }
     }
 
     // Parse decimal digits and allow trailing fractional part.
     if (kind == DECIMAL) {
       ScanDecimalDigits();  // optional
       if (c0_ == '.') {
         AddLiteralCharAdvance();
@@ skipping 109 matching lines @@
 
   // Scan regular expression body: According to ECMA-262, 3rd, 7.8.5,
   // the scanner should pass uninterpreted bodies to the RegExp
   // constructor.
   LiteralScope literal(this);
   if (seen_equal)
     AddLiteralChar('=');
 
   while (c0_ != '/' || in_character_class) {
     if (ScannerConstants::kIsLineTerminator.get(c0_) || c0_ < 0) return false;
     if (c0_ == '\\') {  // Escape sequence.

[Lasse Reichstein, 2011/01/21 11:20:20]

We should also add checking of RegExp literals. They may also contain octal
escapes. It is not as simple as checking whether the next character after '\' is
'0'. The sequence '\12' may be the octal escape for newline, or it may be a
backreference to capture 12, or a backreference to capture 1 followed by a "2".
We really need to do a full parse of the regexp to know.
I don't remember off-hand whether we parse the regexp eagerly for syntax errors,
or if we delay it until it's first executed. If the latter, then we probably
need to do it earlier for strict code.

[MarkM, 2011/01/21 17:44:49]

ES5.1 Chapter 16 Errors states:

  An implementation must treat any instance of the following kinds of errors as
an early error: [...]
  • Errors in regular expression literals that are not implementation-defined
syntax extensions

This is not conditional on strict mode.

[Martin Maly, 2011/01/21 23:32:57]

I saw the octal parsing code. I propose to do this in another patch ... trying
to keep them small. let me know if you prefer I add it to this one though.

[Lasse Reichstein, 2011/01/24 07:59:37]

Even so, we currently don't catch the syntax error until the RegExp literal is
evaluated. If we change this to an early syntax error, we again risk the chance
of breaking existing pages (it is an incompatible change from ES3 to ES5 to
*require* early errors here).

As a side note, our preparser means that we completely skip parsing of some
functions until they are first called. That means that to catch errors early,
the preparser must catch all early errors, since it's the only code to see the
source in time. Since it doesn't build an AST or record most of its tokens,
there are a number of early errors it can't catch in its current form.

In either case, keeping RegExp validation in a separate patch is the right thing
to do.

       AddLiteralCharAdvance();
       if (ScannerConstants::kIsLineTerminator.get(c0_) || c0_ < 0) return false;
       AddLiteralCharAdvance();
       // If the escape allows more characters, i.e., \x??, \u????, or \c?,
       // only "safe" characters are allowed (letters, digits, underscore),
       // otherwise the escape isn't valid and the invalid character has
       // its normal meaning. I.e., we can just continue scanning without
       // worrying whether the following characters are part of the escape
       // or not, since any '/', '\\' or '[' is guaranteed to not be part
       // of the escape sequence.
@@ skipping 156 matching lines @@
       if (MatchKeywordStart(input, "with", 1, Token::WITH)) return;
       break;
     case UNMATCHABLE:
       break;
   }
   // On fallthrough, it's a failure.
   state_ = UNMATCHABLE;
 }
 
 } }  // namespace v8::internal