hphp/compiler/option.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-2014 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_OPTION_H_
  18 #define incl_HPHP_OPTION_H_
  19
  20 #include "hphp/util/hdf.h"
  21 #include <map>
  22 #include <set>
  23 #include <vector>
  24 #include "hphp/util/string-bag.h"
  25 #include "hphp/util/deprecated/base.h"
  26 #include "hphp/util/deprecated/declare-boost-types.h"
  27
  28 namespace HPHP {
  29 ///////////////////////////////////////////////////////////////////////////////
  30 DECLARE_BOOST_TYPES(BlockScope);
  31 DECLARE_BOOST_TYPES(FileScope);
  32
  33 class Option {
  34 public:
  35
  36   /**
  37    * Load options from different sources.
  38    */
  39   static void Load(Hdf &config);
  40   static void Load(); // load default options
  41
  42   /**
  43    * Directories to add to a package.
  44    */
  45   static std::string RootDirectory;
  46   static std::set<std::string> PackageDirectories;
  47
  48   /**
  49    * Files to add to a package.
  50    */
  51   static std::set<std::string> PackageFiles;
  52
  53   /**
  54    * File path patterns for excluding files from a package scan of programs.
  55    */
  56   static std::set<std::string> PackageExcludeDirs;
  57   static std::set<std::string> PackageExcludeFiles;
  58   static std::set<std::string> PackageExcludePatterns;
  59   static std::set<std::string> PackageExcludeStaticFiles;
  60   static std::set<std::string> PackageExcludeStaticDirs;
  61   static std::set<std::string> PackageExcludeStaticPatterns;
  62
  63   static bool IsFileExcluded(const std::string &file,
  64                              const std::set<std::string> &patterns);
  65   static void FilterFiles(std::vector<std::string> &files,
  66                           const std::set<std::string> &patterns);
  67
  68   /**
  69    * Directories in which files are parsed on-demand, when parse-on-demand
  70    * is off.
  71    */
  72   static std::vector<std::string> ParseOnDemandDirs;
  73
  74   /**
  75    * Whether to store PHP source files in static file cache.
  76    */
  77   static bool CachePHPFile;
  78
  79   /**
  80    * Legal root directory expressions in an include expression. For example,
  81    *
  82    *   include_once $PHP_ROOT . '/lib.php';
  83    *
  84    * Here, "$PHP_ROOT" is a legal include root. Stores what it resolves to.
  85    *
  86    *   Option::IncludeRoots["$PHP_ROOT"] = "";
  87    *   Option::IncludeRoots["$LIB_ROOT"] = "lib";
  88    */
  89   static std::map<std::string, std::string> IncludeRoots;
  90   static std::map<std::string, std::string> AutoloadRoots;
  91   static std::vector<std::string> IncludeSearchPaths;
  92
  93   /**
  94    * PHP include root expression to use when generating PHP trimmed code.
  95    */
  96   static std::string DefaultIncludeRoot;
  97
  98   /**
  99    * PHP functions that will take a function name and make a dynamic call.
 100    */
 101   static std::map<std::string, int> DynamicFunctionCalls;
 102
 103   /**
 104    * Optimization flags
 105    */
 106   static bool PreOptimization;
 107   static bool PostOptimization;
 108   static bool AnalyzePerfectVirtuals;
 109   static bool HardTypeHints;
 110
 111   /*
 112    * Flags that only affect HHBBC right now.  See hhbbc/hhbbc.h for
 113    * description.
 114    */
 115   static bool HardConstProp;
 116
 117   /**
 118    * Separate compilation
 119    */
 120   static bool SeparateCompilation;
 121   static bool SeparateCompLib;
 122
 123   /**
 124    * CodeGenerator options for PHP.
 125    */
 126   static bool GeneratePickledPHP;
 127   static bool GenerateInlinedPHP;
 128   static bool GenerateTrimmedPHP;
 129   static bool GenerateInferredTypes;  // comments on constant/variable tables
 130   static bool ConvertSuperGlobals;    // $GLOBALS['var'] => global $var
 131   static bool ConvertQOpExpressions;  // $var = $exp ? $yes : $no => if-else
 132   static std::string ProgramPrologue;
 133   static std::string TrimmedPrologue;
 134   static std::vector<std::string> DynamicFunctionPrefixes;
 135   static std::vector<std::string> DynamicFunctionPostfixes;
 136   static std::vector<std::string> DynamicMethodPrefixes;
 137   static std::vector<std::string> DynamicMethodPostfixes;
 138   static std::vector<std::string> DynamicClassPrefixes;
 139   static std::vector<std::string> DynamicClassPostfixes;
 140   static std::set<std::string, stdltistr> DynamicInvokeFunctions;
 141   static std::set<std::string> VolatileClasses;
 142   static std::map<std::string,std::string> AutoloadClassMap;
 143   static std::map<std::string,std::string> AutoloadFuncMap;
 144   static std::map<std::string,std::string> AutoloadConstMap;
 145   static std::string AutoloadRoot;
 146
 147   /**
 148    * CodeGenerator options for HHBC.
 149    */
 150   static bool GenerateTextHHBC;
 151   static bool GenerateBinaryHHBC;
 152   static std::string RepoCentralPath;
 153   static bool RepoDebugInfo;
 154
 155   /**
 156    * Names of hot and cold functions to be marked in sources.
 157    */
 158   static std::map<std::string, std::string> FunctionSections;
 159
 160   /**
 161    * A somewhat unique prefix for system identifiers.
 162    */
 163   static std::string IdPrefix;
 164   static std::string LambdaPrefix;
 165   static std::string Tab;
 166
 167   /**
 168    * Name resolution helpers.
 169    */
 170   static const char *UserFilePrefix;
 171
 172   /**
 173    * Turn it off for cleaner unit tests.
 174    */
 175   static bool KeepStatementsWithNoEffect;
 176
 177   /**
 178    * When we have an include inside a function or a method, how many levels
 179    * do we expand? If 0, we rely on "require" vs. "include" to give explicit
 180    * instructions. If 1, we only inline just one level, and all deeper
 181    * includes are considered as libraries, and they will be moved to top
 182    * level. If -1, we completely disable conditional include handling.
 183    */
 184   static int ConditionalIncludeExpandLevel;
 185
 186   /**
 187    * Maximum number of examplar programs to store in each output.
 188    */
 189   static int DependencyMaxProgram;
 190   static int CodeErrorMaxProgram;
 191
 192   /**
 193    * Whether or not name matches dynamic function/class prefx/postfix lists.
 194    */
 195   static bool IsDynamicFunction(bool method, const std::string &name);
 196   static bool IsDynamicClass(const std::string &name);
 197
 198   /**
 199    * Whether or not name matches AUTOLOAD files. If not, returns empty. If
 200    * yes, returns root directory for the file.
 201    */
 202   static std::string GetAutoloadRoot(const std::string &name);
 203
 204   /**
 205    * Turning a file name into an identifier. When id is false, preserve
 206    * "/" in file paths.
 207    */
 208   static std::string MangleFilename(const std::string &name, bool id);
 209
 210   enum EvalLevel {
 211     NoEval = 0, // calling eval is a fatal
 212     LimitedEval = 1, // eval is supported in a limited way with no perf hit
 213     FullEval = 2 // eval is supported but with a performance hit
 214   };
 215
 216   static EvalLevel EnableEval;
 217
 218   static std::string ProgramName;
 219
 220   static bool ParseTimeOpts;
 221   static bool OutputHHBC;
 222   static bool EnableHipHopSyntax;
 223   static bool EnableZendCompat;
 224   static bool JitEnableRenameFunction;
 225   static bool EnableHipHopExperimentalSyntax;
 226   static bool EnableShortTags;
 227   static bool EnableAspTags;
 228   static bool EnableXHP;
 229   static bool IntsOverflowToInts;
 230   static int ParserThreadCount;
 231
 232   static int GetScannerType();
 233
 234   /**
 235    * "Dynamic" means a function or a method can be invoked dynamically.
 236    * "Volatile" means a class or a function can be declared dynamically.
 237    */
 238   static bool AllDynamic;
 239   static bool AllVolatile;
 240
 241   /**
 242    * Optimizations
 243    */
 244   static int InvokeFewArgsCount;
 245   static int InlineFunctionThreshold;
 246   static bool EliminateDeadCode;
 247   static bool CopyProp;
 248   static bool LocalCopyProp;
 249   static bool StringLoopOpts;
 250   static int AutoInline;
 251   static bool ArrayAccessIdempotent;
 252
 253   /**
 254    * Output options
 255    */
 256   static bool GenerateDocComments;
 257   static bool ControlFlow;
 258   static bool VariableCoalescing;
 259   static bool DumpAst;
 260   static bool WholeProgram;
 261   static bool UseHHBBC;  // see hhbbc/README
 262   static bool RecordErrors;
 263   static std::string DocJson; // filename to dump doc JSON to
 264
 265   static bool (*PersistenceHook)(BlockScopeRawPtr scope, FileScopeRawPtr fs);
 266 private:
 267   static StringBag OptionStrings;
 268
 269   static void LoadRootHdf(const Hdf &roots, std::map<std::string,
 270                           std::string> &map);
 271   static void LoadRootHdf(const Hdf &roots, std::vector<std::string> &vec);
 272   static void OnLoad();
 273
 274   static bool IsDynamic(const std::string &name,
 275                         const std::vector<std::string> &prefixes,
 276                         const std::vector<std::string> &postfixes);
 277 };
 278
 279 //////////////////////////////////////////////////////////////////////
 280
 281 /*
 282  * Hook called after Option is set up to propagate various options to
 283  * HHBBC's option structure.
 284  *
 285  * This exists this way because we don't want to have libhhbbc depend
 286  * on all of libhphp_analysis---the dependency goes the other way.
 287  */
 288 void initialize_hhbbc_options();
 289
 290 ///////////////////////////////////////////////////////////////////////////////
 291 }
 292 #endif // incl_HPHP_OPTION_H_