hphp/compiler/analysis/variable_table.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #ifndef incl_HPHP_VARIABLE_TABLE_H_
  18 #define incl_HPHP_VARIABLE_TABLE_H_
  19
  20 #include "hphp/compiler/analysis/symbol_table.h"
  21 #include <map>
  22 #include <set>
  23 #include <vector>
  24 #include "hphp/compiler/statement/statement.h"
  25 #include "hphp/compiler/analysis/class_scope.h"
  26 #include "hphp/util/hash-map-typedefs.h"
  27
  28 namespace HPHP {
  29 ///////////////////////////////////////////////////////////////////////////////
  30
  31 DECLARE_BOOST_TYPES(ModifierExpression);
  32 DECLARE_BOOST_TYPES(CodeError);
  33 DECLARE_BOOST_TYPES(VariableTable);
  34 DECLARE_BOOST_TYPES(Expression);
  35 DECLARE_BOOST_TYPES(ClassScope);
  36 DECLARE_BOOST_TYPES(FunctionScope);
  37
  38 /**
  39  * These are the only places that a new variable can be declared:
  40  *
  41  *   variable = expr|variable|new obj(...)
  42  *   static_var_list: T_STATIC T_VARIABLE = static_scalar,...
  43  *   class_variable_declaration: class { T_VARIABLE = static_scalar,...}
  44  *   T_LIST (variable, T_LIST(...), ...) = ...
  45  *   try {...} catch (T obj) {...}
  46  *   extract(name_value_pair)
  47  */
  48 struct VariableTable : SymbolTable {
  49   friend struct AssignmentExpression;
  50 public:
  51   enum Attribute {
  52     ContainsDynamicVariable = 1,
  53     ContainsLDynamicVariable = ContainsDynamicVariable | 2,
  54     InsideStaticStatement = 16,
  55     InsideGlobalStatement = 32,
  56     ForceGlobal = 64,
  57     ContainsUnset = 128,
  58     ContainsDynamicStatic  = 512,
  59   };
  60
  61   enum AlteredVarClass {
  62     NonPrivateNonStaticVars = 1,
  63     NonPrivateStaticVars = 2,
  64     PrivateNonStaticVars = 4,
  65     PrivateStaticVars = 8,
  66
  67     AnyNonStaticVars = NonPrivateNonStaticVars | PrivateNonStaticVars,
  68     AnyStaticVars = NonPrivateStaticVars | PrivateStaticVars,
  69     AnyNonPrivateVars = NonPrivateNonStaticVars | NonPrivateStaticVars,
  70     AnyPrivateVars = PrivateNonStaticVars | PrivateStaticVars,
  71
  72     AnyVars = AnyStaticVars | AnyNonStaticVars
  73   };
  74
  75   static int GetVarClassMask(bool privates, bool statics) {
  76     return (statics ? 2 : 1) << (privates ? 2 : 0);
  77   }
  78
  79   static int GetVarClassMaskForSym(const Symbol *sym) {
  80     return GetVarClassMask(sym->isPrivate(), sym->isStatic());
  81   }
  82
  83 public:
  84   explicit VariableTable(BlockScope &blockScope);
  85
  86   /**
  87    * Get/set attributes.
  88    */
  89   void setAttribute(Attribute attr) { m_attribute |= attr;}
  90   void clearAttribute(Attribute attr) { m_attribute &= ~attr;}
  91   bool getAttribute(Attribute attr) const {
  92     return (m_attribute & attr) == attr;
  93   }
  94
  95   bool isParameter(const std::string &name) const;
  96   bool isPublic(const std::string &name) const;
  97   bool isProtected(const std::string &name) const;
  98   bool isPrivate(const std::string &name) const;
  99   bool isStatic(const std::string &name) const;
 100   bool isGlobal(const std::string &name) const;
 101   bool isSuperGlobal(const std::string &name) const;
 102   bool isLocal(const std::string &name) const;
 103   bool isLocal(const Symbol *sym) const;
 104   bool isRedeclared(const std::string &name) const;
 105   bool isLocalGlobal(const std::string &name) const;
 106   bool isNestedStatic(const std::string &name) const;
 107   bool isLvalParam(const std::string &name) const;
 108   bool isUsed(const std::string &name) const;
 109   bool isNeeded(const std::string &name) const;
 110
 111   bool isPseudoMainTable() const;
 112   bool hasPrivate() const;
 113   bool hasNonStaticPrivate() const;
 114   bool hasStatic() const { return m_hasStatic; }
 115
 116   virtual bool isInherited(const std::string &name) const;
 117
 118   void getLocalVariableNames(std::vector<std::string> &syms) const;
 119
 120   /**
 121    * Get all variable's names.
 122    */
 123   void getNames(std::set<std::string> &names,
 124                 bool collectPrivate = true) const;
 125
 126   Symbol *addSymbol(const std::string &name) {
 127     return genSymbol(name, false);
 128   }
 129
 130   Symbol *addDeclaredSymbol(const std::string &name, ConstructPtr construct) {
 131     return genSymbol(name, false, construct);
 132   }
 133
 134   /**
 135    * Add a function's parameter to this table.
 136    */
 137   void addParam(const std::string &name,
 138                 AnalysisResultConstPtr ar, ConstructPtr construct);
 139
 140   void addParamLike(const std::string &name,
 141                     AnalysisResultPtr ar, ConstructPtr construct,
 142                     bool firstPass);
 143
 144   /**
 145    * Called when a variable is declared or being assigned (l-value).
 146    */
 147   void add(const std::string &name, bool implicit,
 148            AnalysisResultConstPtr ar, ConstructPtr construct,
 149            ModifierExpressionPtr modifiers);
 150   void add(Symbol *sym, bool implicit,
 151            AnalysisResultConstPtr ar, ConstructPtr construct,
 152            ModifierExpressionPtr modifiers);
 153
 154   /**
 155    * Called to note whether a class variable overrides
 156    * a definition in a base class. Returns whether or not there
 157    * was an error in marking as override.
 158    */
 159   bool markOverride(AnalysisResultPtr ar, const std::string &name);
 160
 161   /**
 162    * Called when a variable is used or being evaluated (r-value).
 163    */
 164   void checkVariable(const std::string &name,
 165                      AnalysisResultConstPtr ar, ConstructPtr construct);
 166   void checkVariable(Symbol *sym,
 167                      AnalysisResultConstPtr ar, ConstructPtr construct);
 168   /**
 169    * Find the class which contains the property, and return
 170    * its Symbol
 171    */
 172   Symbol *findProperty(ClassScopePtr &cls,
 173                        const std::string &name,
 174                        AnalysisResultConstPtr ar);
 175
 176   /**
 177    * Walk up to find first parent that has the specified symbol.
 178    */
 179   ClassScopePtr findParent(AnalysisResultConstPtr ar,
 180                            const std::string &name,
 181                            const Symbol *&sym) const;
 182
 183   ClassScopePtr findParent(AnalysisResultConstPtr ar,
 184                            const std::string &name,
 185                            Symbol *&sym) {
 186     const Symbol *ss;
 187     ClassScopePtr p = findParent(ar, name, ss); // const version
 188     sym = const_cast<Symbol*>(ss);
 189     return p;
 190   }
 191
 192   /**
 193    * Called when analyze global and static statement.
 194    */
 195   bool checkRedeclared(const std::string &name, Statement::KindOf kindOf);
 196   void addLocalGlobal(const std::string &name);
 197   void addNestedStatic(const std::string &name);
 198
 199   /**
 200    * Helper for static variable default value
 201    */
 202   ConstructPtr getStaticInitVal(std::string varName);
 203   bool setStaticInitVal(std::string varName, ConstructPtr value);
 204
 205   /**
 206    * Helper for class variable default value
 207    */
 208   ConstructPtr getClassInitVal(std::string varName);
 209   bool setClassInitVal(std::string varName, ConstructPtr value);
 210
 211   /**
 212    * Called when analyze simple variable
 213    */
 214   void addLvalParam(const std::string &name);
 215   void addUsed(const std::string &name);
 216   bool checkUnused(Symbol *sym);
 217   void addNeeded(const std::string &name);
 218   void clearUsed();
 219   void addStaticVariable(Symbol *sym, AnalysisResultConstPtr ar,
 220                          bool member = false);
 221   void addStaticVariable(Symbol *sym, AnalysisResultPtr ar,
 222                          bool member = false);
 223   void cleanupForError(AnalysisResultConstPtr ar);
 224
 225   /**
 226    * Keep track of $GLOBALS['var'].
 227    */
 228   void addSuperGlobal(const std::string &name);
 229   bool isConvertibleSuperGlobal(const std::string &name) const;
 230
 231   /**
 232    * Generate all variable declarations for this symbol table.
 233    */
 234   void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);
 235
 236 private:
 237   enum StaticSelection {
 238     NonStatic = 1,
 239     Static = 2,
 240     EitherStatic = 3
 241   };
 242
 243   enum PrivateSelection {
 244     NonPrivate = 1,
 245     Private = 2,
 246     EitherPrivate = 3
 247   };
 248
 249   int m_attribute;
 250   int m_nextParam;
 251   unsigned m_hasGlobal : 1;
 252   unsigned m_hasStatic : 1;
 253   unsigned m_hasPrivate : 1;
 254   unsigned m_hasNonStaticPrivate : 1;
 255   unsigned m_forcedVariants : 4;
 256
 257   bool isGlobalTable(AnalysisResultConstPtr ar) const;
 258 };
 259
 260 ///////////////////////////////////////////////////////////////////////////////
 261 }
 262
 263 #endif // incl_HPHP_VARIABLE_TABLE_H_