<?php

/**

 * @file

 * Administration functions for locale.module.

 */

/**

 * The language is determined using a URL language indicator:

 * path prefix or domain according to the configuration.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_URL', 'locale-url');

/**

 * The language is set based on the browser language settings.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_BROWSER', 'locale-browser');

/**

 * The language is determined using the current interface language.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_INTERFACE', 'locale-interface');

/**

 * If no URL language is available language is determined using an already

 * detected one.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_URL_FALLBACK', 'locale-url-fallback');

/**

 * The language is set based on the user language settings.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_USER', 'locale-user');

/**

 * The language is set based on the request/session parameters.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_SESSION', 'locale-session');

/**

 * Regular expression pattern used to localize JavaScript strings.

 */

define('LOCALE_JS_STRING', '(?:(?:\'(?:\\\\\'|[^\'])*\'|"(?:\\\\"|[^"])*")(?:\s*\+\s*)?)+');

/**

 * Regular expression pattern used to match simple JS object literal.

 *

 * This pattern matches a basic JS object, but will fail on an object with

 * nested objects. Used in JS file parsing for string arg processing.

 */

define('LOCALE_JS_OBJECT', '\{.*?\}');

/**

 * Regular expression to match an object containing a key 'context'.

 *

 * Pattern to match a JS object containing a 'context key' with a string value,

 * which is captured. Will fail if there are nested objects.

 */

