CSE2410 Fall 2014 Bounce

class UnicodeCache;

}

namespace preparser {

typedef uint8_t byte;

namespace i = v8::internal;

class DuplicateFinder {

 public:

  explicit DuplicateFinder(i::UnicodeCache* constants)

      : unicode_constants_(constants),

        backing_store_(16),

        map_(&Match) { }

  int AddAsciiSymbol(i::Vector<const char> key, int value);

  int AddUtf16Symbol(i::Vector<const uint16_t> key, int value);

  // Add a a number literal by converting it (if necessary)

  // to the string that ToString(ToNumber(literal)) would generate.

  // and then adding that string with AddAsciiSymbol.

  // This string is the actual value used as key in an object literal,

  // and the one that must be different from the other keys.

  int AddNumber(i::Vector<const char> key, int value);

 private:

  int AddSymbol(i::Vector<const byte> key, bool is_ascii, int value);

  // Backs up the key and its length in the backing store.

  // The backup is stored with a base 127 encoding of the

  // length (plus a bit saying whether the string is ASCII),

  // followed by the bytes of the key.

  byte* BackupKey(i::Vector<const byte> key, bool is_ascii);

  // Compare two encoded keys (both pointing into the backing store)

  // for having the same base-127 encoded lengths and ASCII-ness,

  // and then having the same 'length' bytes following.

  static bool Match(void* first, void* second);

  // Creates a hash from a sequence of bytes.

  static uint32_t Hash(i::Vector<const byte> key, bool is_ascii);

  // Checks whether a string containing a JS number is its canonical

  // form.

  static bool IsNumberCanonical(i::Vector<const char> key);

  // Size of buffer. Sufficient for using it to call DoubleToCString in

  // from conversions.h.

  static const int kBufferSize = 100;

  i::UnicodeCache* unicode_constants_;

  // Backing store used to store strings used as hashmap keys.

  i::SequenceCollector<unsigned char> backing_store_;

  i::HashMap map_;

  // Buffer used for string->number->canonical string conversions.

  char number_buffer_[kBufferSize];

};

class PreParser {

  PreParser(i::Scanner* scanner,

            i::ParserRecorder* log,

      : scanner_(scanner),

        stack_limit_(stack_limit),

        strict_mode_violation_location_(i::Scanner::Location::invalid()),

        stack_overflow_(false),

        allow_lazy_(false),

        allow_natives_syntax_(false),

        allow_generators_(false),

        allow_for_of_(false),

  bool allow_natives_syntax() const { return allow_natives_syntax_; }

  bool allow_lazy() const { return allow_lazy_; }

  bool allow_modules() const { return scanner_->HarmonyModules(); }

  bool allow_harmony_scoping() const { return scanner_->HarmonyScoping(); }

  bool allow_generators() const { return allow_generators_; }

  bool allow_for_of() const { return allow_for_of_; }

  bool allow_harmony_numeric_literals() const {

    return scanner_->HarmonyNumericLiterals();

  }

  void set_allow_natives_syntax(bool allow) { allow_natives_syntax_ = allow; }

  void set_allow_lazy(bool allow) { allow_lazy_ = allow; }

  void set_allow_modules(bool allow) { scanner_->SetHarmonyModules(allow); }

  void set_allow_harmony_scoping(bool allow) {

    scanner_->SetHarmonyScoping(allow);

  }

  void set_allow_generators(bool allow) { allow_generators_ = allow; }

  void set_allow_for_of(bool allow) { allow_for_of_ = allow; }

  void set_allow_harmony_numeric_literals(bool allow) {

    scanner_->SetHarmonyNumericLiterals(allow);

  }

    int start_position = scanner_->peek_location().beg_pos;

    ParseSourceElements(i::Token::EOS, &ok);

    if (stack_overflow_) return kPreParseStackOverflow;

      ReportUnexpectedToken(scanner_->current_token());

      CheckOctalLiteral(start_position, scanner_->location().end_pos, &ok);

  PreParseResult PreParseLazyFunction(i::LanguageMode mode,

                                      i::ParserRecorder* log);

  // Used to detect duplicates in object literals. Each of the values

  // kGetterProperty, kSetterProperty and kValueProperty represents

  // a type of object literal property. When parsing a property, its

  // type value is stored in the DuplicateFinder for the property name.

  // Values are chosen so that having intersection bits means the there is

  // an incompatibility.

  // I.e., you can add a getter to a property that already has a setter, since

  // kGetterProperty and kSetterProperty doesn't intersect, but not if it

  // already has a getter or a value. Adding the getter to an existing

  // setter will store the value (kGetterProperty | kSetterProperty), which

  // is incompatible with adding any further properties.

  enum PropertyType {

    kNone = 0,

    // Bit patterns representing different object literal property types.

    kGetterProperty = 1,

    kSetterProperty = 2,

    kValueProperty = 7,

    // Helper constants.

    kValueFlag = 4

  };

  // Checks the type of conflict based on values coming from PropertyType.

  bool HasConflict(int type1, int type2) { return (type1 & type2) != 0; }

  bool IsDataDataConflict(int type1, int type2) {

    return ((type1 & type2) & kValueFlag) != 0;

  }

  bool IsDataAccessorConflict(int type1, int type2) {

    return ((type1 ^ type2) & kValueFlag) != 0;

  }

  bool IsAccessorAccessorConflict(int type1, int type2) {

    return ((type1 | type2) & kValueFlag) == 0;

  }

  void CheckDuplicate(DuplicateFinder* finder,

                      i::Token::Value property,

                      int type,

                      bool* ok);

      return code_ != kUnknownStatement;

              (prev_ != NULL) ? prev_->language_mode() : i::CLASSIC_MODE),

