Club Drupal

<?php

 /**

 * @file

 * Functions for form and batch generation and processing.

 */

/**

 * @defgroup forms Form builder functions

 * @{

 * Functions that build an abstract representation of a HTML form.

 *

 * All modules should declare their form builder functions to be in this

 * group and each builder function should reference its validate and submit

 * functions using \@see. Conversely, validate and submit functions should

 * reference the form builder function using \@see. For examples, of this see

 * system_modules_uninstall() or user_pass(), the latter of which has the

 * following in its doxygen documentation:

 * - \@ingroup forms

 * - \@see user_pass_validate()

 * - \@see user_pass_submit()

 *

 * @}

 */

/**

 * @defgroup form_api Form generation

 * @{

 * Functions to enable the processing and display of HTML forms.

 *

 * Drupal uses these functions to achieve consistency in its form processing and

 * presentation, while simplifying code and reducing the amount of HTML that

 * must be explicitly generated by modules.

 *

 * The primary function used with forms is drupal_get_form(), which is

 * used for forms presented interactively to a user. Forms can also be built and

 * submitted programmatically without any user input using the

 * drupal_form_submit() function.

 *

 * drupal_get_form() handles retrieving, processing, and displaying a rendered

 * HTML form for modules automatically.

 *

 * Here is an example of how to use drupal_get_form() and a form builder

 * function:

 * @code

 * $form = drupal_get_form('my_module_example_form');

 * ...

 * function my_module_example_form($form, &$form_state) {

 *   $form['submit'] = array(

 *     '#type' => 'submit',

 *     '#value' => t('Submit'),

 *   );

 *   return $form;

 * }

 * function my_module_example_form_validate($form, &$form_state) {

 *   // Validation logic.

 * }

 * function my_module_example_form_submit($form, &$form_state) {

 *   // Submission logic.

 * }

 * @endcode

 *

 * Or with any number of additional arguments:

 * @code

 * $extra = "extra";

 * $form = drupal_get_form('my_module_example_form', $extra);

 * ...

 * function my_module_example_form($form, &$form_state, $extra) {

 *   $form['submit'] = array(

 *     '#type' => 'submit',

 *     '#value' => $extra,

 *   );

 *   return $form;

 * }

 * @endcode

 *

 * The $form argument to form-related functions is a structured array containing

 * the elements and properties of the form. For information on the array

 * components and format, and more detailed explanations of the Form API

 * workflow, see the

 * @link forms_api_reference.html Form API reference @endlink

 * and the

 * @link http://drupal.org/node/37775 Form API documentation section. @endlink

 * In addition, there is a set of Form API tutorials in

 * @link form_example_tutorial.inc the Form Example Tutorial @endlink which

 * provide basics all the way up through multistep forms.

 *

 * In the form builder, validation, submission, and other form functions,

 * $form_state is the primary influence on the processing of the form and is

 * passed by reference to most functions, so they use it to communicate with

 * the form system and each other.

 *

 * See drupal_build_form() for documentation of $form_state keys.

 */

/**

 * Returns a renderable form array for a given form ID.

 *

 * This function should be used instead of drupal_build_form() when $form_state

 * is not needed (i.e., when initially rendering the form) and is often

 * used as a menu callback.

 *

 * @param $form_id

 *   The unique string identifying the desired form. If a function with that

 *   name exists, it is called to build the form array. Modules that need to

 *   generate the same form (or very similar forms) using different $form_ids

 *   can implement hook_forms(), which maps different $form_id values to the

 *   proper form constructor function. Examples may be found in node_forms(),

 *   and search_forms().

 * @param ...

 *   Any additional arguments are passed on to the functions called by

 *   drupal_get_form(), including the unique form constructor function. For

 *   example, the node_edit form requires that a node object is passed in here

 *   when it is called. These are available to implementations of

 *   hook_form_alter() and hook_form_FORM_ID_alter() as the array

 *   $form_state['build_info']['args'].

 *

 * @return

 *   The form array.

 *

 * @see drupal_build_form()

 */

function drupal_get_form($form_id) {

  $form_state = array();

  $args = func_get_args();

  // Remove $form_id from the arguments.

  array_shift($args);

  $form_state['build_info']['args'] = $args;

  return drupal_build_form($form_id, $form_state);

}

