hphp/runtime/base/request-injection-data-inl.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_REQUEST_INJECTION_DATA_INL_H_
  18 #error "Can only be included by request-injection-data.h"
  19 #endif
  20
  21 namespace HPHP {
  22 ////////////////////////////////////////////////////////////////////////////////
  23
  24 inline int RequestInjectionData::getTimeout() const {
  25   return m_timer.m_timeoutSeconds;
  26 }
  27
  28 inline int RequestInjectionData::getCPUTimeout() const {
  29   return m_cpuTimer.m_timeoutSeconds;
  30 }
  31
  32 inline bool RequestInjectionData::getJit() const {
  33   return m_jit;
  34 }
  35
  36 inline bool RequestInjectionData::isJittingDisabled() const {
  37   return m_jittingDisabled;
  38 }
  39
  40 inline void RequestInjectionData::setJittingDisabled(bool flag) {
  41   m_jittingDisabled = flag;
  42 }
  43
  44 inline bool RequestInjectionData::getJitFolding() const {
  45   return m_jitFolding;
  46 }
  47
  48 inline void RequestInjectionData::setJitFolding(bool flag) {
  49   m_jitFolding = flag;
  50 }
  51
  52 inline bool RequestInjectionData::getSuppressHackArrayCompatNotices() const {
  53   return m_suppressHackArrayCompatNotices;
  54 }
  55
  56 inline void RequestInjectionData::setSuppressHackArrayCompatNotices(bool flag) {
  57   m_suppressHackArrayCompatNotices = flag;
  58 }
  59
  60 inline bool RequestInjectionData::getCoverage() const {
  61   return m_coverage;
  62 }
  63
  64 inline void RequestInjectionData::setCoverage(bool flag) {
  65   m_coverage = flag;
  66   updateJit();
  67 }
  68
  69 inline bool RequestInjectionData::getDebuggerAttached() {
  70   return m_debuggerAttached;
  71 }
  72
  73 inline void RequestInjectionData::setDebuggerAttached(bool flag) {
  74   m_debuggerAttached = flag;
  75   updateJit();
  76 }
  77
  78 inline size_t RequestInjectionData::getDebuggerStackDepth() const {
  79   return m_activeLineBreaks.size();
  80 }
  81
  82 inline bool RequestInjectionData::getDebuggerForceIntr() const {
  83   return
  84     m_debuggerIntr ||
  85     // Force interrupts when over an active line.
  86     getActiveLineBreak() != -1 ||
  87     // Interrupts forced while stepping in.
  88     m_debuggerStepIn ||
  89     // Step out forces interrupts after we have exited the function.
  90     m_debuggerStepOut == StepOutState::Out;
  91 }
  92
  93 inline bool RequestInjectionData::getDebuggerIntr() const {
  94   return m_debuggerIntr;
  95 }
  96
  97 inline void RequestInjectionData::setDebuggerIntr(bool flag) {
  98   m_debuggerIntr = flag;
  99   updateJit();
 100 }
 101
 102 inline bool RequestInjectionData::getDebuggerStepIn() const {
 103   return m_debuggerStepIn;
 104 }
 105
 106 inline void RequestInjectionData::setDebuggerStepIn(bool flag) {
 107   m_debuggerStepIn = flag;
 108   updateJit();
 109 }
 110
 111 inline RequestInjectionData::StepOutState
 112 RequestInjectionData::getDebuggerStepOut() const {
 113   return m_debuggerStepOut;
 114 }
 115
 116 inline void RequestInjectionData::setDebuggerStepOut(StepOutState state) {
 117   m_debuggerStepOut = state;
 118   updateJit();
 119 }
 120
 121 inline bool RequestInjectionData::getDebuggerNext() const {
 122   return m_debuggerNext;
 123 }
 124
 125 inline void RequestInjectionData::setDebuggerNext(bool flag) {
 126   m_debuggerNext = flag;
 127   updateJit();
 128 }
 129
 130 inline int RequestInjectionData::getDebuggerFlowDepth() const {
 131   return m_debuggerFlowDepth;
 132 }
 133
 134 inline void RequestInjectionData::setDebuggerFlowDepth(int depth) {
 135   m_debuggerFlowDepth = depth;
 136 }
 137
 138 inline int RequestInjectionData::getActiveLineBreak() const {
 139   return m_activeLineBreaks.empty() ? -1 : m_activeLineBreaks.top();
 140 }
 141
 142 inline void RequestInjectionData::clearActiveLineBreak() {
 143   if (m_activeLineBreaks.empty()) return;
 144   m_activeLineBreaks.top() = -1;
 145   updateJit();
 146 }
 147
 148 inline void RequestInjectionData::setActiveLineBreak(int line) {
 149   assertx(line != -1);
 150   if (m_activeLineBreaks.empty()) return;
 151   m_activeLineBreaks.top() = line;
 152   updateJit();
 153 }
 154
 155 inline void RequestInjectionData::popActiveLineBreak() {
 156   if (m_activeLineBreaks.empty()) return;
 157   m_activeLineBreaks.pop();
 158   updateJit();
 159 }
 160
 161 inline void RequestInjectionData::pushActiveLineBreak() {
 162   m_activeLineBreaks.push(-1);
 163   updateJit();
 164 }
 165
 166 inline const std::vector<std::string>&
 167 RequestInjectionData::getIncludePaths() const {
 168   return m_include_paths;
 169 }
 170
 171 inline const std::string& RequestInjectionData::getDefaultMimeType() const {
 172   return m_defaultMimeType;
 173 }
 174
 175 inline int64_t RequestInjectionData::getErrorReportingLevel() {
 176   return m_errorReportingLevel;
 177 }
 178
 179 inline void RequestInjectionData::setErrorReportingLevel(int64_t level) {
 180   m_errorReportingLevel = level;
 181 }
 182
 183 inline int64_t RequestInjectionData::getMemoryLimitNumeric() const {
 184   return m_maxMemoryNumeric;
 185 }
 186
 187 inline const std::string& RequestInjectionData::getVariablesOrder() const {
 188   return m_variablesOrder;
 189 }
 190
 191 inline void RequestInjectionData::setVariablesOrder(const std::string& order) {
 192   m_variablesOrder = order;
 193 }
 194
 195 inline const std::string& RequestInjectionData::getRequestOrder() const {
 196   return m_requestOrder;
 197 }
 198
 199 inline void RequestInjectionData::setRequestOrder(const std::string& order) {
 200   m_requestOrder = order;
 201 }
 202
 203 inline int64_t RequestInjectionData::getSocketDefaultTimeout() const {
 204   return m_socketDefaultTimeout;
 205 }
 206
 207 inline const std::string& RequestInjectionData::getUserAgent() const {
 208   return m_userAgent;
 209 }
 210
 211 inline void RequestInjectionData::setUserAgent(const std::string& agent) {
 212   m_userAgent = agent;
 213 }
 214
 215 inline const std::string& RequestInjectionData::getTimeZone() const {
 216   return m_timezone;
 217 }
 218
 219 inline void RequestInjectionData::setTimeZone(const std::string& tz) {
 220   m_timezone = tz;
 221 }
 222
 223 inline void RequestInjectionData::setSafeFileAccess(bool b) {
 224   m_safeFileAccess = b;
 225 }
 226
 227 inline bool RequestInjectionData::hasSafeFileAccess() const {
 228   return m_safeFileAccess;
 229 }
 230
 231 inline bool RequestInjectionData::hasTrackErrors() const {
 232   return m_trackErrors;
 233 }
 234
 235 inline bool RequestInjectionData::hasHtmlErrors() const {
 236   return m_htmlErrors;
 237 }
 238
 239 inline bool RequestInjectionData::logFunctionCalls() const {
 240   return m_logFunctionCalls;
 241 }
 242 ////////////////////////////////////////////////////////////////////////////////
 243 }