<?php

/**

 * @file

 * Functions that need to be loaded on every Drupal request.

 */

/**

 * The current system version.

 */

define('VERSION', '7.56');

/**

 * Core API compatibility.

 */

define('DRUPAL_CORE_COMPATIBILITY', '7.x');

/**

 * Minimum supported version of PHP.

 */

define('DRUPAL_MINIMUM_PHP', '5.2.4');

/**

 * Minimum recommended value of PHP memory_limit.

 */

define('DRUPAL_MINIMUM_PHP_MEMORY_LIMIT', '32M');

/**

 * Error reporting level: display no errors.

 */

define('ERROR_REPORTING_HIDE', 0);

/**

 * Error reporting level: display errors and warnings.

 */

define('ERROR_REPORTING_DISPLAY_SOME', 1);

/**

 * Error reporting level: display all messages.

 */

define('ERROR_REPORTING_DISPLAY_ALL', 2);

/**

 * Indicates that the item should never be removed unless explicitly selected.

 *

 * The item may be removed using cache_clear_all() with a cache ID.

 */

define('CACHE_PERMANENT', 0);

/**

 * Indicates that the item should be removed at the next general cache wipe.

 */

define('CACHE_TEMPORARY', -1);

/**

 * @defgroup logging_severity_levels Logging severity levels

 * @{

 * Logging severity levels as defined in RFC 3164.

 *

 * The WATCHDOG_* constant definitions correspond to the logging severity levels

 * defined in RFC 3164, section 4.1.1. PHP supplies predefined LOG_* constants

 * for use in the syslog() function, but their values on Windows builds do not

 * correspond to RFC 3164. The associated PHP bug report was closed with the

 * comment, "And it's also not a bug, as Windows just have less log levels,"

 * and "So the behavior you're seeing is perfectly normal."

 *

 * @see http://www.faqs.org/rfcs/rfc3164.html

 * @see http://bugs.php.net/bug.php?id=18090

 * @see http://php.net/manual/function.syslog.php

 * @see http://php.net/manual/network.constants.php

 * @see watchdog()

 * @see watchdog_severity_levels()

 */

/**

 * Log message severity -- Emergency: system is unusable.

 */

define('WATCHDOG_EMERGENCY', 0);

/**

 * Log message severity -- Alert: action must be taken immediately.

 */

define('WATCHDOG_ALERT', 1);

/**

 * Log message severity -- Critical conditions.

 */

define('WATCHDOG_CRITICAL', 2);

/**

 * Log message severity -- Error conditions.

 */

define('WATCHDOG_ERROR', 3);

/**

 * Log message severity -- Warning conditions.

 */

define('WATCHDOG_WARNING', 4);

/**

 * Log message severity -- Normal but significant conditions.

 */

define('WATCHDOG_NOTICE', 5);

/**

 * Log message severity -- Informational messages.

 */

define('WATCHDOG_INFO', 6);

/**

 * Log message severity -- Debug-level messages.

 */

define('WATCHDOG_DEBUG', 7);

/**

 * @} End of "defgroup logging_severity_levels".

 */

/**

 * First bootstrap phase: initialize configuration.

 */

define('DRUPAL_BOOTSTRAP_CONFIGURATION', 0);

/**

 * Second bootstrap phase: try to serve a cached page.

 */

define('DRUPAL_BOOTSTRAP_PAGE_CACHE', 1);

/**

 * Third bootstrap phase: initialize database layer.

 */

define('DRUPAL_BOOTSTRAP_DATABASE', 2);

/**

 * Fourth bootstrap phase: initialize the variable system.

 */

define('DRUPAL_BOOTSTRAP_VARIABLES', 3);

/**

 * Fifth bootstrap phase: initialize session handling.

 */

define('DRUPAL_BOOTSTRAP_SESSION', 4);

/**

 * Sixth bootstrap phase: set up the page header.

 */

