Club Drupal

Drupal 7.52, 2016-11-16

-----------------------

- Fixed security issues (multiple vulnerabilities). See SA-CORE-2016-005.

Drupal 7.51, 2016-10-05

-----------------------

- The Update module now also checks for updates to a disabled theme that is

  used as an admin theme.

- Exceptions thrown in dblog_watchdog() are now caught and ignored.

- Clarified the warning that appears when modules are missing or have moved.

- Log messages are now XSS filtered on display.

- Draggable tables now work on touch screen devices.

- Added a setting for allowing double underscores in CSS identifiers

  (https://www.drupal.org/node/2810369).

- If a user navigates away from a page while an Ajax request is running they

  will no longer get an error message saying "An Ajax HTTP request terminated

  abnormally".

- The system_region_list() API function now takes an optional third parameter

  which allows region name translations to be skipped when they are not needed

  (API addition: https://www.drupal.org/node/2810365).

- Numerous performance improvements.

- Numerous bug fixes.

- Numerous API documentation improvements.

- Additional automated test coverage.

Drupal 7.50, 2016-07-07 

-----------------------

- Added a new "administer fields" permission for trusted users, which is

  required in addition to other permissions to use the field UI

  (https://www.drupal.org/node/2483307).

- Added clickjacking protection to Drupal core by setting the X-Frame-Options

  header to SAMEORIGIN by default (https://www.drupal.org/node/2735873).

- Added support for full UTF-8 (emojis, Asian symbols, mathematical symbols) on

  MySQL and other database drivers when the site and database are configured to

  allow it (https://www.drupal.org/node/2761183).

- Improved performance by avoiding a re-scan of directories when a file is

  missing; instead, trigger a PHP warning (minor API change:

  https://www.drupal.org/node/2581445).

- Made it possible to use any PHP callable in Ajax form callbacks, form API

  form-building functions, and form API wrapper callbacks (API addition:

  https://www.drupal.org/node/2761169).

- Fixed that following a password reset link while logged in leaves users unable

  to change their password (minor user interface change:

  https://www.drupal.org/node/2759023).

- Implemented various fixes for automated test failures on PHP 5.4+ and PHP 7.

  Drupal core automated tests now pass in these environments.

- Improved support for PHP 7 by fixing various problems.

- Fixed various bugs with PHP 5.5+ imagerotate(), including when incorrect

  color indices are passed in.

- Fixed a regression introduced in Drupal 7.43 that allowed files uploaded by

  anonymous users to be lost after form validation errors, and that also caused

  regressions with certain contributed modules.

- Fixed a regression introduced in Drupal 7.36 which caused the default value

  of hidden textarea fields to be ignored.

- Fixed robots.txt to allow search engines to access CSS, JavaScript and image

  files.

- Changed wording on the Update Manager settings page to clarify that the

  option to check for disabled module updates also applies to uninstalled

  modules (administrative-facing translatable string change).

- Changed the help text when editing menu links and configuring URL redirect

  actions so that it does not reference "Drupal" or the drupal.org website

  (administrative-facing translatable string change).

- Fixed the locale safety check that is used to ensure that translations are

  safe to allow for tokens in the href/src attributes of translated strings.

- Fixed that URL generation only works on port 80 when using domain based

  language negotation.

- Made method="get" forms work inside the administrative overlay. The fix adds

  a new hidden field to these forms when they appear inside the overlay (minor

  data structure change).

- Increased maxlength of menu link title input fields in the node form and

  menu link form from 128 to 255 characters.

- Removed meaningless post-check=0 and pre-check=0 cache control headers from

  Drupal HTTP responses.

- Added a .editorconfig file to auto-configure editors that support it.

- Added --directory option to run-tests.sh for easier test discovery of all

  tests within a project.

- Made run-tests.sh exit with a failure code when there are test fails or

  problems running the script.

- Fixed that cookies from previous tests are still present when a new test

  starts in DrupalWebTestCase.

- Improved performance of queries on the {authmap} database table.

- Fixed handling of missing files and functions inside the registry.

- Fixed Ajax handling for tableselect form elements that use checkboxes.

- Fixed a bug which caused ip_address() to return nothing when the client IP

  address and proxy IP address are the same.

- Added a new option to format_xml_elements() to allow for already encoded

  values.

- Changed the {history} table's node ID field to be an unsigned integer, to

  match the same field in the {node} table and to prevent errors with very

  large node IDs.

- Added an explicit page callback to the "admin/people/create" menu item in the

  User module (minor data structure change). Previously this automatically

  inherited the page callback from the parent "admin/people" menu item, which

  broke contributed modules that override the "admin/people" page.

- Numerous small bug fixes.

- Numerous API documentation improvements.

- Additional automated test coverage.

- Fabian Franz 'Fabianx' https://www.drupal.org/u/fabianx

- Stefan Ruijsenaars 'stefan.r' https://www.drupal.org/u/stefanr-0

  if (!empty($callback) && is_callable($callback)) {

define('VERSION', '7.52');

 * @param bool $trigger_error

 *   Whether to trigger an error when a file is missing or has unexpectedly

 *   moved. This defaults to TRUE, but can be set to FALSE by calling code that

 *   merely wants to check whether an item exists in the filesystem.

function drupal_get_filename($type, $name, $filename = NULL, $trigger_error = TRUE) {

  // The $files static variable will hold the locations of all requested files.

  // We can be sure that any file listed in this static variable actually

  // exists as all additions have gone through a file_exists() check.

  static $files = array();

    // Prime the static cache with the provided filename.

    // This item had already been found earlier in the request, either through

    // priming of the static cache (for example, in system_list()), through a

    // lookup in the {system} table, or through a file scan (cached or not). Do

    // nothing.

    // Look for the filename listed in the {system} table. Verify that we have

    // an active database connection before doing so, since this function is

    // called both before we have a database connection (i.e. during

    // installation) and when a database connection fails.

    $database_unavailable = TRUE;

        $database_unavailable = FALSE;

      // the database might be down, or we may have done a non-database cache

      // flush while $conf['page_cache_without_database'] = TRUE and

      // $conf['page_cache_invoke_hooks'] = TRUE. We have a fallback for these

      // cases so we hide the error completely.

    // Fall back to searching the filesystem if the database could not find the

    // file or the file does not exist at the path returned by the database.

      $files[$type][$name] = _drupal_get_filename_fallback($type, $name, $trigger_error, $database_unavailable);

    }

  }

  if (isset($files[$type][$name])) {

    return $files[$type][$name];

  }

}

/**

 * Performs a cached file system scan as a fallback when searching for a file.

 *

 * This function looks for the requested file by triggering a file scan,

 * caching the new location if the file has moved and caching the miss

 * if the file is missing. If a file had been marked as missing in a previous

 * file scan, or if it has been marked as moved and is still in the last known

 * location, no new file scan will be performed.

 *

 * @param string $type

 *   The type of the item (theme, theme_engine, module, profile).

 * @param string $name

 *   The name of the item for which the filename is requested.

 * @param bool $trigger_error

 *   Whether to trigger an error when a file is missing or has unexpectedly

 *   moved.

 * @param bool $database_unavailable

 *   Whether this function is being called because the Drupal database could

 *   not be queried for the file's location.

 *

 * @return

 *   The filename of the requested item or NULL if the item is not found.

 *

 * @see drupal_get_filename()

 */

function _drupal_get_filename_fallback($type, $name, $trigger_error, $database_unavailable) {

  $file_scans = &_drupal_file_scan_cache();

  $filename = NULL;

  // If the cache indicates that the item is missing, or we can verify that the

  // item exists in the location the cache says it exists in, use that.

  if (isset($file_scans[$type][$name]) && ($file_scans[$type][$name] === FALSE || file_exists($file_scans[$type][$name]))) {

    $filename = $file_scans[$type][$name];

  }

  // Otherwise, perform a new file scan to find the item.

  else {

    $filename = _drupal_get_filename_perform_file_scan($type, $name);

    // Update the static cache, and mark the persistent cache for updating at

    // the end of the page request. See drupal_file_scan_write_cache().

    $file_scans[$type][$name] = $filename;

    $file_scans['#write_cache'] = TRUE;

  }

  // If requested, trigger a user-level warning about the missing or

  // unexpectedly moved file. If the database was unavailable, do not trigger a

  // warning in the latter case, though, since if the {system} table could not

  // be queried there is no way to know if the location found here was

  // "unexpected" or not.

  if ($trigger_error) {

    $error_type = $filename === FALSE ? 'missing' : 'moved';

    if ($error_type == 'missing' || !$database_unavailable) {

      _drupal_get_filename_fallback_trigger_error($type, $name, $error_type);

    }

  }

  // The cache stores FALSE for files that aren't found (to be able to

  // distinguish them from files that have not yet been searched for), but

  // drupal_get_filename() expects NULL for these instead, so convert to NULL

  // before returning.

  if ($filename === FALSE) {

    $filename = NULL;

  }

  return $filename;

}

/**

 * Returns the current list of cached file system scan results.

 *

 * @return

 *   An associative array tracking the most recent file scan results for all

 *   files that have had scans performed. The keys are the type and name of the

 *   item that was searched for, and the values can be either:

 *   - Boolean FALSE if the item was not found in the file system.

 *   - A string pointing to the location where the item was found.

 */

function &_drupal_file_scan_cache() {

  $file_scans = &drupal_static(__FUNCTION__, array());

  // The file scan results are stored in a persistent cache (in addition to the

  // static cache) but because this function can be called before the

  // persistent cache is available, we must merge any items that were found

  // earlier in the page request into the results from the persistent cache.

  if (!isset($file_scans['#cache_merge_done'])) {

    try {

      if (function_exists('cache_get')) {

        $cache = cache_get('_drupal_file_scan_cache', 'cache_bootstrap');

        if (!empty($cache->data)) {

          // File scan results from the current request should take precedence

          // over the results from the persistent cache, since they are newer.

          $file_scans = drupal_array_merge_deep($cache->data, $file_scans);

        // Set a flag to indicate that the persistent cache does not need to be

        // merged again.

        $file_scans['#cache_merge_done'] = TRUE;

    catch (Exception $e) {

      // Hide the error.

    }

  return $file_scans;

}

/**

 * Performs a file system scan to search for a system resource.

 *

 * @param $type

 *   The type of the item (theme, theme_engine, module, profile).

 * @param $name

 *   The name of the item for which the filename is requested.

 *

 * @return

 *   The filename of the requested item or FALSE if the item is not found.

 *

 * @see drupal_get_filename()

 * @see _drupal_get_filename_fallback()

 */

function _drupal_get_filename_perform_file_scan($type, $name) {

  // The location of files will not change during the request, so do not use

  // drupal_static().

  static $dirs = array(), $files = array();

  // We have a consistent directory naming: modules, themes...

  $dir = $type . 's';

  if ($type == 'theme_engine') {

    $dir = 'themes/engines';

    $extension = 'engine';

  }

  elseif ($type == 'theme') {

    $extension = 'info';

  }

  else {

    $extension = $type;

  }

  // Check if we had already scanned this directory/extension combination.

  if (!isset($dirs[$dir][$extension])) {

    // Log that we have now scanned this directory/extension combination

    // into a static variable so as to prevent unnecessary file scans.

    $dirs[$dir][$extension] = TRUE;

    if (!function_exists('drupal_system_listing')) {

      require_once DRUPAL_ROOT . '/includes/common.inc';

    }

    // Scan the appropriate directories for all files with the requested

    // extension, not just the file we are currently looking for. This

    // prevents unnecessary scans from being repeated when this function is

    // called more than once in the same page request.

    $matches = drupal_system_listing("/^" . DRUPAL_PHP_FUNCTION_PATTERN . "\.$extension$/", $dir, 'name', 0);

    foreach ($matches as $matched_name => $file) {

      // Log the locations found in the file scan into a static variable.

      $files[$type][$matched_name] = $file->uri;

    }

  }

  // Return the results of the file system scan, or FALSE to indicate the file

  // was not found.

  return isset($files[$type][$name]) ? $files[$type][$name] : FALSE;

}

/**

 * Triggers a user-level warning for missing or unexpectedly moved files.

 *

 * @param $type

 *   The type of the item (theme, theme_engine, module, profile).

 * @param $name

 *   The name of the item for which the filename is requested.

 * @param $error_type

 *   The type of the error ('missing' or 'moved').

 *

 * @see drupal_get_filename()

 * @see _drupal_get_filename_fallback()

 */

function _drupal_get_filename_fallback_trigger_error($type, $name, $error_type) {

  // Hide messages due to known bugs that will appear on a lot of sites.

  // @todo Remove this in https://www.drupal.org/node/2383823

  if (empty($name)) {

    return;

  }

  // Make sure we only show any missing or moved file errors only once per

  // request.

  static $errors_triggered = array();

  if (empty($errors_triggered[$type][$name][$error_type])) {

    // Use _drupal_trigger_error_with_delayed_logging() here since these are

    // triggered during low-level operations that cannot necessarily be

    // interrupted by a watchdog() call.

    if ($error_type == 'missing') {

      _drupal_trigger_error_with_delayed_logging(format_string('The following @type is missing from the file system: %name. For information about how to fix this, see <a href="@documentation">the documentation page</a>.', array('@type' => $type, '%name' => $name, '@documentation' => 'https://www.drupal.org/node/2487215')), E_USER_WARNING);

    }

    elseif ($error_type == 'moved') {

      _drupal_trigger_error_with_delayed_logging(format_string('The following @type has moved within the file system: %name. In order to fix this, clear caches or put the @type back in its original location. For more information, see <a href="@documentation">the documentation page</a>.', array('@type' => $type, '%name' => $name, '@documentation' => 'https://www.drupal.org/node/2487215')), E_USER_WARNING);

    }

    $errors_triggered[$type][$name][$error_type] = TRUE;

  }

}

/**

 * Invokes trigger_error() with logging delayed until the end of the request.

 *

 * This is an alternative to PHP's trigger_error() function which can be used

 * during low-level Drupal core operations that need to avoid being interrupted

 * by a watchdog() call.

 *

 * Normally, Drupal's error handler calls watchdog() in response to a

 * trigger_error() call. However, this invokes hook_watchdog() which can run

 * arbitrary code. If the trigger_error() happens in the middle of an

 * operation such as a rebuild operation which should not be interrupted by

 * arbitrary code, that could potentially break or trigger the rebuild again.

 * This function protects against that by delaying the watchdog() call until

 * the end of the current page request.

 *

 * This is an internal function which should only be called by low-level Drupal

 * core functions. It may be removed in a future Drupal 7 release.

 *

 * @param string $error_msg

 *   The error message to trigger. As with trigger_error() itself, this is

 *   limited to 1024 bytes; additional characters beyond that will be removed.

 * @param int $error_type

 *   (optional) The type of error. This should be one of the E_USER family of

 *   constants. As with trigger_error() itself, this defaults to E_USER_NOTICE

 *   if not provided.

 *

 * @see _drupal_log_error()

 */

function _drupal_trigger_error_with_delayed_logging($error_msg, $error_type = E_USER_NOTICE) {

  $delay_logging = &drupal_static(__FUNCTION__, FALSE);

  $delay_logging = TRUE;

  trigger_error($error_msg, $error_type);

  $delay_logging = FALSE;

}

/**

 * Writes the file scan cache to the persistent cache.

 *

 * This cache stores all files marked as missing or moved after a file scan

 * to prevent unnecessary file scans in subsequent requests. This cache is

 * cleared in system_list_reset() (i.e. after a module/theme rebuild).

 */

function drupal_file_scan_write_cache() {

  // Only write to the persistent cache if requested, and if we know that any

  // data previously in the cache was successfully loaded and merged in by

  // _drupal_file_scan_cache().

  $file_scans = &_drupal_file_scan_cache();

  if (isset($file_scans['#write_cache']) && isset($file_scans['#cache_merge_done'])) {

    unset($file_scans['#write_cache']);

    cache_set('_drupal_file_scan_cache', $file_scans, 'cache_bootstrap');

    'Cache-Control' => 'no-cache, must-revalidate',

 * @section sec_context String context

 * Matching source strings are normally only translated once, and the same

 * translation is used everywhere that has a matching string. However, in some

 * cases, a certain English source string needs to have multiple translations.

 * One example of this is the string "May", which could be used as either a

 * full month name or a 3-letter abbreviated month. In other languages where

 * the month name for May has more than 3 letters, you would need to provide

 * two different translations (one for the full name and one abbreviated), and

 * the correct form would need to be chosen, depending on how "May" is being

 * used. To facilitate this, the "May" string should be provided with two

 * different contexts in the $options parameter when calling t(). For example:

 * @code

 * t('May', array(), array('context' => 'Long month name')

 * t('May', array(), array('context' => 'Abbreviated month name')

 * @endcode

 * See https://localize.drupal.org/node/2109 for more information.

 *

 *   - 'context' (defaults to the empty context): A string giving the context

 *     that the source string belongs to. See @ref sec_context above for more

 *     information.

        if (!empty($untrusted)) {

          // The right-most IP is the most specific we can trust.

          $ip_address = array_pop($untrusted);

        }

        else {

          // All IP addresses in the forwarded array are configured proxy IPs

          // (and thus trusted). We take the leftmost IP.

          $ip_address = array_shift($forwarded);

        }

      include_once DRUPAL_ROOT . '/' . $lookup_cache[$cache_key];

    include_once DRUPAL_ROOT . '/' . $file;

 *     'param=value&param=value&...'; to generate this, use http_build_query().

 *     Defaults to NULL.

 *

 * @see http_build_query()

 *     - 'encoded': TRUE if 'value' is already encoded

 *

 * If 'encoded' is TRUE it is up to the caller to ensure that 'value' is either

 * entity-encoded or CDATA-escaped. Using this option is not recommended when

 * working with untrusted user input, since failing to escape the data

 * correctly has security implications.

          $output .= '>' . (is_array($value['value']) ? format_xml_elements($value['value']) : (!empty($value['encoded']) ? $value['value'] : check_plain($value['value']))) . '</' . $value['key'] . ">\n";

  // By default, do not allow the site to be rendered in an iframe on another

  // domain, but provide a variable to override this. If the code running for

  // this page request already set the X-Frame-Options header earlier, don't

  // overwrite it here.

  $frame_options = variable_get('x_frame_options', 'SAMEORIGIN');

  if ($frame_options && is_null(drupal_get_http_header('X-Frame-Options'))) {

    drupal_add_http_header('X-Frame-Options', $frame_options);

  }

  drupal_file_scan_write_cache();

  $count = &drupal_static(__FUNCTION__ . '_count', 0);

  // If the $css variable has been reset with drupal_static_reset(), there is

  // no longer any CSS being tracked, so set the counter back to 0 also.

  if (count($css) === 0) {

    $count = 0;

  }

    $options['weight'] += $count / 1000;

    $count++;

  // Use the advanced drupal_static() pattern, since this is called very often.

  static $drupal_static_fast;

  if (!isset($drupal_static_fast)) {

    $drupal_static_fast['allow_css_double_underscores'] = &drupal_static(__FUNCTION__ . ':allow_css_double_underscores');

  }

  $allow_css_double_underscores = &$drupal_static_fast['allow_css_double_underscores'];

  if (!isset($allow_css_double_underscores)) {

    $allow_css_double_underscores = variable_get('allow_css_double_underscores', FALSE);

  }

  // Preserve BEM-style double-underscores depending on custom setting.

  if ($allow_css_double_underscores) {

    $filter['__'] = '__';

  }

  /**

   * List of escaped database, table, and field names, keyed by unescaped names.

   *

   * @var array

   */

  protected $escapedNames = array();

  /**

   * List of escaped aliases names, keyed by unescaped aliases.

   *

   * @var array

   */

  protected $escapedAliases = array();

   * @return string

    if (!isset($this->escapedNames[$table])) {

      $this->escapedNames[$table] = preg_replace('/[^A-Za-z0-9_.]+/', '', $table);

    }

    return $this->escapedNames[$table];

   * @return string

    if (!isset($this->escapedNames[$field])) {

      $this->escapedNames[$field] = preg_replace('/[^A-Za-z0-9_.]+/', '', $field);

    }

    return $this->escapedNames[$field];

   * @return string

    if (!isset($this->escapedAliases[$field])) {

      $this->escapedAliases[$field] = preg_replace('/[^A-Za-z0-9_]+/', '', $field);

    }

    return $this->escapedAliases[$field];

  /**

   * Checks whether utf8mb4 support is configurable in settings.php.

   *

   * @return bool

   */

  public function utf8mb4IsConfigurable() {

    // Since 4 byte UTF-8 is not supported by default, there is nothing to

    // configure.

    return FALSE;

  }

  /**

   * Checks whether utf8mb4 support is currently active.

   *

   * @return bool

   */

  public function utf8mb4IsActive() {

    // Since 4 byte UTF-8 is not supported by default, there is nothing to

    // activate.

    return FALSE;

  }

  /**

   * Checks whether utf8mb4 support is available on the current database system.

   *

   * @return bool

   */

  public function utf8mb4IsSupported() {

    // By default we assume that the database backend may not support 4 byte

    // UTF-8.

    return FALSE;

  }

    $charset = 'utf8';

    // Check if the charset is overridden to utf8mb4 in settings.php.

    if ($this->utf8mb4IsActive()) {

      $charset = 'utf8mb4';

    }

    $dsn .= ';charset=' . $charset;

      $this->exec('SET NAMES ' . $charset . ' COLLATE ' . $connection_options['collation']);

      $this->exec('SET NAMES ' . $charset);

  public function utf8mb4IsConfigurable() {

    return TRUE;

  }

  public function utf8mb4IsActive() {

    return isset($this->connectionOptions['charset']) && $this->connectionOptions['charset'] === 'utf8mb4';

  }

  public function utf8mb4IsSupported() {

    // Ensure that the MySQL driver supports utf8mb4 encoding.

    $version = $this->getAttribute(PDO::ATTR_CLIENT_VERSION);

    if (strpos($version, 'mysqlnd') !== FALSE) {

      // The mysqlnd driver supports utf8mb4 starting at version 5.0.9.

      $version = preg_replace('/^\D+([\d.]+).*/', '$1', $version);

      if (version_compare($version, '5.0.9', '<')) {

        return FALSE;

      }

    }

    else {

      // The libmysqlclient driver supports utf8mb4 starting at version 5.5.3.

      if (version_compare($version, '5.5.3', '<')) {

        return FALSE;

      }

    }

    // Ensure that the MySQL server supports large prefixes and utf8mb4.

    try {

      $this->query("CREATE TABLE {drupal_utf8mb4_test} (id VARCHAR(255), PRIMARY KEY(id(255))) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci ROW_FORMAT=DYNAMIC ENGINE=INNODB");

    }

    catch (Exception $e) {

      return FALSE;

    }

    $this->query("DROP TABLE {drupal_utf8mb4_test}");

    return TRUE;

  }

      $db_info = $this->connection->getConnectionOptions();

      $info['database'] = $db_info['database'];

      // Allow the default charset to be overridden in settings.php.

      'mysql_character_set' => $this->connection->utf8mb4IsActive() ? 'utf8mb4' : 'utf8',

    // The row format needs to be either DYNAMIC or COMPRESSED in order to allow

    // for the innodb_large_prefix setting to take effect, see

    // https://dev.mysql.com/doc/refman/5.6/en/create-table.html

    if ($this->connection->utf8mb4IsActive()) {

      $sql .= ' ROW_FORMAT=DYNAMIC';

    }

  public function utf8mb4IsActive() {

    return TRUE;

  }

  public function utf8mb4IsSupported() {

    return TRUE;

  }

      // Many contrib modules assume that query tags used for access-checking

      // purposes follow the pattern $entity_type . '_access'. But this is

      // not the case for taxonomy terms, since core used to add term_access

      // instead of taxonomy_term_access to its queries. Provide backwards

      // compatibility by adding both tags here instead of attempting to fix

      // all contrib modules in a coordinated effort.

      // TODO:

      // - Extract this mechanism into a hook as part of a public (non-security)

      //   issue.

      // - Emit E_USER_DEPRECATED if term_access is used.

      //   https://www.drupal.org/node/2575081

      $term_access_tags = array('term_access' => 1, 'taxonomy_term_access' => 1);

      if (array_intersect_key($this->alterTags, $term_access_tags)) {

        $this->alterTags += $term_access_tags;

      }

  public function utf8mb4IsActive() {

    return TRUE;

  }

  public function utf8mb4IsSupported() {

    return TRUE;

  }

 * entity type, entity ID, and revision ID). It is not possible to query across

   *   The column that should hold the value to be matched, defined in the

   *   hook_field_schema() of this field. If this is omitted then all of the

   *   other parameters are ignored, except $field, and this call will just be

   *   adding a condition that says that the field has a value, rather than

   *   testing the value itself.

   *   The value to test the column value against. In most cases, this is a

   *   scalar. For more complex options, it is an array. The meaning of each

   *   element in the array is dependent on $operator.

   *   The operator to be used to test the given value. The possible values are:

   *   - '=', '<>', '>', '>=', '<', '<=', 'STARTS_WITH', 'CONTAINS': These

   *     operators expect $value to be a literal of the same type as the

   *     column.

   *   - 'IN', 'NOT IN': These operators expect $value to be an array of

   *     literals of the same type as the column.

   *   - 'BETWEEN': This operator expects $value to be an array of two literals

   *     of the same type as the column.

   *   The operator can be omitted, and will default to 'IN' if the value is an

   *   array, or to '=' otherwise.

   *   $delta_group. For example, let's presume a multivalue field which has

   *   two columns, 'color' and 'shape', and for entity ID 1, there are two

   *   values: red/square and blue/circle. Entity ID 1 does not have values

   *   corresponding to 'red circle'; however if you pass 'red' and 'circle' as

   *   conditions, it will appear in the results -- by default queries will run

   *   against any combination of deltas. By passing the conditions with the

   *   same $delta_group it will ensure that only values attached to the same

   *   delta are matched, and entity 1 would then be excluded from the results.

   *   The column that should hold the value to be matched, defined in the

   *   hook_field_schema() of this field. If this is omitted then all of the

   *   other parameters are ignored, except $field, and this call will just be

   *   adding a condition that says that the field has a value, rather than

   *   testing the value itself.

   *   two columns, 'color' and 'shape', and for entity ID 1, there are two

   *   conditions, it will appear in the results -- by default queries will run

  // Log the error immediately, unless this is a non-fatal error which has been

  // triggered via drupal_trigger_error_with_delayed_logging(); in that case

  // trigger it in a shutdown function. Fatal errors are always triggered

  // immediately since for a fatal error the page request will end here anyway.

  if (!$fatal && drupal_static('_drupal_trigger_error_with_delayed_logging')) {

    drupal_register_shutdown_function('watchdog', 'php', '%type: !message in %function (line %line of %file).', $error, $error['severity_level']);

  }

  else {

    watchdog('php', '%type: !message in %function (line %line of %file).', $error, $error['severity_level']);

  }

  // Inline file_uri_scheme() function call for performance reasons.

  $position = strpos($uri, '://');

  $scheme = $position ? substr($uri, 0, $position) : FALSE;

 * @see hook_file_download()

 *   and search_forms(). hook_forms() can also be used to define forms in

 *   classes.

      $form_state['build_info']['base_form_id'] = isset($form_definition['base_form_id']) ? $form_definition['base_form_id'] : $callback;

  if (isset($form_state['wrapper_callback']) && is_callable($form_state['wrapper_callback'])) {

  if ($input !== FALSE && $input !== NULL) {

  if (strlen($pass1) > 0 || strlen($pass2) > 0) {

            '#ajax' => isset($element['#ajax']) ? $element['#ajax'] : NULL,

  // Prevent the hook_requirements() check from telling us to convert the

  // database to utf8mb4.

  $connection = Database::getConnection();

  if ($connection->utf8mb4IsConfigurable() && $connection->utf8mb4IsActive()) {

    variable_set('drupal_all_databases_are_utf8mb4', TRUE);

  }

          // Save the original base URL. If it contains a port, we need to

          // retain it below.

          if (!empty($options['base_url'])) {

            // The colon in the URL scheme messes up the port checking below.

            $normalized_base_url = str_replace(array('https://', 'http://'), '', $options['base_url']);

          }

          // In case either the original base URL or the HTTP host contains a

          // port, retain it.

          $http_host = $_SERVER['HTTP_HOST'];

          if (isset($normalized_base_url) && strpos($normalized_base_url, ':') !== FALSE) {

            list($host, $port) = explode(':', $normalized_base_url);

            $options['base_url'] .= ':' . $port;

          }

          elseif (strpos($http_host, ':') !== FALSE) {

            list($host, $port) = explode(':', $http_host);

            $options['base_url'] .= ':' . $port;

          }

  // Some strings have tokens in them. For tokens in the first part of href or

  // src HTML attributes, filter_xss() removes part of the token, the part

  // before the first colon.  filter_xss() assumes it could be an attempt to

  // inject javascript. When filter_xss() removes part of tokens, it causes the

  // string to not be translatable when it should be translatable. See

  // LocaleStringIsSafeTest::testLocaleStringIsSafe().

  //

  // We can recognize tokens since they are wrapped with brackets and are only

  // composed of alphanumeric characters, colon, underscore, and dashes. We can

  // be sure these strings are safe to strip out before the string is checked in

  // filter_xss() because no dangerous javascript will match that pattern.

  //

  // @todo Do not strip out the token. Fix filter_xss() to not incorrectly

  //   alter the string. https://www.drupal.org/node/2372127

  $string = preg_replace('/\[[a-z0-9_-]+(:[a-z0-9_-]+)+\]/i', '', $string);

    // Refresh the time limit every 10 parsed rows to ensure there is always

    // enough time to import the data for large PO files.

    if (!($lineno % 10)) {

      drupal_set_time_limit(30);

    }

          // the breadcrumb for the current page.

  // Clean up the bootstrap file scan cache.

  drupal_static_reset('_drupal_file_scan_cache');

  cache_clear_all('_drupal_file_scan_cache', 'cache_bootstrap');

 *   arrays from their implementations, those are merged into one array

 *   recursively. Note: integer keys in arrays will be lost, as the merge is

 *   done using array_merge_recursive().

      return TRUE;

    return TRUE;

  return TRUE;

  $theme_functions = preg_grep('/^(' . implode(')|(', $prefixes) . ')_/', $functions['user']);

        $matches = preg_grep('/^' . $prefix . '_' . $pattern . '/', $theme_functions);

  foreach (system_region_list($GLOBALS['theme'], REGIONS_ALL, FALSE) as $region_key) {

  // 'Default' profile has been renamed to 'Standard' in D7.

  // We change the profile here to prevent a broken record in the system table.

  // See system_update_7049().

  if ($profile == 'default') {

    $profile = 'standard';

    variable_set('install_profile', $profile);

  }

  Drupal.displayAjaxError(Drupal.ajaxError(xmlhttprequest, uri, customMessage));

        Drupal.displayAjaxError(Drupal.ajaxError(xmlhttp, db.uri));

/**

 * Add a global variable which determines if the window is being unloaded.

 *

 * This is primarily used by Drupal.displayAjaxError().

 */

Drupal.beforeUnloadCalled = false;

$(window).bind('beforeunload pagehide', function () {

    Drupal.beforeUnloadCalled = true;

});

/**

 * Displays a JavaScript error from an Ajax response when appropriate to do so.

 */

Drupal.displayAjaxError = function (message) {

  // Skip displaying the message if the user deliberately aborted (for example,

  // by reloading the page or navigating to a different page) while the Ajax

  // request was still ongoing. See, for example, the discussion at

  // http://stackoverflow.com/questions/699941/handle-ajax-error-when-a-user-clicks-refresh.

  if (!Drupal.beforeUnloadCalled) {

    alert(message);

  }

};