Fix uninitialized members

src/scopes.h

 // Copyright 2006-2008 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 75 matching lines @@
  public:
   // ---------------------------------------------------------------------------
   // Construction
 
   enum Type {
     EVAL_SCOPE,     // the top-level scope for an 'eval' source
     FUNCTION_SCOPE,  // the top-level scope for a function
     GLOBAL_SCOPE    // the top-level scope for a program or a top-level eval
   };
 
-  Scope();
   Scope(Scope* outer_scope, Type type);
 
   virtual ~Scope() { }
 
   // The scope name is only used for printing/debugging.
   void SetScopeName(Handle<String> scope_name)  { scope_name_ = scope_name; }
 
   void Initialize(bool inside_with);
 
 
@@ skipping 16 matching lines @@
   // declared before, the previously declared variable is returned.
   virtual Variable* DeclareLocal(Handle<String> name, Variable::Mode mode);
 
   // Declare an implicit global variable in this scope which must be a
   // global scope.  The variable was introduced (possibly from an inner
   // scope) by a reference to an unresolved variable with no intervening
   // with statements or eval calls.
   Variable* DeclareGlobal(Handle<String> name);
 
   // Add a parameter to the parameter list. The parameter must have been
-  // declared via Declare. The same parameter may occur more then once in
+  // declared via Declare. The same parameter may occur more than once in
   // the parameter list; they must be added in source order, from left to
   // right.
   void AddParameter(Variable* var);
 
   // Create a new unresolved variable.
   virtual VariableProxy* NewUnresolved(Handle<String> name, bool inside_with);
 
   // Remove a unresolved variable. During parsing, an unresolved variable
   // may have been added optimistically, but then only the variable name
   // was used (typically for labels). If the variable was not declared, the
@@ skipping 135 matching lines @@
 
 #ifdef DEBUG
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  protected:
   friend class ParserFactory;
 
+  explicit Scope(Type type);
+
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   ZoneList<Scope*> inner_scopes_;  // the immediately enclosed inner scopes
 
   // The scope type.
   Type type_;
 
   // Debugging support.
   Handle<String> scope_name_;
 
@@ skipping 69 matching lines @@
   void AllocateHeapSlot(Variable* var);
   void AllocateParameterLocals();
   void AllocateNonParameterLocal(Variable* var);
   void AllocateNonParameterLocals();
   void AllocateVariablesRecursively();
 };
 
 
 class DummyScope : public Scope {
  public:
-  DummyScope() {
+   DummyScope() : Scope(GLOBAL_SCOPE) {
     outer_scope_ = this;
   }
 
   virtual Variable* Lookup(Handle<String> name)  { return NULL; }
   virtual Variable* Declare(Handle<String> name, Variable::Mode mode) {
     return NULL;
   }
   virtual VariableProxy* NewUnresolved(Handle<String> name, bool inside_with) {
     return NULL;
   }
   virtual VariableProxy* NewTemporary(Handle<String> name)  { return NULL; }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_