define('DRUPAL_BOOTSTRAP_PAGE_HEADER', 5);

/**

 * Seventh bootstrap phase: find out language of the page.

 */

define('DRUPAL_BOOTSTRAP_LANGUAGE', 6);

/**

 * Final bootstrap phase: Drupal is fully loaded; validate and fix input data.

 */

define('DRUPAL_BOOTSTRAP_FULL', 7);

/**

 * Role ID for anonymous users; should match what's in the "role" table.

 */

define('DRUPAL_ANONYMOUS_RID', 1);

/**

 * Role ID for authenticated users; should match what's in the "role" table.

 */

define('DRUPAL_AUTHENTICATED_RID', 2);

/**

 * The number of bytes in a kilobyte.

 *

 * For more information, visit http://en.wikipedia.org/wiki/Kilobyte.

 */

define('DRUPAL_KILOBYTE', 1024);

/**

 * The language code used when no language is explicitly assigned.

 *

 * Defined by ISO639-2 for "Undetermined".

 */

define('LANGUAGE_NONE', 'und');

/**

 * The type of language used to define the content language.

 */

define('LANGUAGE_TYPE_CONTENT', 'language_content');

/**

 * The type of language used to select the user interface.

 */

define('LANGUAGE_TYPE_INTERFACE', 'language');

/**

 * The type of language used for URLs.

 */

define('LANGUAGE_TYPE_URL', 'language_url');

/**

 * Language written left to right. Possible value of $language->direction.

 */

define('LANGUAGE_LTR', 0);

/**

 * Language written right to left. Possible value of $language->direction.

 */

define('LANGUAGE_RTL', 1);

/**

 * Time of the current request in seconds elapsed since the Unix Epoch.

 *

 * This differs from $_SERVER['REQUEST_TIME'], which is stored as a float

 * since PHP 5.4.0. Float timestamps confuse most PHP functions

 * (including date_create()).

 *

 * @see http://php.net/manual/reserved.variables.server.php

 * @see http://php.net/manual/function.time.php

 */

define('REQUEST_TIME', (int) $_SERVER['REQUEST_TIME']);

/**

 * Flag used to indicate that text is not sanitized, so run check_plain().

 *

 * @see drupal_set_title()

 */

define('CHECK_PLAIN', 0);

/**

 * Flag used to indicate that text has already been sanitized.

 *

 * @see drupal_set_title()

 */

define('PASS_THROUGH', -1);

/**

 * Signals that the registry lookup cache should be reset.

 */

define('REGISTRY_RESET_LOOKUP_CACHE', 1);

/**

 * Signals that the registry lookup cache should be written to storage.

 */

define('REGISTRY_WRITE_LOOKUP_CACHE', 2);

/**

 * Regular expression to match PHP function names.

 *

 * @see http://php.net/manual/language.functions.php

 */

define('DRUPAL_PHP_FUNCTION_PATTERN', '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*');

/**

 * A RFC7231 Compliant date.

 *

 * http://tools.ietf.org/html/rfc7231#section-7.1.1.1

 *

 * Example: Sun, 06 Nov 1994 08:49:37 GMT

 *

 * This constant was introduced in PHP 7.0.19 and PHP 7.1.5 but needs to be

 * defined by Drupal for earlier PHP versions.

 */

if (!defined('DATE_RFC7231')) {

  define('DATE_RFC7231', 'D, d M Y H:i:s \G\M\T');

}

