src/variables.h

   1 // Copyright 2006-2008 Google Inc. All Rights Reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #ifndef V8_VARIABLES_H_
  29 #define V8_VARIABLES_H_
  30
  31 #include "zone.h"
  32
  33 namespace v8 { namespace internal {
  34
  35 class UseCount BASE_EMBEDDED {
  36  public:
  37   UseCount();
  38
  39   // Inform the node of a "use". The weight can be used to indicate
  40   // heavier use, for instance if the variable is accessed inside a loop.
  41   void RecordRead(int weight);
  42   void RecordWrite(int weight);
  43   void RecordAccess(int weight);  // records a read & write
  44   void RecordUses(UseCount* uses);
  45
  46   int nreads() const  { return nreads_; }
  47   int nwrites() const  { return nwrites_; }
  48   int nuses() const  { return nreads_ + nwrites_; }
  49
  50   bool is_read() const  { return nreads() > 0; }
  51   bool is_written() const  { return nwrites() > 0; }
  52   bool is_used() const  { return nuses() > 0; }
  53
  54 #ifdef DEBUG
  55   void Print();
  56 #endif
  57
  58  private:
  59   int nreads_;
  60   int nwrites_;
  61 };
  62
  63
  64 // The AST refers to variables via VariableProxies - placeholders for the actual
  65 // variables. Variables themselves are never directly referred to from the AST,
  66 // they are maintained by scopes, and referred to from VariableProxies and Slots
  67 // after binding and variable allocation.
  68
  69 class Variable: public ZoneObject {
  70  public:
  71   enum Mode {
  72     // User declared variables:
  73     VAR,       // declared via 'var', and 'function' declarations
  74     CONST,     // declared via 'const' declarations
  75
  76     // Variables introduced by the compiler:
  77     DYNAMIC,   // always require dynamic lookup (we don't know the declaration)
  78     INTERNAL,  // like VAR, but not user-visible (may or may not be in a
  79                // context)
  80     TEMPORARY  // temporary variables (not user-visible), never in a context
  81   };
  82
  83   // Printing support
  84   static const char* Mode2String(Mode mode);
  85
  86   // Type testing & conversion
  87   Property* AsProperty();
  88   Variable* AsVariable();
  89   bool IsValidLeftHandSide() { return is_valid_LHS_; }
  90
  91   // The source code for an eval() call may refer to a variable that is
  92   // in an outer scope about which we don't know anything (it may not
  93   // be the global scope). scope() is NULL in that case. Currently the
  94   // scope is only used to follow the context chain length.
  95   Scope* scope() const  { return scope_; }
  96   // If this assertion fails it means that some code has tried to
  97   // treat the special this variable as an ordinary variable with
  98   // the name "this".
  99   Handle<String> name() const  { return name_; }
 100   Mode mode() const  { return mode_; }
 101   bool is_accessed_from_inner_scope() const  {
 102     return is_accessed_from_inner_scope_;
 103   }
 104   UseCount* var_uses()  { return &var_uses_; }
 105   UseCount* obj_uses()  { return &obj_uses_; }
 106
 107   bool IsVariable(Handle<String> n) {
 108     return !is_this() && name().is_identical_to(n);
 109   }
 110
 111   bool is_global() const;
 112   bool is_this() const { return is_this_; }
 113
 114   Expression* rewrite() const  { return rewrite_; }
 115   Slot* slot() const;
 116
 117  private:
 118   Variable(Scope* scope, Handle<String> name, Mode mode, bool is_valid_LHS,
 119       bool is_this);
 120
 121   Scope* scope_;
 122   Handle<String> name_;
 123   Mode mode_;
 124   bool is_valid_LHS_;
 125   bool is_this_;
 126
 127   // Usage info.
 128   bool is_accessed_from_inner_scope_;  // set by variable resolver
 129   UseCount var_uses_;  // uses of the variable value
 130   UseCount obj_uses_;  // uses of the object the variable points to
 131
 132   // Code generation.
 133   // rewrite_ is usually a Slot or a Property, but maybe any expression.
 134   Expression* rewrite_;
 135
 136   friend class VariableProxy;
 137   friend class Scope;
 138   friend class LocalsMap;
 139   friend class AstBuildingParser;
 140 };
 141
 142
 143 } }  // namespace v8::internal
 144
 145 #endif  // V8_VARIABLES_H_