/**

 * Builds and process a form based on a form id.

 *

 * The form may also be retrieved from the cache if the form was built in a

 * previous page-load. The form is then passed on for processing, validation

 * and submission if there is proper input.

 *

 * @param $form_id

 *   The unique string identifying the desired form. If a function with that

 *   name exists, it is called to build the form array. Modules that need to

 *   generate the same form (or very similar forms) using different $form_ids

 *   can implement hook_forms(), which maps different $form_id values to the

 *   proper form constructor function. Examples may be found in node_forms(),

 *   and search_forms().

 * @param $form_state

 *   An array which stores information about the form. This is passed as a

 *   reference so that the caller can use it to examine what in the form changed

 *   when the form submission process is complete. Furthermore, it may be used

 *   to store information related to the processed data in the form, which will

 *   persist across page requests when the 'cache' or 'rebuild' flag is set.

 *   The following parameters may be set in $form_state to affect how the form

 *   is rendered:

 *   - build_info: Internal. An associative array of information stored by Form

 *     API that is necessary to build and rebuild the form from cache when the

 *     original context may no longer be available:

 *     - args: A list of arguments to pass to the form constructor.

 *     - files: An optional array defining include files that need to be loaded

 *       for building the form. Each array entry may be the path to a file or

 *       another array containing values for the parameters 'type', 'module' and

 *       'name' as needed by module_load_include(). The files listed here are

 *       automatically loaded by form_get_cache(). By default the current menu

 *       router item's 'file' definition is added, if any. Use

 *       form_load_include() to add include files from a form constructor.

 *     - form_id: Identification of the primary form being constructed and

 *       processed.

 *     - base_form_id: Identification for a base form, as declared in a

 *       hook_forms() implementation.

 *     - immutable: If this flag is set to TRUE, a new form build id is

 *       generated when the form is loaded from the cache. If it is subsequently

 *       saved to the cache again, it will have another cache id and therefore

 *       the original form and form-state will remain unaltered. This is

 *       important when page caching is enabled in order to prevent form state

 *       from leaking between anonymous users.

 *   - rebuild_info: Internal. Similar to 'build_info', but pertaining to

 *     drupal_rebuild_form().

 *   - rebuild: Normally, after the entire form processing is completed and

 *     submit handlers have run, a form is considered to be done and

 *     drupal_redirect_form() will redirect the user to a new page using a GET

 *     request (so a browser refresh does not re-submit the form). However, if

 *     'rebuild' has been set to TRUE, then a new copy of the form is

 *     immediately built and sent to the browser, instead of a redirect. This is

 *     used for multi-step forms, such as wizards and confirmation forms.

 *     Normally, $form_state['rebuild'] is set by a submit handler, since it is

 *     usually logic within a submit handler that determines whether a form is

 *     done or requires another step. However, a validation handler may already

 *     set $form_state['rebuild'] to cause the form processing to bypass submit

 *     handlers and rebuild the form instead, even if there are no validation

 *     errors.

 *   - redirect: Used to redirect the form on submission. It may either be a

 *     string containing the destination URL, or an array of arguments

 *     compatible with drupal_goto(). See drupal_redirect_form() for complete

 *     information.

 *   - no_redirect: If set to TRUE the form will NOT perform a drupal_goto(),

 *     even if 'redirect' is set.

 *   - method: The HTTP form method to use for finding the input for this form.

 *     May be 'post' or 'get'. Defaults to 'post'. Note that 'get' method

 *     forms do not use form ids so are always considered to be submitted, which

 *     can have unexpected effects. The 'get' method should only be used on

 *     forms that do not change data, as that is exclusively the domain of

 *     'post.'

 *   - cache: If set to TRUE the original, unprocessed form structure will be

 *     cached, which allows the entire form to be rebuilt from cache. A typical

 *     form workflow involves two page requests; first, a form is built and

 *     rendered for the user to fill in. Then, the user fills the form in and

 *     submits it, triggering a second page request in which the form must be

 *     built and processed. By default, $form and $form_state are built from

 *     scratch during each of these page requests. Often, it is necessary or

 *     desired to persist the $form and $form_state variables from the initial

 *     page request to the one that processes the submission. 'cache' can be set

 *     to TRUE to do this. A prominent example is an Ajax-enabled form, in which

 *     ajax_process_form() enables form caching for all forms that include an

 *     element with the #ajax property. (The Ajax handler has no way to build

 *     the form itself, so must rely on the cached version.) Note that the

 *     persistence of $form and $form_state happens automatically for

 *     (multi-step) forms having the 'rebuild' flag set, regardless of the value

 *     for 'cache'.

 *   - no_cache: If set to TRUE the form will NOT be cached, even if 'cache' is

 *     set.

 *   - values: An associative array of values submitted to the form. The

 *     validation functions and submit functions use this array for nearly all

 *     their decision making. (Note that #tree determines whether the values are

 *     a flat array or an array whose structure parallels the $form array. See

 *     @link forms_api_reference.html Form API reference @endlink for more

 *     information.) These are raw and unvalidated, so should not be used

 *     without a thorough understanding of security implications. In almost all

 *     cases, code should use the data in the 'values' array exclusively. The

 *     most common use of this key is for multi-step forms that need to clear

 *     some of the user input when setting 'rebuild'. The values correspond to

 *     $_POST or $_GET, depending on the 'method' chosen.

 *   - always_process: If TRUE and the method is GET, a form_id is not

 *     necessary. This should only be used on RESTful GET forms that do NOT

 *     write data, as this could lead to security issues. It is useful so that

 *     searches do not need to have a form_id in their query arguments to

 *     trigger the search.

 *   - must_validate: Ordinarily, a form is only validated once, but there are

 *     times when a form is resubmitted internally and should be validated

 *     again. Setting this to TRUE will force that to happen. This is most

 *     likely to occur during Ajax operations.

 *   - programmed: If TRUE, the form was submitted programmatically, usually

 *     invoked via drupal_form_submit(). Defaults to FALSE.

 *   - programmed_bypass_access_check: If TRUE, programmatic form submissions

 *     are processed without taking #access into account. Set this to FALSE

 *     when submitting a form programmatically with values that may have been

 *     input by the user executing the current request; this will cause #access

 *     to be respected as it would on a normal form submission. Defaults to

 *     TRUE.

 *   - process_input: Boolean flag. TRUE signifies correct form submission.

 *     This is always TRUE for programmed forms coming from drupal_form_submit()

 *     (see 'programmed' key), or if the form_id coming from the $_POST data is

 *     set and matches the current form_id.

 *   - submitted: If TRUE, the form has been submitted. Defaults to FALSE.

 *   - executed: If TRUE, the form was submitted and has been processed and

 *     executed. Defaults to FALSE.

 *   - triggering_element: (read-only) The form element that triggered

 *     submission. This is the same as the deprecated

 *     $form_state['clicked_button']. It is the element that caused submission,

 *     which may or may not be a button (in the case of Ajax forms). This key is

 *     often used to distinguish between various buttons in a submit handler,

 *     and is also used in Ajax handlers.

 *   - clicked_button: Deprecated. Use triggering_element instead.

 *   - has_file_element: Internal. If TRUE, there is a file element and Form API

 *     will set the appropriate 'enctype' HTML attribute on the form.

 *   - groups: Internal. An array containing references to fieldsets to render

 *     them within vertical tabs.

 *   - storage: $form_state['storage'] is not a special key, and no specific

 *     support is provided for it in the Form API. By tradition it was

 *     the location where application-specific data was stored for communication

 *     between the submit, validation, and form builder functions, especially

 *     in a multi-step-style form. Form implementations may use any key(s)

 *     within $form_state (other than the keys listed here and other reserved

 *     ones used by Form API internals) for this kind of storage. The

 *     recommended way to ensure that the chosen key doesn't conflict with ones

 *     used by the Form API or other modules is to use the module name as the

 *     key name or a prefix for the key name. For example, the Node module uses

 *     $form_state['node'] in node editing forms to store information about the

 *     node being edited, and this information stays available across successive

 *     clicks of the "Preview" button as well as when the "Save" button is

 *     finally clicked.

 *   - buttons: A list containing copies of all submit and button elements in

 *     the form.

 *   - complete form: A reference to the $form variable containing the complete

 *     form structure. #process, #after_build, #element_validate, and other

 *     handlers being invoked on a form element may use this reference to access

 *     other information in the form the element is contained in.

 *   - temporary: An array holding temporary data accessible during the current

 *     page request only. All $form_state properties that are not reserved keys

 *     (see form_state_keys_no_cache()) persist throughout a multistep form

 *     sequence. Form API provides this key for modules to communicate

 *     information across form-related functions during a single page request.

 *     It may be used to temporarily save data that does not need to or should

 *     not be cached during the whole form workflow; e.g., data that needs to be

 *     accessed during the current form build process only. There is no use-case

 *     for this functionality in Drupal core.

 *   - wrapper_callback: Modules that wish to pre-populate certain forms with

 *     common elements, such as back/next/save buttons in multi-step form

 *     wizards, may define a form builder function name that returns a form

 *     structure, which is passed on to the actual form builder function.

 *     Such implementations may either define the 'wrapper_callback' via

 *     hook_forms() or have to invoke drupal_build_form() (instead of

 *     drupal_get_form()) on their own in a custom menu callback to prepare

 *     $form_state accordingly.

 *   Information on how certain $form_state properties control redirection

 *   behavior after form submission may be found in drupal_redirect_form().

 *

 * @return

 *   The rendered form. This function may also perform a redirect and hence may

 *   not return at all, depending upon the $form_state flags that were set.

 *

 * @see drupal_redirect_form()

 */

function drupal_build_form($form_id, &$form_state) {

  // Ensure some defaults; if already set they will not be overridden.

  $form_state += form_state_defaults();

  if (!isset($form_state['input'])) {

    $form_state['input'] = $form_state['method'] == 'get' ? $_GET : $_POST;

  }

  if (isset($_SESSION['batch_form_state'])) {

    // We've been redirected here after a batch processing. The form has

    // already been processed, but needs to be rebuilt. See _batch_finished().

    $form_state = $_SESSION['batch_form_state'];

    unset($_SESSION['batch_form_state']);

    return drupal_rebuild_form($form_id, $form_state);

  }

  // If the incoming input contains a form_build_id, we'll check the cache for a

  // copy of the form in question. If it's there, we don't have to rebuild the

  // form to proceed. In addition, if there is stored form_state data from a

  // previous step, we'll retrieve it so it can be passed on to the form

  // processing code.

  $check_cache = isset($form_state['input']['form_id']) && $form_state['input']['form_id'] == $form_id && !empty($form_state['input']['form_build_id']);

  if ($check_cache) {

    $form = form_get_cache($form_state['input']['form_build_id'], $form_state);

  }

  // If the previous bit of code didn't result in a populated $form object, we

  // are hitting the form for the first time and we need to build it from

  // scratch.

  if (!isset($form)) {

    // If we attempted to serve the form from cache, uncacheable $form_state

    // keys need to be removed after retrieving and preparing the form, except

    // any that were already set prior to retrieving the form.

    if ($check_cache) {

      $form_state_before_retrieval = $form_state;

    }

    $form = drupal_retrieve_form($form_id, $form_state);

    drupal_prepare_form($form_id, $form, $form_state);

    // form_set_cache() removes uncacheable $form_state keys defined in

    // form_state_keys_no_cache() in order for multi-step forms to work

    // properly. This means that form processing logic for single-step forms

    // using $form_state['cache'] may depend on data stored in those keys

    // during drupal_retrieve_form()/drupal_prepare_form(), but form

    // processing should not depend on whether the form is cached or not, so

    // $form_state is adjusted to match what it would be after a

    // form_set_cache()/form_get_cache() sequence. These exceptions are

    // allowed to survive here:

    // - always_process: Does not make sense in conjunction with form caching

    //   in the first place, since passing form_build_id as a GET parameter is

    //   not desired.

    // - temporary: Any assigned data is expected to survives within the same

    //   page request.

    if ($check_cache) {

      $uncacheable_keys = array_flip(array_diff(form_state_keys_no_cache(), array('always_process', 'temporary')));

      $form_state = array_diff_key($form_state, $uncacheable_keys);

      $form_state += $form_state_before_retrieval;

    }

  }

  // Now that we have a constructed form, process it. This is where:

  // - Element #process functions get called to further refine $form.

  // - User input, if any, gets incorporated in the #value property of the

  //   corresponding elements and into $form_state['values'].

  // - Validation and submission handlers are called.

  // - If this submission is part of a multistep workflow, the form is rebuilt

  //   to contain the information of the next step.

  // - If necessary, the form and form state are cached or re-cached, so that

  //   appropriate information persists to the next page request.

  // All of the handlers in the pipeline receive $form_state by reference and

  // can use it to know or update information about the state of the form.

  drupal_process_form($form_id, $form, $form_state);

  // If this was a successful submission of a single-step form or the last step

  // of a multi-step form, then drupal_process_form() issued a redirect to

  // another page, or back to this page, but as a new request. Therefore, if

  // we're here, it means that this is either a form being viewed initially

  // before any user input, or there was a validation error requiring the form

  // to be re-displayed, or we're in a multi-step workflow and need to display

  // the form's next step. In any case, we have what we need in $form, and can

  // return it for rendering.

  return $form;

}