/**

 * Provides a caching wrapper to be used in place of large array structures.

 *

 * This class should be extended by systems that need to cache large amounts

 * of data and have it represented as an array to calling functions. These

 * arrays can become very large, so ArrayAccess is used to allow different

 * strategies to be used for caching internally (lazy loading, building caches

 * over time etc.). This can dramatically reduce the amount of data that needs

 * to be loaded from cache backends on each request, and memory usage from

 * static caches of that same data.

 *

 * Note that array_* functions do not work with ArrayAccess. Systems using

 * DrupalCacheArray should use this only internally. If providing API functions

 * that return the full array, this can be cached separately or returned

 * directly. However since DrupalCacheArray holds partial content by design, it

 * should be a normal PHP array or otherwise contain the full structure.

 *

 * Note also that due to limitations in PHP prior to 5.3.4, it is impossible to

 * write directly to the contents of nested arrays contained in this object.

 * Only writes to the top-level array elements are possible. So if you

 * previously had set $object['foo'] = array(1, 2, 'bar' => 'baz'), but later

 * want to change the value of 'bar' from 'baz' to 'foobar', you cannot do so

 * a targeted write like $object['foo']['bar'] = 'foobar'. Instead, you must

 * overwrite the entire top-level 'foo' array with the entire set of new

 * values: $object['foo'] = array(1, 2, 'bar' => 'foobar'). Due to this same

 * limitation, attempts to create references to any contained data, nested or

 * otherwise, will fail silently. So $var = &$object['foo'] will not throw an

 * error, and $var will be populated with the contents of $object['foo'], but

 * that data will be passed by value, not reference. For more information on

 * the PHP limitation, see the note in the official PHP documentation at·

 * http://php.net/manual/arrayaccess.offsetget.php on

 * ArrayAccess::offsetGet().

 *

 * By default, the class accounts for caches where calling functions might

 * request keys in the array that won't exist even after a cache rebuild. This

 * prevents situations where a cache rebuild would be triggered over and over

 * due to a 'missing' item. These cases are stored internally as a value of

 * NULL. This means that the offsetGet() and offsetExists() methods

 * must be overridden if caching an array where the top level values can

 * legitimately be NULL, and where $object->offsetExists() needs to correctly

 * return (equivalent to array_key_exists() vs. isset()). This should not

 * be necessary in the majority of cases.

 *

 * Classes extending this class must override at least the

 * resolveCacheMiss() method to have a working implementation.

 *

 * offsetSet() is not overridden by this class by default. In practice this

 * means that assigning an offset via arrayAccess will only apply while the

 * object is in scope and will not be written back to the persistent cache.

 * This follows a similar pattern to static vs. persistent caching in

 * procedural code. Extending classes may wish to alter this behavior, for

 * example by overriding offsetSet() and adding an automatic call to persist().

 *

 * @see SchemaCache

 */

abstract class DrupalCacheArray implements ArrayAccess {

  /**

   * A cid to pass to cache_set() and cache_get().

   */

  protected $cid;

  /**

   * A bin to pass to cache_set() and cache_get().

   */

  protected $bin;

  /**

   * An array of keys to add to the cache at the end of the request.

   */

  protected $keysToPersist = array();

  /**

   * Storage for the data itself.

   */

  protected $storage = array();

  /**

   * Constructs a DrupalCacheArray object.

   *

   * @param $cid

   *   The cid for the array being cached.

   * @param $bin

   *   The bin to cache the array.

   */

  public function __construct($cid, $bin) {

    $this->cid = $cid;

    $this->bin = $bin;

    if ($cached = cache_get($this->cid, $this->bin)) {

     $this->storage = $cached->data;

    }

  }

  /**

   * Implements ArrayAccess::offsetExists().

   */

  public function offsetExists($offset) {

    return $this->offsetGet($offset) !== NULL;

  }

  /**

   * Implements ArrayAccess::offsetGet().

   */

  public function offsetGet($offset) {

    if (isset($this->storage[$offset]) || array_key_exists($offset, $this->storage)) {

      return $this->storage[$offset];

    }

    else {

      return $this->resolveCacheMiss($offset);

    }

  }

  /**

   * Implements ArrayAccess::offsetSet().

   */

  public function offsetSet($offset, $value) {

    $this->storage[$offset] = $value;

  }

