Home | History | Annotate | Download | only in src 
      1 // Copyright 2011 the V8 project authors. 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 {
     34 namespace internal {
     35 
     36 // The AST refers to variables via VariableProxies - placeholders for the actual
     37 // variables. Variables themselves are never directly referred to from the AST,
     38 // they are maintained by scopes, and referred to from VariableProxies and Slots
     39 // after binding and variable allocation.
     40 
     41 class Variable: public ZoneObject {
     42  public:
     43   enum Mode {
     44     // User declared variables:
     45     VAR,       // declared via 'var', and 'function' declarations
     46 
     47     CONST,     // declared via 'const' declarations
     48 
     49     // Variables introduced by the compiler:
     50     DYNAMIC,         // always require dynamic lookup (we don't know
     51                      // the declaration)
     52 
     53     DYNAMIC_GLOBAL,  // requires dynamic lookup, but we know that the
     54                      // variable is global unless it has been shadowed
     55                      // by an eval-introduced variable
     56 
     57     DYNAMIC_LOCAL,   // requires dynamic lookup, but we know that the
     58                      // variable is local and where it is unless it
     59                      // has been shadowed by an eval-introduced
     60                      // variable
     61 
     62     INTERNAL,        // like VAR, but not user-visible (may or may not
     63                      // be in a context)
     64 
     65     TEMPORARY        // temporary variables (not user-visible), never
     66                      // in a context
     67   };
     68 
     69   enum Kind {
     70     NORMAL,
     71     THIS,
     72     ARGUMENTS
     73   };
     74 
     75   Variable(Scope* scope,
     76            Handle<String> name,
     77            Mode mode,
     78            bool is_valid_lhs,
     79            Kind kind);
     80 
     81   // Printing support
     82   static const char* Mode2String(Mode mode);
     83 
     84   // Type testing & conversion
     85   Property* AsProperty() const;
     86   Slot* AsSlot() const;
     87 
     88   bool IsValidLeftHandSide() { return is_valid_LHS_; }
     89 
     90   // The source code for an eval() call may refer to a variable that is
     91   // in an outer scope about which we don't know anything (it may not
     92   // be the global scope). scope() is NULL in that case. Currently the
     93   // scope is only used to follow the context chain length.
     94   Scope* scope() const { return scope_; }
     95 
     96   Handle<String> name() const { return name_; }
     97   Mode mode() const { return mode_; }
     98   bool is_accessed_from_inner_scope() const {
     99     return is_accessed_from_inner_scope_;
    100   }
    101   void MarkAsAccessedFromInnerScope() {
    102     is_accessed_from_inner_scope_ = true;
    103   }
    104   bool is_used() { return is_used_; }
    105   void set_is_used(bool flag) { is_used_ = flag; }
    106 
    107   bool IsVariable(Handle<String> n) const {
    108     return !is_this() && name().is_identical_to(n);
    109   }
    110 
    111   bool IsStackAllocated() const;
    112   bool IsParameter() const;  // Includes 'this'.
    113   bool IsStackLocal() const;
    114   bool IsContextSlot() const;
    115 
    116   bool is_dynamic() const {
    117     return (mode_ == DYNAMIC ||
    118             mode_ == DYNAMIC_GLOBAL ||
    119             mode_ == DYNAMIC_LOCAL);
    120   }
    121 
    122   bool is_global() const;
    123   bool is_this() const { return kind_ == THIS; }
    124   bool is_arguments() const { return kind_ == ARGUMENTS; }
    125 
    126   // True if the variable is named eval and not known to be shadowed.
    127   bool is_possibly_eval() const {
    128     return IsVariable(FACTORY->eval_symbol()) &&
    129         (mode_ == DYNAMIC || mode_ == DYNAMIC_GLOBAL);
    130   }
    131 
    132   Variable* local_if_not_shadowed() const {
    133     ASSERT(mode_ == DYNAMIC_LOCAL && local_if_not_shadowed_ != NULL);
    134     return local_if_not_shadowed_;
    135   }
    136 
    137   void set_local_if_not_shadowed(Variable* local) {
    138     local_if_not_shadowed_ = local;
    139   }
    140 
    141   Expression* rewrite() const { return rewrite_; }
    142   void set_rewrite(Expression* expr) { rewrite_ = expr; }
    143 
    144  private:
    145   Scope* scope_;
    146   Handle<String> name_;
    147   Mode mode_;
    148   Kind kind_;
    149 
    150   Variable* local_if_not_shadowed_;
    151 
    152   // Code generation.
    153   // rewrite_ is usually a Slot or a Property, but may be any expression.
    154   Expression* rewrite_;
    155 
    156   // Valid as a LHS? (const and this are not valid LHS, for example)
    157   bool is_valid_LHS_;
    158 
    159   // Usage info.
    160   bool is_accessed_from_inner_scope_;  // set by variable resolver
    161   bool is_used_;
    162 };
    163 
    164 
    165 } }  // namespace v8::internal
    166 
    167 #endif  // V8_VARIABLES_H_
    168