/**

 * Retrieves default values for the $form_state array.

 */

function form_state_defaults() {

  return array(

    'rebuild' => FALSE,

    'rebuild_info' => array(),

    'redirect' => NULL,

    // @todo 'args' is usually set, so no other default 'build_info' keys are

    //   appended via += form_state_defaults().

    'build_info' => array(

      'args' => array(),

      'files' => array(),

    ),

    'temporary' => array(),

    'submitted' => FALSE,

    'executed' => FALSE,

    'programmed' => FALSE,

    'programmed_bypass_access_check' => TRUE,

    'cache'=> FALSE,

    'method' => 'post',

    'groups' => array(),

    'buttons' => array(),

  );

}

/**

 * Constructs a new $form from the information in $form_state.

 *

 * This is the key function for making multi-step forms advance from step to

 * step. It is called by drupal_process_form() when all user input processing,

 * including calling validation and submission handlers, for the request is

 * finished. If a validate or submit handler set $form_state['rebuild'] to TRUE,

 * and if other conditions don't preempt a rebuild from happening, then this

 * function is called to generate a new $form, the next step in the form

 * workflow, to be returned for rendering.

 *

 * Ajax form submissions are almost always multi-step workflows, so that is one

 * common use-case during which form rebuilding occurs. See ajax_form_callback()

 * for more information about creating Ajax-enabled forms.

 *

 * @param $form_id

 *   The unique string identifying the desired form. If a function

 *   with that name exists, it is called to build the form array.

 *   Modules that need to generate the same form (or very similar forms)

 *   using different $form_ids can implement hook_forms(), which maps

 *   different $form_id values to the proper form constructor function. Examples

 *   may be found in node_forms() and search_forms().

 * @param $form_state

 *   A keyed array containing the current state of the form.

 * @param $old_form

 *   (optional) A previously built $form. Used to retain the #build_id and

 *   #action properties in Ajax callbacks and similar partial form rebuilds. The

 *   only properties copied from $old_form are the ones which both exist in

 *   $old_form and for which $form_state['rebuild_info']['copy'][PROPERTY] is

 *   TRUE. If $old_form is not passed, the entire $form is rebuilt freshly.

 *   'rebuild_info' needs to be a separate top-level property next to

 *   'build_info', since the contained data must not be cached.

 *

 * @return

 *   The newly built form.

 *

 * @see drupal_process_form()

 * @see ajax_form_callback()

 */

function drupal_rebuild_form($form_id, &$form_state, $old_form = NULL) {

  $form = drupal_retrieve_form($form_id, $form_state);

  // If only parts of the form will be returned to the browser (e.g., Ajax or

  // RIA clients), or if the form already had a new build ID regenerated when it

  // was retrieved from the form cache, reuse the existing #build_id.

  // Otherwise, a new #build_id is generated, to not clobber the previous

  // build's data in the form cache; also allowing the user to go back to an

  // earlier build, make changes, and re-submit.

  // @see drupal_prepare_form()

  $enforce_old_build_id = isset($old_form['#build_id']) && !empty($form_state['rebuild_info']['copy']['#build_id']);

  $old_form_is_mutable_copy = isset($old_form['#build_id_old']);

  if ($enforce_old_build_id || $old_form_is_mutable_copy) {

    $form['#build_id'] = $old_form['#build_id'];

    if ($old_form_is_mutable_copy) {

      $form['#build_id_old'] = $old_form['#build_id_old'];

    }

  }

  else {

    if (isset($old_form['#build_id'])) {

      $form['#build_id_old'] = $old_form['#build_id'];

    }

    $form['#build_id'] = 'form-' . drupal_random_key();

  }

  // #action defaults to request_uri(), but in case of Ajax and other partial

  // rebuilds, the form is submitted to an alternate URL, and the original

  // #action needs to be retained.

  if (isset($old_form['#action']) && !empty($form_state['rebuild_info']['copy']['#action'])) {

    $form['#action'] = $old_form['#action'];

  }

  drupal_prepare_form($form_id, $form, $form_state);

  // Caching is normally done in drupal_process_form(), but what needs to be

  // cached is the $form structure before it passes through form_builder(),

  // so we need to do it here.

  // @todo For Drupal 8, find a way to avoid this code duplication.

  if (empty($form_state['no_cache'])) {

    form_set_cache($form['#build_id'], $form, $form_state);

  }

  // Clear out all group associations as these might be different when

  // re-rendering the form.

  $form_state['groups'] = array();

  // Return a fully built form that is ready for rendering.

  return form_builder($form_id, $form, $form_state);

}

/**

 * Fetches a form from cache.

 */

function form_get_cache($form_build_id, &$form_state) {

  if ($cached = cache_get('form_' . $form_build_id, 'cache_form')) {

    $form = $cached->data;

    global $user;

    if ((isset($form['#cache_token']) && drupal_valid_token($form['#cache_token'])) || (!isset($form['#cache_token']) && !$user->uid)) {

      if ($cached = cache_get('form_state_' . $form_build_id, 'cache_form')) {

        // Re-populate $form_state for subsequent rebuilds.

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

        // If the original form is contained in include files, load the files.

        // @see form_load_include()

        $form_state['build_info'] += array('files' => array());

        foreach ($form_state['build_info']['files'] as $file) {

          if (is_array($file)) {

            $file += array('type' => 'inc', 'name' => $file['module']);

            module_load_include($file['type'], $file['module'], $file['name']);

          }

          elseif (file_exists($file)) {

            require_once DRUPAL_ROOT . '/' . $file;

          }

        }

      }

      // Generate a new #build_id if the cached form was rendered on a cacheable

      // page.

      if (!empty($form_state['build_info']['immutable'])) {

        $form['#build_id_old'] = $form['#build_id'];

        $form['#build_id'] = 'form-' . drupal_random_key();

        $form['form_build_id']['#value'] = $form['#build_id'];

        $form['form_build_id']['#id'] = $form['#build_id'];

        unset($form_state['build_info']['immutable']);

      }

      return $form;

    }

  }

}

/**

 * Stores a form in the cache.

 */