      return language_mode_ == i::CLASSIC_MODE;

    i::LanguageMode language_mode() {

    void set_language_mode(i::LanguageMode language_mode) {

    i::LanguageMode language_mode_;

  void ReportUnexpectedToken(i::Token::Value token);

  void ReportMessageAt(i::Scanner::Location location,

  void CheckOctalLiteral(int beg_pos, int end_pos, bool* ok);

  i::Token::Value peek() {

    if (stack_overflow_) return i::Token::ILLEGAL;

    return scanner_->peek();

  }

  i::Token::Value Next() {

    if (stack_overflow_) return i::Token::ILLEGAL;

    {

      int marker;

      if (reinterpret_cast<uintptr_t>(&marker) < stack_limit_) {

        // Further calls to peek/Next will return illegal token.

        // The current one will still be returned. It might already

        // have been seen using peek.

        stack_overflow_ = true;

      }

    }

    return scanner_->Next();

  }

  bool peek_any_identifier();

  void set_language_mode(i::LanguageMode language_mode) {

    return scope_->language_mode() == i::CLASSIC_MODE;

    return scope_->language_mode() == i::EXTENDED_MODE;

  i::LanguageMode language_mode() { return scope_->language_mode(); }

  void Consume(i::Token::Value token) { Next(); }

  void Expect(i::Token::Value token, bool* ok) {

    if (Next() != token) {

      *ok = false;

    }

  }

  bool Check(i::Token::Value token) {

    i::Token::Value next = peek();

    if (next == token) {

      Consume(next);

      return true;

    }

    return false;

  }

  void ExpectSemicolon(bool* ok);

  static int Precedence(i::Token::Value tok, bool accept_IN);

  void SetStrictModeViolation(i::Scanner::Location,

  void StrictModeIdentifierViolation(i::Scanner::Location,

  i::Scanner* scanner_;

  i::ParserRecorder* log_;

  uintptr_t stack_limit_;

  i::Scanner::Location strict_mode_violation_location_;

  bool stack_overflow_;

  bool allow_lazy_;

  bool allow_natives_syntax_;

  bool allow_generators_;

  bool allow_for_of_;

} }  // v8::preparser