Club Drupal

<?php

/**

 * @file

 * This file contains the code registry parser engine.

 */

/**

 * @defgroup registry Code registry

 * @{

 * The code registry engine.

 *

 * Drupal maintains an internal registry of all interfaces or classes in the

 * system, allowing it to lazy-load code files as needed (reducing the amount

 * of code that must be parsed on each request).

 */

/**

 * Does the work for registry_update().

 */

function _registry_update() {

  // The registry serves as a central autoloader for all classes, including

  // the database query builders. However, the registry rebuild process

  // requires write ability to the database, which means having access to the

  // query builders that require the registry in order to be loaded. That

  // causes a fatal race condition. Therefore we manually include the

  // appropriate query builders for the currently active database before the

  // registry rebuild process runs.

  $connection_info = Database::getConnectionInfo();

  $driver = $connection_info['default']['driver'];

  require_once DRUPAL_ROOT . '/includes/database/query.inc';

  require_once DRUPAL_ROOT . '/includes/database/select.inc';

  require_once DRUPAL_ROOT . '/includes/database/' . $driver . '/query.inc';

  // During the first registry rebuild in a request, we check all the files.

  // During subsequent rebuilds, we only add new files. It makes the rebuilding

  // process faster during installation of modules.

  static $check_existing_files = TRUE;

  // Get current list of modules and their files.

  $modules = db_query("SELECT * FROM {system} WHERE type = 'module'")->fetchAll();

  // Get the list of files we are going to parse.

  $files = array();

  foreach ($modules as &$module) {

    $module->info = unserialize($module->info);

    $dir = dirname($module->filename);

    // Store the module directory for use in hook_registry_files_alter().

    $module->dir = $dir;

    if ($module->status) {

      // Add files for enabled modules to the registry.

      foreach ($module->info['files'] as $file) {

        $files["$dir/$file"] = array('module' => $module->name, 'weight' => $module->weight);

      }

    }

  }

  foreach (file_scan_directory('includes', '/\.inc$/') as $filename => $file) {

    $files["$filename"] = array('module' => '', 'weight' => 0);

  }

  // Initialize an empty array for the unchanged files.

  $unchanged_files = array();

  $transaction = db_transaction();

  try {

    // Allow modules to manually modify the list of files before the registry

    // parses them. The $modules array provides the .info file information, which

    // includes the list of files registered to each module. Any files in the

    // list can then be added to the list of files that the registry will parse,

    // or modify attributes of a file.

    drupal_alter('registry_files', $files, $modules);

    foreach (registry_get_parsed_files() as $filename => $file) {

      // Add the hash for those files we have already parsed.

      if (isset($files[$filename])) {

        if ($check_existing_files === TRUE) {

          $files[$filename]['hash'] = $file['hash'];

        }

        else {

          // Ignore that file for this request, it has been parsed previously

          // and it is unlikely it has changed.

          unset($files[$filename]);

          $unchanged_files[$filename] = $file;

        }

      }

      else {

        // Flush the registry of resources in files that are no longer on disc

        // or are in files that no installed modules require to be parsed.

        db_delete('registry')

          ->condition('filename', $filename)

          ->execute();

        db_delete('registry_file')

          ->condition('filename', $filename)

          ->execute();

      }

    }

    $parsed_files = _registry_parse_files($files);

    // Add unchanged files to the files.

    $files += $unchanged_files;

    $unchanged_resources = array();

    $lookup_cache = array();

    if ($cache = cache_get('lookup_cache', 'cache_bootstrap')) {

      $lookup_cache = $cache->data;

    }

    foreach ($lookup_cache as $key => $file) {

      // If the file for this cached resource is carried over unchanged from

      // the last registry build, then we can safely re-cache it.

      if ($file && isset($files[$file]) && !in_array($file, $parsed_files, TRUE)) {

        $unchanged_resources[$key] = $file;

      }

    }

  }

  catch (Exception $e) {

    $transaction->rollback();

    watchdog_exception('registry', $e);

    throw $e;

  }

  module_implements('', FALSE, TRUE);

  _registry_check_code(REGISTRY_RESET_LOOKUP_CACHE);

  // During the next run in this request, don't bother re-checking existing

  // files.

  $check_existing_files = FALSE;

  // We have some unchanged resources, warm up the cache - no need to pay

  // for looking them up again.

  if (count($unchanged_resources) > 0) {

    cache_set('lookup_cache', $unchanged_resources, 'cache_bootstrap');

  }

}

/**

 * Return the list of files in registry_file

 */

function registry_get_parsed_files() {

  $files = array();

  // We want the result as a keyed array.

  $files = db_query("SELECT * FROM {registry_file}")->fetchAllAssoc('filename', PDO::FETCH_ASSOC);

  return $files;

}

/**

 * Parse all changed files and save their interface and class listings.

 *

 * Parse all files that have changed since the registry was last built, and save

 * their interface and class listings.

 *

 * @param $files

 *  The list of files to check and parse.

 */

function _registry_parse_files($files) {

  $parsed_files = array();

  foreach ($files as $filename => $file) {

    if (file_exists($filename)) {

      $hash = hash_file('sha256', $filename);

      if (empty($file['hash']) || $file['hash'] != $hash) {

        $file['hash'] = $hash;

        $parsed_files[$filename] = $file;

      }

    }

  }

  foreach ($parsed_files as $filename => $file) {

    _registry_parse_file($filename, file_get_contents($filename), $file['module'], $file['weight']);

    db_merge('registry_file')

      ->key(array('filename' => $filename))

      ->fields(array(

        'hash' => $file['hash'],

      ))

      ->execute();

  }

  return array_keys($parsed_files);

}

/**

 * Parse a file and save its interface and class listings.

 *

 * @param $filename

 *   Name of the file we are going to parse.

 * @param $contents

 *   Contents of the file we are going to parse as a string.

 * @param $module

 *   (optional) Name of the module this file belongs to.

 * @param $weight

 *   (optional) Weight of the module.

 */

function _registry_parse_file($filename, $contents, $module = '', $weight = 0) {

  if (preg_match_all('/^\s*(?:abstract|final)?\s*(class|interface|trait)\s+([a-zA-Z0-9_]+)/m', $contents, $matches)) {

    foreach ($matches[2] as $key => $name) {

      db_merge('registry')

        ->key(array(

          'name' => $name,

          'type' => $matches[1][$key],

        ))

        ->fields(array(

          'filename' => $filename,

          'module' => $module,

          'weight' => $weight,

        ))

        ->execute();

    }

    // Delete any resources for this file where the name is not in the list

    // we just merged in.

    db_delete('registry')

      ->condition('filename', $filename)

      ->condition('name', $matches[2], 'NOT IN')

      ->execute();

  }

}

/**

 * @} End of "defgroup registry".

 */