function form_set_cache($form_build_id, $form, $form_state) {

  // 6 hours cache life time for forms should be plenty.

  $expire = 21600;

  // Ensure that the form build_id embedded in the form structure is the same as

  // the one passed in as a parameter. This is an additional safety measure to

  // prevent legacy code operating directly with form_get_cache and

  // form_set_cache from accidentally overwriting immutable form state.

  if ($form['#build_id'] != $form_build_id) {

    watchdog('form', 'Form build-id mismatch detected while attempting to store a form in the cache.', array(), WATCHDOG_ERROR);

    return;

  }

  // Cache form structure.

  if (isset($form)) {

    if ($GLOBALS['user']->uid) {

      $form['#cache_token'] = drupal_get_token();

    }

    unset($form['#build_id_old']);

    cache_set('form_' . $form_build_id, $form, 'cache_form', REQUEST_TIME + $expire);

  }

  // Cache form state.

  if (variable_get('cache', 0) && drupal_page_is_cacheable()) {

    $form_state['build_info']['immutable'] = TRUE;

  }

  if ($data = array_diff_key($form_state, array_flip(form_state_keys_no_cache()))) {

    cache_set('form_state_' . $form_build_id, $data, 'cache_form', REQUEST_TIME + $expire);

  }

}

/**

 * Returns an array of $form_state keys that shouldn't be cached.

 */

function form_state_keys_no_cache() {

  return array(

    // Public properties defined by form constructors and form handlers.

    'always_process',

    'must_validate',

    'rebuild',

    'rebuild_info',

    'redirect',

    'no_redirect',

    'temporary',

    // Internal properties defined by form processing.

    'buttons',

    'triggering_element',

    'clicked_button',

    'complete form',

    'groups',

    'input',

    'method',

    'submit_handlers',

    'submitted',

    'executed',

    'validate_handlers',

    'values',

  );

}

/**

 * Ensures an include file is loaded whenever the form is processed.

 *

 * Example:

 * @code

 *   // Load node.admin.inc from Node module.

 *   form_load_include($form_state, 'inc', 'node', 'node.admin');

 * @endcode

 *

 * Use this function instead of module_load_include() from inside a form

 * constructor or any form processing logic as it ensures that the include file

 * is loaded whenever the form is processed. In contrast to using

 * module_load_include() directly, form_load_include() makes sure the include

 * file is correctly loaded also if the form is cached.

 *

 * @param $form_state

 *   The current state of the form.

 * @param $type

 *   The include file's type (file extension).

 * @param $module

 *   The module to which the include file belongs.

 * @param $name

 *   (optional) The base file name (without the $type extension). If omitted,

 *   $module is used; i.e., resulting in "$module.$type" by default.

 *

 * @return

 *   The filepath of the loaded include file, or FALSE if the include file was

 *   not found or has been loaded already.

 *

 * @see module_load_include()

 */

function form_load_include(&$form_state, $type, $module, $name = NULL) {

  if (!isset($name)) {

    $name = $module;

  }

  if (!isset($form_state['build_info']['files']["$module:$name.$type"])) {

    // Only add successfully included files to the form state.

    if ($result = module_load_include($type, $module, $name)) {

      $form_state['build_info']['files']["$module:$name.$type"] = array(

        'type' => $type,

        'module' => $module,

        'name' => $name,

      );

      return $result;

    }

  }

  return FALSE;

}

/**

 * Retrieves, populates, and processes a form.

 *

 * This function allows you to supply values for form elements and submit a

 * form for processing. Compare to drupal_get_form(), which also builds and

 * processes a form, but does not allow you to supply values.

 *

 * There is no return value, but you can check to see if there are errors

 * by calling form_get_errors().

 *

 * @param $form_id

 *   The unique string identifying the desired form. If a function

 *   with that name exists, it is called to build the form array.

 *   Modules that need to generate the same form (or very similar forms)

 *   using different $form_ids can implement hook_forms(), which maps

 *   different $form_id values to the proper form constructor function. Examples

 *   may be found in node_forms() and search_forms().

 * @param $form_state

 *   A keyed array containing the current state of the form. Most important is

 *   the $form_state['values'] collection, a tree of data used to simulate the

 *   incoming $_POST information from a user's form submission. If a key is not

 *   filled in $form_state['values'], then the default value of the respective

 *   element is used. To submit an unchecked checkbox or other control that

 *   browsers submit by not having a $_POST entry, include the key, but set the

 *   value to NULL.

 * @param ...

 *   Any additional arguments are passed on to the functions called by

 *   drupal_form_submit(), including the unique form constructor function.

 *   For example, the node_edit form requires that a node object be passed

 *   in here when it is called. Arguments that need to be passed by reference

 *   should not be included here, but rather placed directly in the $form_state

 *   build info array so that the reference can be preserved. For example, a

 *   form builder function with the following signature:

 *   @code

 *   function mymodule_form($form, &$form_state, &$object) {

 *   }

 *   @endcode

 *   would be called via drupal_form_submit() as follows:

 *   @code

 *   $form_state['values'] = $my_form_values;

 *   $form_state['build_info']['args'] = array(&$object);

 *   drupal_form_submit('mymodule_form', $form_state);

 *   @endcode

 * For example:

 * @code

 * // register a new user

 * $form_state = array();

 * $form_state['values']['name'] = 'robo-user';

 * $form_state['values']['mail'] = 'robouser@example.com';

 * $form_state['values']['pass']['pass1'] = 'password';

 * $form_state['values']['pass']['pass2'] = 'password';

 * $form_state['values']['op'] = t('Create new account');

 * drupal_form_submit('user_register_form', $form_state);

 * @endcode

 */

function drupal_form_submit($form_id, &$form_state) {

  if (!isset($form_state['build_info']['args'])) {

    $args = func_get_args();

    array_shift($args);

    array_shift($args);

    $form_state['build_info']['args'] = $args;

  }

  // Merge in default values.

  $form_state += form_state_defaults();

  // Populate $form_state['input'] with the submitted values before retrieving

  // the form, to be consistent with what drupal_build_form() does for

  // non-programmatic submissions (form builder functions may expect it to be

  // there).

  $form_state['input'] = $form_state['values'];

  $form_state['programmed'] = TRUE;

  $form = drupal_retrieve_form($form_id, $form_state);

  // Programmed forms are always submitted.

  $form_state['submitted'] = TRUE;

  // Reset form validation.

  $form_state['must_validate'] = TRUE;

  form_clear_error();

  drupal_prepare_form($form_id, $form, $form_state);

  drupal_process_form($form_id, $form, $form_state);

}

/**

 * Retrieves the structured array that defines a given form.

 *

 * @param $form_id

 *   The unique string identifying the desired form. If a function

 *   with that name exists, it is called to build the form array.

 *   Modules that need to generate the same form (or very similar forms)

 *   using different $form_ids can implement hook_forms(), which maps

 *   different $form_id values to the proper form constructor function.

 * @param $form_state

 *   A keyed array containing the current state of the form, including the

 *   additional arguments to drupal_get_form() or drupal_form_submit() in the

 *   'args' component of the array.

 */