define('LOCALE_JS_OBJECT_CONTEXT', '

  \{              # match object literal start

  .*?             # match anything, non-greedy

  (?:             # match a form of "context"

    \'context\'

    |

    "context"

    |

    context

  )

  \s*:\s*         # match key-value separator ":"

  (' . LOCALE_JS_STRING . ')  # match context string

  .*?             # match anything, non-greedy

  \}              # match end of object literal

');

/**

 * Translation import mode overwriting all existing translations

 * if new translated version available.

 */

define('LOCALE_IMPORT_OVERWRITE', 0);

/**

 * Translation import mode keeping existing translations and only

 * inserting new strings.

 */

define('LOCALE_IMPORT_KEEP', 1);

/**

 * URL language negotiation: use the path prefix as URL language

 * indicator.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_URL_PREFIX', 0);

/**

 * URL language negotiation: use the domain as URL language

 * indicator.

 */

define('LOCALE_LANGUAGE_NEGOTIATION_URL_DOMAIN', 1);

/**

 * @defgroup locale-languages-negotiation Language negotiation options

 * @{

 * Functions for language negotiation.

 *

 * There are functions that provide the ability to identify the

 * language. This behavior can be controlled by various options.

 */

/**

 * Identifies the language from the current interface language.

 *

 * @return

 *   The current interface language code.

 */

function locale_language_from_interface() {

  global $language;

  return isset($language->language) ? $language->language : FALSE;

}

/**

 * Identify language from the Accept-language HTTP header we got.

 *

 * We perform browser accept-language parsing only if page cache is disabled,

 * otherwise we would cache a user-specific preference.

 *

 * @param $languages

 *   An array of language objects for enabled languages ordered by weight.

 *

 * @return

 *   A valid language code on success, FALSE otherwise.

 */

function locale_language_from_browser($languages) {

  if (empty($_SERVER['HTTP_ACCEPT_LANGUAGE'])) {

    return FALSE;

  }

  // The Accept-Language header contains information about the language

  // preferences configured in the user's browser / operating system.

  // RFC 2616 (section 14.4) defines the Accept-Language header as follows:

  //   Accept-Language = "Accept-Language" ":"

  //                  1#( language-range [ ";" "q" "=" qvalue ] )

  //   language-range  = ( ( 1*8ALPHA *( "-" 1*8ALPHA ) ) | "*" )

  // Samples: "hu, en-us;q=0.66, en;q=0.33", "hu,en-us;q=0.5"

  $browser_langcodes = array();

  if (preg_match_all('@(?<=[, ]|^)([a-zA-Z-]+|\*)(?:;q=([0-9.]+))?(?:$|\s*,\s*)@', trim($_SERVER['HTTP_ACCEPT_LANGUAGE']), $matches, PREG_SET_ORDER)) {

    foreach ($matches as $match) {

      // We can safely use strtolower() here, tags are ASCII.

      // RFC2616 mandates that the decimal part is no more than three digits,

      // so we multiply the qvalue by 1000 to avoid floating point comparisons.

      $langcode = strtolower($match[1]);

      $qvalue = isset($match[2]) ? (float) $match[2] : 1;

      $browser_langcodes[$langcode] = (int) ($qvalue * 1000);

    }

  }

  // We should take pristine values from the HTTP headers, but Internet Explorer

  // from version 7 sends only specific language tags (eg. fr-CA) without the

  // corresponding generic tag (fr) unless explicitly configured. In that case,

  // we assume that the lowest value of the specific tags is the value of the

  // generic language to be as close to the HTTP 1.1 spec as possible.

  // See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4 and

  // http://blogs.msdn.com/b/ie/archive/2006/10/17/accept-language-header-for-internet-explorer-7.aspx

  asort($browser_langcodes);

  foreach ($browser_langcodes as $langcode => $qvalue) {

    $generic_tag = strtok($langcode, '-');

    if (!isset($browser_langcodes[$generic_tag])) {

      $browser_langcodes[$generic_tag] = $qvalue;

    }

  }

  // Find the enabled language with the greatest qvalue, following the rules

  // of RFC 2616 (section 14.4). If several languages have the same qvalue,

  // prefer the one with the greatest weight.

  $best_match_langcode = FALSE;

  $max_qvalue = 0;

  foreach ($languages as $langcode => $language) {

    // Language tags are case insensitive (RFC2616, sec 3.10).

    $langcode = strtolower($langcode);

    // If nothing matches below, the default qvalue is the one of the wildcard

    // language, if set, or is 0 (which will never match).

    $qvalue = isset($browser_langcodes['*']) ? $browser_langcodes['*'] : 0;

    // Find the longest possible prefix of the browser-supplied language

    // ('the language-range') that matches this site language ('the language tag').

    $prefix = $langcode;

    do {

      if (isset($browser_langcodes[$prefix])) {

        $qvalue = $browser_langcodes[$prefix];

        break;

      }

    }

    while ($prefix = substr($prefix, 0, strrpos($prefix, '-')));

    // Find the best match.

    if ($qvalue > $max_qvalue) {

      $best_match_langcode = $language->language;

      $max_qvalue = $qvalue;

    }

  }

  return $best_match_langcode;

}

/**

 * Identify language from the user preferences.

 *

 * @param $languages

 *   An array of valid language objects.

 *

 * @return

 *   A valid language code on success, FALSE otherwise.

 */

function locale_language_from_user($languages) {

  // User preference (only for logged users).

  global $user;

  if ($user->uid) {

    return $user->language;

  }

  // No language preference from the user.

  return FALSE;

}

/**

 * Identify language from a request/session parameter.

 *

 * @param $languages

 *   An array of valid language objects.

 *

 * @return

 *   A valid language code on success, FALSE otherwise.

 */

function locale_language_from_session($languages) {

  $param = variable_get('locale_language_negotiation_session_param', 'language');

  // Request parameter: we need to update the session parameter only if we have

  // an authenticated user.

  if (isset($_GET[$param]) && isset($languages[$langcode = $_GET[$param]])) {

    global $user;

    if ($user->uid) {

      $_SESSION[$param] = $langcode;

    }

    return $langcode;

  }

  // Session parameter.

  if (isset($_SESSION[$param])) {

    return $_SESSION[$param];

  }

  return FALSE;

}

/**

 * Identify language via URL prefix or domain.

 *

 * @param $languages

 *   An array of valid language objects.

 *

 * @return

 *   A valid language code on success, FALSE otherwise.

 */

function locale_language_from_url($languages) {

  $language_url = FALSE;

  if (!language_negotiation_get_any(LOCALE_LANGUAGE_NEGOTIATION_URL)) {

    return $language_url;

  }

  switch (variable_get('locale_language_negotiation_url_part', LOCALE_LANGUAGE_NEGOTIATION_URL_PREFIX)) {

    case LOCALE_LANGUAGE_NEGOTIATION_URL_PREFIX:

      // $_GET['q'] might not be available at this time, because

      // path initialization runs after the language bootstrap phase.

      list($language, $_GET['q']) = language_url_split_prefix(isset($_GET['q']) ? $_GET['q'] : NULL, $languages);

      if ($language !== FALSE) {

        $language_url = $language->language;

      }

      break;

    case LOCALE_LANGUAGE_NEGOTIATION_URL_DOMAIN:

      // Get only the host, not the port.

      $http_host= $_SERVER['HTTP_HOST'];

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

        $http_host_tmp = explode(':', $http_host);

        $http_host = current($http_host_tmp);

      }

      foreach ($languages as $language) {

        // Skip check if the language doesn't have a domain.

        if ($language->domain) {

          // Only compare the domains not the protocols or ports.

          // Remove protocol and add http:// so parse_url works

          $host = 'http://' . str_replace(array('http://', 'https://'), '', $language->domain);

          $host = parse_url($host, PHP_URL_HOST);

          if ($http_host == $host) {

            $language_url = $language->language;

            break;

          }

        }

      }

      break;

  }

  return $language_url;

}