  /**

   * Implements ArrayAccess::offsetUnset().

   */

  public function offsetUnset($offset) {

    unset($this->storage[$offset]);

  }

  /**

   * Flags an offset value to be written to the persistent cache.

   *

   * If a value is assigned to a cache object with offsetSet(), by default it

   * will not be written to the persistent cache unless it is flagged with this

   * method. This allows items to be cached for the duration of a request,

   * without necessarily writing back to the persistent cache at the end.

   *

   * @param $offset

   *   The array offset that was requested.

   * @param $persist

   *   Optional boolean to specify whether the offset should be persisted or

   *   not, defaults to TRUE. When called with $persist = FALSE the offset will

   *   be unflagged so that it will not be written at the end of the request.

   */

  protected function persist($offset, $persist = TRUE) {

    $this->keysToPersist[$offset] = $persist;

  }

  /**

   * Resolves a cache miss.

   *

   * When an offset is not found in the object, this is treated as a cache

   * miss. This method allows classes implementing the interface to look up

   * the actual value and allow it to be cached.

   *

   * @param $offset

   *   The offset that was requested.

   *

   * @return

   *   The value of the offset, or NULL if no value was found.

   */

  abstract protected function resolveCacheMiss($offset);

  /**

   * Writes a value to the persistent cache immediately.

   *

   * @param $data

   *   The data to write to the persistent cache.

   * @param $lock

   *   Whether to acquire a lock before writing to cache.

   */

  protected function set($data, $lock = TRUE) {

    // Lock cache writes to help avoid stampedes.

    // To implement locking for cache misses, override __construct().

    $lock_name = $this->cid . ':' . $this->bin;

    if (!$lock || lock_acquire($lock_name)) {

      if ($cached = cache_get($this->cid, $this->bin)) {

        $data = $cached->data + $data;

      }

      cache_set($this->cid, $data, $this->bin);

      if ($lock) {

        lock_release($lock_name);

      }

    }

  }

  /**

   * Destructs the DrupalCacheArray object.

   */

  public function __destruct() {

    $data = array();

    foreach ($this->keysToPersist as $offset => $persist) {

      if ($persist) {

        $data[$offset] = $this->storage[$offset];

      }

    }

    if (!empty($data)) {

      $this->set($data);

    }

  }

}

/**

 * Starts the timer with the specified name.

 *

 * If you start and stop the same timer multiple times, the measured intervals

 * will be accumulated.

 *

 * @param $name

 *   The name of the timer.

 */

function timer_start($name) {

  global $timers;

  $timers[$name]['start'] = microtime(TRUE);

  $timers[$name]['count'] = isset($timers[$name]['count']) ? ++$timers[$name]['count'] : 1;

}

/**

 * Reads the current timer value without stopping the timer.

 *

 * @param $name

 *   The name of the timer.

 *

 * @return

 *   The current timer value in ms.

 */

function timer_read($name) {

  global $timers;

  if (isset($timers[$name]['start'])) {

    $stop = microtime(TRUE);

    $diff = round(($stop - $timers[$name]['start']) * 1000, 2);

    if (isset($timers[$name]['time'])) {

      $diff += $timers[$name]['time'];

    }

    return $diff;

  }

  return $timers[$name]['time'];

}

/**

 * Stops the timer with the specified name.

 *

 * @param $name

 *   The name of the timer.

 *

 * @return

 *   A timer array. The array contains the number of times the timer has been

 *   started and stopped (count) and the accumulated timer value in ms (time).

 */

function timer_stop($name) {

  global $timers;

  if (isset($timers[$name]['start'])) {

    $stop = microtime(TRUE);

    $diff = round(($stop - $timers[$name]['start']) * 1000, 2);

    if (isset($timers[$name]['time'])) {

      $timers[$name]['time'] += $diff;

    }

    else {

      $timers[$name]['time'] = $diff;

    }

    unset($timers[$name]['start']);

  }