function drupal_retrieve_form($form_id, &$form_state) {

  $forms = &drupal_static(__FUNCTION__);

  // Record the $form_id.

  $form_state['build_info']['form_id'] = $form_id;

  // Record the filepath of the include file containing the original form, so

  // the form builder callbacks can be loaded when the form is being rebuilt

  // from cache on a different path (such as 'system/ajax'). See

  // form_get_cache(). Don't do this in maintenance mode as Drupal may not be

  // fully bootstrapped (i.e. during installation) in which case

  // menu_get_item() is not available.

  if (!isset($form_state['build_info']['files']['menu']) && !defined('MAINTENANCE_MODE')) {

    $item = menu_get_item();

    if (!empty($item['include_file'])) {

      // Do not use form_load_include() here, as the file is already loaded.

      // Anyway, form_get_cache() is able to handle filepaths too.

      $form_state['build_info']['files']['menu'] = $item['include_file'];

    }

  }

  // We save two copies of the incoming arguments: one for modules to use

  // when mapping form ids to constructor functions, and another to pass to

  // the constructor function itself.

  $args = $form_state['build_info']['args'];

  // We first check to see if there's a function named after the $form_id.

  // If there is, we simply pass the arguments on to it to get the form.

  if (!function_exists($form_id)) {

    // In cases where many form_ids need to share a central constructor function,

    // such as the node editing form, modules can implement hook_forms(). It

    // maps one or more form_ids to the correct constructor functions.

    //

    // We cache the results of that hook to save time, but that only works

    // for modules that know all their form_ids in advance. (A module that

    // adds a small 'rate this comment' form to each comment in a list

    // would need a unique form_id for each one, for example.)

    //

    // So, we call the hook if $forms isn't yet populated, OR if it doesn't

    // yet have an entry for the requested form_id.

    if (!isset($forms) || !isset($forms[$form_id])) {

      $forms = module_invoke_all('forms', $form_id, $args);

    }

    $form_definition = $forms[$form_id];

    if (isset($form_definition['callback arguments'])) {

      $args = array_merge($form_definition['callback arguments'], $args);

    }

    if (isset($form_definition['callback'])) {

      $callback = $form_definition['callback'];

      $form_state['build_info']['base_form_id'] = $callback;

    }

    // In case $form_state['wrapper_callback'] is not defined already, we also

    // allow hook_forms() to define one.

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

      $form_state['wrapper_callback'] = $form_definition['wrapper_callback'];

    }

  }

  $form = array();

  // We need to pass $form_state by reference in order for forms to modify it,

  // since call_user_func_array() requires that referenced variables are passed

  // explicitly.

  $args = array_merge(array($form, &$form_state), $args);

  // When the passed $form_state (not using drupal_get_form()) defines a

  // 'wrapper_callback', then it requests to invoke a separate (wrapping) form

  // builder function to pre-populate the $form array with form elements, which

  // the actual form builder function ($callback) expects. This allows for

  // pre-populating a form with common elements for certain forms, such as

  // back/next/save buttons in multi-step form wizards. See drupal_build_form().

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

    $form = call_user_func_array($form_state['wrapper_callback'], $args);

    // Put the prepopulated $form into $args.

    $args[0] = $form;

  }

  // If $callback was returned by a hook_forms() implementation, call it.

  // Otherwise, call the function named after the form id.

  $form = call_user_func_array(isset($callback) ? $callback : $form_id, $args);

  $form['#form_id'] = $form_id;

  return $form;

}

/**

 * Processes a form submission.

 *

 * This function is the heart of form API. The form gets built, validated and in

 * appropriate cases, submitted and rebuilt.

 *

 * @param $form_id

 *   The unique string identifying the current form.

 * @param $form

 *   An associative array containing the structure of the form.

 * @param $form_state

 *   A keyed array containing the current state of the form. This

 *   includes the current persistent storage data for the form, and

 *   any data passed along by earlier steps when displaying a

 *   multi-step form. Additional information, like the sanitized $_POST

 *   data, is also accumulated here.

 */

function drupal_process_form($form_id, &$form, &$form_state) {

  $form_state['values'] = array();

  // With $_GET, these forms are always submitted if requested.

  if ($form_state['method'] == 'get' && !empty($form_state['always_process'])) {

    if (!isset($form_state['input']['form_build_id'])) {

      $form_state['input']['form_build_id'] = $form['#build_id'];

    }

    if (!isset($form_state['input']['form_id'])) {

      $form_state['input']['form_id'] = $form_id;

    }

    if (!isset($form_state['input']['form_token']) && isset($form['#token'])) {

      $form_state['input']['form_token'] = drupal_get_token($form['#token']);

    }

  }

  // form_builder() finishes building the form by calling element #process

  // functions and mapping user input, if any, to #value properties, and also

  // storing the values in $form_state['values']. We need to retain the

  // unprocessed $form in case it needs to be cached.

  $unprocessed_form = $form;

  $form = form_builder($form_id, $form, $form_state);

  // Only process the input if we have a correct form submission.

  if ($form_state['process_input']) {

    drupal_validate_form($form_id, $form, $form_state);

    // drupal_html_id() maintains a cache of element IDs it has seen,

    // so it can prevent duplicates. We want to be sure we reset that

    // cache when a form is processed, so scenarios that result in

    // the form being built behind the scenes and again for the

    // browser don't increment all the element IDs needlessly.

    if (!form_get_errors()) {

      // In case of errors, do not break HTML IDs of other forms.

      drupal_static_reset('drupal_html_id');

    }

    if ($form_state['submitted'] && !form_get_errors() && !$form_state['rebuild']) {

      // Execute form submit handlers.

      form_execute_handlers('submit', $form, $form_state);

      // We'll clear out the cached copies of the form and its stored data

      // here, as we've finished with them. The in-memory copies are still

      // here, though.

      if (!variable_get('cache', 0) && !empty($form_state['values']['form_build_id'])) {

        cache_clear_all('form_' . $form_state['values']['form_build_id'], 'cache_form');

        cache_clear_all('form_state_' . $form_state['values']['form_build_id'], 'cache_form');

      }

      // If batches were set in the submit handlers, we process them now,

      // possibly ending execution. We make sure we do not react to the batch

      // that is already being processed (if a batch operation performs a

      // drupal_form_submit).

      if ($batch =& batch_get() && !isset($batch['current_set'])) {

        // Store $form_state information in the batch definition.

        // We need the full $form_state when either:

        // - Some submit handlers were saved to be called during batch

        //   processing. See form_execute_handlers().

        // - The form is multistep.

        // In other cases, we only need the information expected by

        // drupal_redirect_form().

        if ($batch['has_form_submits'] || !empty($form_state['rebuild'])) {

          $batch['form_state'] = $form_state;

        }

        else {

          $batch['form_state'] = array_intersect_key($form_state, array_flip(array('programmed', 'rebuild', 'storage', 'no_redirect', 'redirect')));

        }

        $batch['progressive'] = !$form_state['programmed'];

        batch_process();

        // Execution continues only for programmatic forms.

        // For 'regular' forms, we get redirected to the batch processing

        // page. Form redirection will be handled in _batch_finished(),

        // after the batch is processed.

      }

      // Set a flag to indicate the the form has been processed and executed.

      $form_state['executed'] = TRUE;

      // Redirect the form based on values in $form_state.

      drupal_redirect_form($form_state);

    }

    // Don't rebuild or cache form submissions invoked via drupal_form_submit().

    if (!empty($form_state['programmed'])) {

      return;

    }

    // If $form_state['rebuild'] has been set and input has been processed

    // without validation errors, we are in a multi-step workflow that is not

    // yet complete. A new $form needs to be constructed based on the changes

    // made to $form_state during this request. Normally, a submit handler sets

    // $form_state['rebuild'] if a fully executed form requires another step.

    // However, for forms that have not been fully executed (e.g., Ajax

    // submissions triggered by non-buttons), there is no submit handler to set

    // $form_state['rebuild']. It would not make sense to redisplay the

    // identical form without an error for the user to correct, so we also

    // rebuild error-free non-executed forms, regardless of

    // $form_state['rebuild'].

    // @todo D8: Simplify this logic; considering Ajax and non-HTML front-ends,

    //   along with element-level #submit properties, it makes no sense to have

    //   divergent form execution based on whether the triggering element has

    //   #executes_submit_callback set to TRUE.

    if (($form_state['rebuild'] || !$form_state['executed']) && !form_get_errors()) {

      // Form building functions (e.g., _form_builder_handle_input_element())

      // may use $form_state['rebuild'] to determine if they are running in the

      // context of a rebuild, so ensure it is set.

      $form_state['rebuild'] = TRUE;

      $form = drupal_rebuild_form($form_id, $form_state, $form);

    }

  }

  // After processing the form, the form builder or a #process callback may

  // have set $form_state['cache'] to indicate that the form and form state

  // shall be cached. But the form may only be cached if the 'no_cache' property

  // is not set to TRUE. Only cache $form as it was prior to form_builder(),

  // because form_builder() must run for each request to accommodate new user

  // input. Rebuilt forms are not cached here, because drupal_rebuild_form()

  // already takes care of that.

  if (!$form_state['rebuild'] && $form_state['cache'] && empty($form_state['no_cache'])) {

    form_set_cache($form['#build_id'], $unprocessed_form, $form_state);

  }

}