/**

 * Determines the language to be assigned to URLs when none is detected.

 *

 * The language negotiation process has a fallback chain that ends with the

 * default language provider. Each built-in language type has a separate

 * initialization:

 * - Interface language, which is the only configurable one, always gets a valid

 *   value. If no request-specific language is detected, the default language

 *   will be used.

 * - Content language merely inherits the interface language by default.

 * - URL language is detected from the requested URL and will be used to rewrite

 *   URLs appearing in the page being rendered. If no language can be detected,

 *   there are two possibilities:

 *   - If the default language has no configured path prefix or domain, then the

 *     default language is used. This guarantees that (missing) URL prefixes are

 *     preserved when navigating through the site.

 *   - If the default language has a configured path prefix or domain, a

 *     requested URL having an empty prefix or domain is an anomaly that must be

 *     fixed. This is done by introducing a prefix or domain in the rendered

 *     page matching the detected interface language.

 *

 * @param $languages

 *   (optional) An array of valid language objects. This is passed by

 *   language_provider_invoke() to every language provider callback, but it is

 *   not actually needed here. Defaults to NULL.

 * @param $language_type

 *   (optional) The language type to fall back to. Defaults to the interface

 *   language.

 *

 * @return

 *   A valid language code.

 */

function locale_language_url_fallback($language = NULL, $language_type = LANGUAGE_TYPE_INTERFACE) {

  $default = language_default();

  $prefix = (variable_get('locale_language_negotiation_url_part', LOCALE_LANGUAGE_NEGOTIATION_URL_PREFIX) == LOCALE_LANGUAGE_NEGOTIATION_URL_PREFIX);

  // If the default language is not configured to convey language information,

  // a missing URL language information indicates that URL language should be

  // the default one, otherwise we fall back to an already detected language.

  if (($prefix && empty($default->prefix)) || (!$prefix && empty($default->domain))) {

    return $default->language;

  }

  else {

    return $GLOBALS[$language_type]->language;

  }

}

/**

 * Return the URL language switcher block. Translation links may be provided by

 * other modules.

 */

function locale_language_switcher_url($type, $path) {

  $languages = language_list('enabled');

  $links = array();

  foreach ($languages[1] as $language) {

    $links[$language->language] = array(

      'href'       => $path,

      'title'      => $language->native,

      'language'   => $language,

      'attributes' => array('class' => array('language-link')),

    );

  }

  return $links;

}

/**

 * Return the session language switcher block.

 */

function locale_language_switcher_session($type, $path) {

  drupal_add_css(drupal_get_path('module', 'locale') . '/locale.css');

  $param = variable_get('locale_language_negotiation_session_param', 'language');

  $language_query = isset($_SESSION[$param]) ? $_SESSION[$param] : $GLOBALS[$type]->language;

  $languages = language_list('enabled');

  $links = array();

  $query = $_GET;

  unset($query['q']);

  foreach ($languages[1] as $language) {

    $langcode = $language->language;

    $links[$langcode] = array(

      'href'       => $path,

      'title'      => $language->native,

      'attributes' => array('class' => array('language-link')),

      'query'      => $query,

    );

    if ($language_query != $langcode) {

      $links[$langcode]['query'][$param] = $langcode;

    }

    else {

      $links[$langcode]['attributes']['class'][] = 'session-active';

    }

  }

  return $links;

}

/**

 * Rewrite URLs for the URL language provider.

 */

function locale_language_url_rewrite_url(&$path, &$options) {

  static $drupal_static_fast;

  if (!isset($drupal_static_fast)) {

    $drupal_static_fast['languages'] = &drupal_static(__FUNCTION__);

  }

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

  if (!isset($languages)) {

    $languages = language_list('enabled');

    $languages = array_flip(array_keys($languages[1]));

  }

  // Language can be passed as an option, or we go for current URL language.

  if (!isset($options['language'])) {

    global $language_url;

    $options['language'] = $language_url;

  }

  // We allow only enabled languages here.

  elseif (!isset($languages[$options['language']->language])) {

    unset($options['language']);

    return;

  }

  if (isset($options['language'])) {

    switch (variable_get('locale_language_negotiation_url_part', LOCALE_LANGUAGE_NEGOTIATION_URL_PREFIX)) {

      case LOCALE_LANGUAGE_NEGOTIATION_URL_DOMAIN:

        if ($options['language']->domain) {

          // 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']);

          }