/**

 * Prepares a structured form array.

 *

 * Adds required elements, executes any hook_form_alter functions, and

 * optionally inserts a validation token to prevent tampering.

 *

 * @param $form_id

 *   A unique string identifying the form for validation, submission,

 *   theming, and hook_form_alter functions.

 * @param $form

 *   An associative array containing the structure of the form.

 * @param $form_state

 *   A keyed array containing the current state of the form. Passed

 *   in here so that hook_form_alter() calls can use it, as well.

 */

function drupal_prepare_form($form_id, &$form, &$form_state) {

  global $user;

  $form['#type'] = 'form';

  $form_state['programmed'] = isset($form_state['programmed']) ? $form_state['programmed'] : FALSE;

  // Fix the form method, if it is 'get' in $form_state, but not in $form.

  if ($form_state['method'] == 'get' && !isset($form['#method'])) {

    $form['#method'] = 'get';

  }

  // Generate a new #build_id for this form, if none has been set already. The

  // form_build_id is used as key to cache a particular build of the form. For

  // multi-step forms, this allows the user to go back to an earlier build, make

  // changes, and re-submit.

  // @see drupal_build_form()

  // @see drupal_rebuild_form()

  if (!isset($form['#build_id'])) {

    $form['#build_id'] = 'form-' . drupal_random_key();

  }

  $form['form_build_id'] = array(

    '#type' => 'hidden',

    '#value' => $form['#build_id'],

    '#id' => $form['#build_id'],

    '#name' => 'form_build_id',

    // Form processing and validation requires this value, so ensure the

    // submitted form value appears literally, regardless of custom #tree

    // and #parents being set elsewhere.

    '#parents' => array('form_build_id'),

  );

  // Add a token, based on either #token or form_id, to any form displayed to

  // authenticated users. This ensures that any submitted form was actually

  // requested previously by the user and protects against cross site request

  // forgeries.

  // This does not apply to programmatically submitted forms. Furthermore, since

  // tokens are session-bound and forms displayed to anonymous users are very

  // likely cached, we cannot assign a token for them.

  // During installation, there is no $user yet.

  if (!empty($user->uid) && !$form_state['programmed']) {

    // Form constructors may explicitly set #token to FALSE when cross site

    // request forgery is irrelevant to the form, such as search forms.

    if (isset($form['#token']) && $form['#token'] === FALSE) {

      unset($form['#token']);

    }

    // Otherwise, generate a public token based on the form id.

    else {

      $form['#token'] = $form_id;

      $form['form_token'] = array(

        '#id' => drupal_html_id('edit-' . $form_id . '-form-token'),

        '#type' => 'token',

        '#default_value' => drupal_get_token($form['#token']),

        // Form processing and validation requires this value, so ensure the

        // submitted form value appears literally, regardless of custom #tree

        // and #parents being set elsewhere.

        '#parents' => array('form_token'),

      );

    }

  }

  if (isset($form_id)) {

    $form['form_id'] = array(

      '#type' => 'hidden',

      '#value' => $form_id,

      '#id' => drupal_html_id("edit-$form_id"),

      // Form processing and validation requires this value, so ensure the

      // submitted form value appears literally, regardless of custom #tree

      // and #parents being set elsewhere.

      '#parents' => array('form_id'),

    );

  }

  if (!isset($form['#id'])) {

    $form['#id'] = drupal_html_id($form_id);

  }

  $form += element_info('form');

  $form += array('#tree' => FALSE, '#parents' => array());

  if (!isset($form['#validate'])) {

    // Ensure that modules can rely on #validate being set.

    $form['#validate'] = array();

    // Check for a handler specific to $form_id.

    if (function_exists($form_id . '_validate')) {

      $form['#validate'][] = $form_id . '_validate';

    }

    // Otherwise check whether this is a shared form and whether there is a

    // handler for the shared $form_id.

    elseif (isset($form_state['build_info']['base_form_id']) && function_exists($form_state['build_info']['base_form_id'] . '_validate')) {

      $form['#validate'][] = $form_state['build_info']['base_form_id'] . '_validate';

    }

  }

  if (!isset($form['#submit'])) {

    // Ensure that modules can rely on #submit being set.

    $form['#submit'] = array();

    // Check for a handler specific to $form_id.

    if (function_exists($form_id . '_submit')) {

      $form['#submit'][] = $form_id . '_submit';

    }

    // Otherwise check whether this is a shared form and whether there is a

    // handler for the shared $form_id.

    elseif (isset($form_state['build_info']['base_form_id']) && function_exists($form_state['build_info']['base_form_id'] . '_submit')) {

      $form['#submit'][] = $form_state['build_info']['base_form_id'] . '_submit';

    }

  }

  // If no #theme has been set, automatically apply theme suggestions.

  // theme_form() itself is in #theme_wrappers and not #theme. Therefore, the

  // #theme function only has to care for rendering the inner form elements,

  // not the form itself.

  if (!isset($form['#theme'])) {

    $form['#theme'] = array($form_id);

    if (isset($form_state['build_info']['base_form_id'])) {

      $form['#theme'][] = $form_state['build_info']['base_form_id'];

    }

  }

  // Invoke hook_form_alter(), hook_form_BASE_FORM_ID_alter(), and

  // hook_form_FORM_ID_alter() implementations.

  $hooks = array('form');

  if (isset($form_state['build_info']['base_form_id'])) {

    $hooks[] = 'form_' . $form_state['build_info']['base_form_id'];

  }

  $hooks[] = 'form_' . $form_id;

  drupal_alter($hooks, $form, $form_state, $form_id);

}

/**

 * Validates user-submitted form data in the $form_state array.

 *

 * @param $form_id

 *   A unique string identifying the form for validation, submission,

 *   theming, and hook_form_alter functions.

 * @param $form

 *   An associative array containing the structure of the form, which is passed

 *   by reference. Form validation handlers are able to alter the form structure

 *   (like #process and #after_build callbacks during form building) in case of

 *   a validation error. If a validation handler alters the form structure, it

 *   is responsible for validating the values of changed form elements in

 *   $form_state['values'] to prevent form submit handlers from receiving

 *   unvalidated values.

 * @param $form_state

 *   A keyed array containing the current state of the form. The current

 *   user-submitted data is stored in $form_state['values'], though

 *   form validation functions are passed an explicit copy of the

 *   values for the sake of simplicity. Validation handlers can also use

 *   $form_state to pass information on to submit handlers. For example:

 *     $form_state['data_for_submission'] = $data;

 *   This technique is useful when validation requires file parsing,

 *   web service requests, or other expensive requests that should

 *   not be repeated in the submission step.

 */

function drupal_validate_form($form_id, &$form, &$form_state) {

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

  if (isset($validated_forms[$form_id]) && empty($form_state['must_validate'])) {

    return;

  }

  // If the session token was set by drupal_prepare_form(), ensure that it

  // matches the current user's session.

  if (isset($form['#token'])) {

    if (!drupal_valid_token($form_state['values']['form_token'], $form['#token'])) {

      $path = current_path();

      $query = drupal_get_query_parameters();

      $url = url($path, array('query' => $query));

      // Setting this error will cause the form to fail validation.

      form_set_error('form_token', t('The form has become outdated. Copy any unsaved work in the form below and then <a href="@link">reload this page</a>.', array('@link' => $url)));

      // Stop here and don't run any further validation handlers, because they

      // could invoke non-safe operations which opens the door for CSRF

      // vulnerabilities.

      $validated_forms[$form_id] = TRUE;

      return;

    }

  }

  _form_validate($form, $form_state, $form_id);

  $validated_forms[$form_id] = TRUE;

  // If validation errors are limited then remove any non validated form values,

  // so that only values that passed validation are left for submit callbacks.

  if (isset($form_state['triggering_element']['#limit_validation_errors']) && $form_state['triggering_element']['#limit_validation_errors'] !== FALSE) {

    $values = array();

    foreach ($form_state['triggering_element']['#limit_validation_errors'] as $section) {

      // If the section exists within $form_state['values'], even if the value

      // is NULL, copy it to $values.

      $section_exists = NULL;

      $value = drupal_array_get_nested_value($form_state['values'], $section, $section_exists);

      if ($section_exists) {

        drupal_array_set_nested_value($values, $section, $value);

      }

    }

    // A button's #value does not require validation, so for convenience we

    // allow the value of the clicked button to be retained in its normal

    // $form_state['values'] locations, even if these locations are not included

    // in #limit_validation_errors.

    if (isset($form_state['triggering_element']['#button_type'])) {

      $button_value = $form_state['triggering_element']['#value'];

      // Like all input controls, the button value may be in the location

      // dictated by #parents. If it is, copy it to $values, but do not override

      // what may already be in $values.

      $parents = $form_state['triggering_element']['#parents'];

      if (!drupal_array_nested_key_exists($values, $parents) && drupal_array_get_nested_value($form_state['values'], $parents) === $button_value) {

        drupal_array_set_nested_value($values, $parents, $button_value);

      }

      // Additionally, form_builder() places the button value in

      // $form_state['values'][BUTTON_NAME]. If it's still there, after

      // validation handlers have run, copy it to $values, but do not override

      // what may already be in $values.

      $name = $form_state['triggering_element']['#name'];

      if (!isset($values[$name]) && isset($form_state['values'][$name]) && $form_state['values'][$name] === $button_value) {

        $values[$name] = $button_value;

      }

    }

    $form_state['values'] = $values;

  }

}

/**

 * Redirects the user to a URL after a form has been processed.

 *

 * After a form is submitted and processed, normally the user should be

 * redirected to a new destination page. This function figures out what that

 * destination should be, based on the $form_state array and the 'destination'

 * query string in the request URL, and redirects the user there.

 *

 * Usually (for exceptions, see below) $form_state['redirect'] determines where

 * to redirect the user. This can be set either to a string (the path to

 * redirect to), or an array of arguments for drupal_goto(). If

 * $form_state['redirect'] is missing, the user is usually (again, see below for

 * exceptions) redirected back to the page they came from, where they should see

 * a fresh, unpopulated copy of the form.

 *

 * Here is an example of how to set up a form to redirect to the path 'node':

 * @code

 * $form_state['redirect'] = 'node';

 * @endcode

 * And here is an example of how to redirect to 'node/123?foo=bar#baz':

 * @code

 * $form_state['redirect'] = array(

 *   'node/123',

 *   array(

 *     'query' => array(

 *       'foo' => 'bar',

 *     ),

 *     'fragment' => 'baz',

 *   ),

 * );

 * @endcode

 *

 * There are several exceptions to the "usual" behavior described above:

 * - If $form_state['programmed'] is TRUE, the form submission was usually

 *   invoked via drupal_form_submit(), so any redirection would break the script

 *   that invoked drupal_form_submit() and no redirection is done.

 * - If $form_state['rebuild'] is TRUE, the form is being rebuilt, and no

 *   redirection is done.

 * - If $form_state['no_redirect'] is TRUE, redirection is disabled. This is

 *   set, for instance, by ajax_get_form() to prevent redirection in Ajax

 *   callbacks. $form_state['no_redirect'] should never be set or altered by

 *   form builder functions or form validation/submit handlers.

 * - If $form_state['redirect'] is set to FALSE, redirection is disabled.

 * - If none of the above conditions has prevented redirection, then the

 *   redirect is accomplished by calling drupal_goto(), passing in the value of

 *   $form_state['redirect'] if it is set, or the current path if it is

 *   not. drupal_goto() preferentially uses the value of $_GET['destination']

 *   (the 'destination' URL query string) if it is present, so this will

 *   override any values set by $form_state['redirect']. Note that during

 *   installation, install_goto() is called in place of drupal_goto().

 *

 * @param $form_state

 *   An associative array containing the current state of the form.

 *

 * @see drupal_process_form()

 * @see drupal_build_form()

 */

function drupal_redirect_form($form_state) {

  // Skip redirection for form submissions invoked via drupal_form_submit().

  if (!empty($form_state['programmed'])) {

    return;

  }

  // Skip redirection if rebuild is activated.

  if (!empty($form_state['rebuild'])) {

    return;

  }

  // Skip redirection if it was explicitly disallowed.

  if (!empty($form_state['no_redirect'])) {

    return;

  }

  // Only invoke drupal_goto() if redirect value was not set to FALSE.

  if (!isset($form_state['redirect']) || $form_state['redirect'] !== FALSE) {

    if (isset($form_state['redirect'])) {

      if (is_array($form_state['redirect'])) {

        call_user_func_array('drupal_goto', $form_state['redirect']);

      }

      else {

        // This function can be called from the installer, which guarantees

        // that $redirect will always be a string, so catch that case here

        // and use the appropriate redirect function.

        $function = drupal_installation_attempted() ? 'install_goto' : 'drupal_goto';

        $function($form_state['redirect']);

      }

    }

    drupal_goto(current_path(), array('query' => drupal_get_query_parameters()));

  }

}

/**

 * Performs validation on form elements.

 *

 * First ensures required fields are completed, #maxlength is not exceeded, and

 * selected options were in the list of options given to the user. Then calls

 * user-defined validators.

 *

 * @param $elements

 *   An associative array containing the structure of the form.

 * @param $form_state

 *   A keyed array containing the current state of the form. The current

 *   user-submitted data is stored in $form_state['values'], though

 *   form validation functions are passed an explicit copy of the

 *   values for the sake of simplicity. Validation handlers can also

 *   $form_state to pass information on to submit handlers. For example:

 *     $form_state['data_for_submission'] = $data;

 *   This technique is useful when validation requires file parsing,

 *   web service requests, or other expensive requests that should

 *   not be repeated in the submission step.

 * @param $form_id

 *   A unique string identifying the form for validation, submission,

 *   theming, and hook_form_alter functions.

 */

function _form_validate(&$elements, &$form_state, $form_id = NULL) {

  // Also used in the installer, pre-database setup.

  $t = get_t();

  // Recurse through all children.

  foreach (element_children($elements) as $key) {

    if (isset($elements[$key]) && $elements[$key]) {

      _form_validate($elements[$key], $form_state);

    }

  }

  // Validate the current input.

  if (!isset($elements['#validated']) || !$elements['#validated']) {

    // The following errors are always shown.

    if (isset($elements['#needs_validation'])) {

      // Verify that the value is not longer than #maxlength.

      if (isset($elements['#maxlength']) && drupal_strlen($elements['#value']) > $elements['#maxlength']) {

        form_error($elements, $t('!name cannot be longer than %max characters but is currently %length characters long.', array('!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title'], '%max' => $elements['#maxlength'], '%length' => drupal_strlen($elements['#value']))));

      }

      if (isset($elements['#options']) && isset($elements['#value'])) {

        if ($elements['#type'] == 'select') {

          $options = form_options_flatten($elements['#options']);

        }

        else {

          $options = $elements['#options'];

        }

        if (is_array($elements['#value'])) {

          $value = in_array($elements['#type'], array('checkboxes', 'tableselect')) ? array_keys($elements['#value']) : $elements['#value'];

          foreach ($value as $v) {

            if (!isset($options[$v])) {

              form_error($elements, $t('An illegal choice has been detected. Please contact the site administrator.'));

              watchdog('form', 'Illegal choice %choice in !name element.', array('%choice' => $v, '!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);

            }

          }

        }

        // Non-multiple select fields always have a value in HTML. If the user

        // does not change the form, it will be the value of the first option.

        // Because of this, form validation for the field will almost always

        // pass, even if the user did not select anything. To work around this

        // browser behavior, required select fields without a #default_value get

        // an additional, first empty option. In case the submitted value is

        // identical to the empty option's value, we reset the element's value

        // to NULL to trigger the regular #required handling below.

        // @see form_process_select()

        elseif ($elements['#type'] == 'select' && !$elements['#multiple'] && $elements['#required'] && !isset($elements['#default_value']) && $elements['#value'] === $elements['#empty_value']) {

          $elements['#value'] = NULL;

          form_set_value($elements, NULL, $form_state);

        }

        elseif (!isset($options[$elements['#value']])) {

          form_error($elements, $t('An illegal choice has been detected. Please contact the site administrator.'));

          watchdog('form', 'Illegal choice %choice in %name element.', array('%choice' => $elements['#value'], '%name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);

        }

      }

    }

    // While this element is being validated, it may be desired that some calls

    // to form_set_error() be suppressed and not result in a form error, so

    // that a button that implements low-risk functionality (such as "Previous"

    // or "Add more") that doesn't require all user input to be valid can still

    // have its submit handlers triggered. The triggering element's

    // #limit_validation_errors property contains the information for which

    // errors are needed, and all other errors are to be suppressed. The

    // #limit_validation_errors property is ignored if submit handlers will run,

    // but the element doesn't have a #submit property, because it's too large a

    // security risk to have any invalid user input when executing form-level

    // submit handlers.

    if (isset($form_state['triggering_element']['#limit_validation_errors']) && ($form_state['triggering_element']['#limit_validation_errors'] !== FALSE) && !($form_state['submitted'] && !isset($form_state['triggering_element']['#submit']))) {

      form_set_error(NULL, '', $form_state['triggering_element']['#limit_validation_errors']);

    }

    // If submit handlers won't run (due to the submission having been triggered

    // by an element whose #executes_submit_callback property isn't TRUE), then

    // it's safe to suppress all validation errors, and we do so by default,

    // which is particularly useful during an Ajax submission triggered by a

    // non-button. An element can override this default by setting the

    // #limit_validation_errors property. For button element types,

    // #limit_validation_errors defaults to FALSE (via system_element_info()),

    // so that full validation is their default behavior.

    elseif (isset($form_state['triggering_element']) && !isset($form_state['triggering_element']['#limit_validation_errors']) && !$form_state['submitted']) {

      form_set_error(NULL, '', array());

    }

    // As an extra security measure, explicitly turn off error suppression if

    // one of the above conditions wasn't met. Since this is also done at the

    // end of this function, doing it here is only to handle the rare edge case

    // where a validate handler invokes form processing of another form.

    else {

      drupal_static_reset('form_set_error:limit_validation_errors');

    }

    // Make sure a value is passed when the field is required.

    if (isset($elements['#needs_validation']) && $elements['#required']) {

      // A simple call to empty() will not cut it here as some fields, like

      // checkboxes, can return a valid value of '0'. Instead, check the

      // length if it's a string, and the item count if it's an array.

      // An unchecked checkbox has a #value of integer 0, different than string

      // '0', which could be a valid value.

      $is_empty_multiple = (!count($elements['#value']));

      $is_empty_string = (is_string($elements['#value']) && drupal_strlen(trim($elements['#value'])) == 0);

      $is_empty_value = ($elements['#value'] === 0);

      if ($is_empty_multiple || $is_empty_string || $is_empty_value) {

        // Although discouraged, a #title is not mandatory for form elements. In

        // case there is no #title, we cannot set a form error message.

        // Instead of setting no #title, form constructors are encouraged to set

        // #title_display to 'invisible' to improve accessibility.

        if (isset($elements['#title'])) {

          form_error($elements, $t('!name field is required.', array('!name' => $elements['#title'])));

        }

        else {

          form_error($elements);

        }

      }

    }

    // Call user-defined form level validators.

    if (isset($form_id)) {

      form_execute_handlers('validate', $elements, $form_state);

    }

    // Call any element-specific validators. These must act on the element

    // #value data.

    elseif (isset($elements['#element_validate'])) {

      foreach ($elements['#element_validate'] as $function) {

        $function($elements, $form_state, $form_state['complete form']);

      }

    }

    $elements['#validated'] = TRUE;

  }

  // Done validating this element, so turn off error suppression.

  // _form_validate() turns it on again when starting on the next element, if

  // it's still appropriate to do so.

  drupal_static_reset('form_set_error:limit_validation_errors');

}

/**

 * Executes custom validation and submission handlers for a given form.

 *

 * Button-specific handlers are checked first. If none exist, the function

 * falls back to form-level handlers.

 *

 * @param $type

 *   The type of handler to execute. 'validate' or 'submit' are the

 *   defaults used by Form API.

 * @param $form

 *   An associative array containing the structure of the form.

 * @param $form_state

 *   A keyed array containing the current state of the form. If the user

 *   submitted the form by clicking a button with custom handler functions

 *   defined, those handlers will be stored here.

 */

function form_execute_handlers($type, &$form, &$form_state) {

  $return = FALSE;

  // If there was a button pressed, use its handlers.

  if (isset($form_state[$type . '_handlers'])) {

    $handlers = $form_state[$type . '_handlers'];

  }

  // Otherwise, check for a form-level handler.

  elseif (isset($form['#' . $type])) {

    $handlers = $form['#' . $type];

  }

  else {

    $handlers = array();

  }

  foreach ($handlers as $function) {

    // Check if a previous _submit handler has set a batch, but make sure we

    // do not react to a batch that is already being processed (for instance

    // if a batch operation performs a drupal_form_submit()).

    if ($type == 'submit' && ($batch =& batch_get()) && !isset($batch['id'])) {

      // Some previous submit handler has set a batch. To ensure correct

      // execution order, store the call in a special 'control' batch set.

      // See _batch_next_set().

      $batch['sets'][] = array('form_submit' => $function);

      $batch['has_form_submits'] = TRUE;

    }

    else {

      $function($form, $form_state);

    }

    $return = TRUE;

  }

  return $return;

}

/**

 * Files an error against a form element.

 *

 * When a validation error is detected, the validator calls form_set_error() to

 * indicate which element needs to be changed and provide an error message. This

 * causes the Form API to not execute the form submit handlers, and instead to

 * re-display the form to the user with the corresponding elements rendered with

 * an 'error' CSS class (shown as red by default).

 *

 * The standard form_set_error() behavior can be changed if a button provides

 * the #limit_validation_errors property. Multistep forms not wanting to

 * validate the whole form can set #limit_validation_errors on buttons to

 * limit validation errors to only certain elements. For example, pressing the

 * "Previous" button in a multistep form should not fire validation errors just

 * because the current step has invalid values. If #limit_validation_errors is

 * set on a clicked button, the button must also define a #submit property

 * (may be set to an empty array). Any #submit handlers will be executed even if

 * there is invalid input, so extreme care should be taken with respect to any

 * actions taken by them. This is typically not a problem with buttons like

 * "Previous" or "Add more" that do not invoke persistent storage of the

 * submitted form values. Do not use the #limit_validation_errors property on

 * buttons that trigger saving of form values to the database.

 *

 * The #limit_validation_errors property is a list of "sections" within

 * $form_state['values'] that must contain valid values. Each "section" is an

 * array with the ordered set of keys needed to reach that part of

 * $form_state['values'] (i.e., the #parents property of the element).

 *

 * Example 1: Allow the "Previous" button to function, regardless of whether any

 * user input is valid.

 *

 * @code

 *   $form['actions']['previous'] = array(

 *     '#type' => 'submit',

 *     '#value' => t('Previous'),

 *     '#limit_validation_errors' => array(),       // No validation.

 *     '#submit' => array('some_submit_function'),  // #submit required.

 *   );

 * @endcode

 *

 * Example 2: Require some, but not all, user input to be valid to process the

 * submission of a "Previous" button.

 *

 * @code

 *   $form['actions']['previous'] = array(

 *     '#type' => 'submit',

 *     '#value' => t('Previous'),

 *     '#limit_validation_errors' => array(

 *       array('step1'),       // Validate $form_state['values']['step1'].

 *       array('foo', 'bar'),  // Validate $form_state['values']['foo']['bar'].

 *     ),

 *     '#submit' => array('some_submit_function'), // #submit required.

 *   );

 * @endcode

 *

 * This will require $form_state['values']['step1'] and everything within it