/*

   +----------------------------------------------------------------------+

   | Copyright (c) The PHP Group                                          |

   +----------------------------------------------------------------------+

   | This source file is subject to version 3.01 of the PHP license,      |

   | that is bundled with this package in the file LICENSE, and is        |

   | available through the world-wide-web at the following url:           |

   | https://www.php.net/license/3_01.txt                                 |

   | If you did not receive a copy of the PHP license and are unable to   |

   | obtain it through the world-wide-web, please send a note to          |

   | license@php.net so we can mail you a copy immediately.               |

   +----------------------------------------------------------------------+

   | Author: Thies C. Arntzen <thies@thieso.net>                          |

   +----------------------------------------------------------------------+

*/

/* {{{ includes */

#include "php.h"

#include "php_assert.h"

#include "php_ini.h"

#include "zend_exceptions.h"

/* }}} */

ZEND_BEGIN_MODULE_GLOBALS(assert)

  zval callback;

  char *cb;

  bool active;

  bool bail;

  bool warning;

  bool exception;

ZEND_END_MODULE_GLOBALS(assert)

ZEND_DECLARE_MODULE_GLOBALS(assert)

#define ASSERTG(v) ZEND_MODULE_GLOBALS_ACCESSOR(assert, v)

PHPAPI zend_class_entry *assertion_error_ce;

/* Hack to pass a custom stage for the our OnModify handler so that a deprecation warning does not get emitted

 * when an option is modified via assert_option() function */

#define ZEND_INI_STAGE_ASSERT_OPTIONS (1<<6)

static inline bool php_must_emit_ini_deprecation(int stage)

{

  return stage != ZEND_INI_STAGE_DEACTIVATE && stage != ZEND_INI_STAGE_SHUTDOWN && stage != ZEND_INI_STAGE_ASSERT_OPTIONS;

}

static PHP_INI_MH(OnChangeCallback) /* {{{ */

{

  if (EG(current_execute_data)) {

    if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {

      zval_ptr_dtor(&ASSERTG(callback));

      ZVAL_UNDEF(&ASSERTG(callback));

    }

    if (new_value && (Z_TYPE(ASSERTG(callback)) != IS_UNDEF || ZSTR_LEN(new_value))) {

      if (php_must_emit_ini_deprecation(stage)) {

        php_error_docref(NULL, E_DEPRECATED, "assert.callback INI setting is deprecated");

      }

      ZVAL_STR_COPY(&ASSERTG(callback), new_value);

    }

  } else {

    if (ASSERTG(cb)) {

      pefree(ASSERTG(cb), 1);

    }

    if (new_value && ZSTR_LEN(new_value)) {

      if (php_must_emit_ini_deprecation(stage)) {

        php_error_docref(NULL, E_DEPRECATED, "assert.callback INI setting is deprecated");

      }

      ASSERTG(cb) = pemalloc(ZSTR_LEN(new_value) + 1, 1);

      memcpy(ASSERTG(cb), ZSTR_VAL(new_value), ZSTR_LEN(new_value));

      ASSERTG(cb)[ZSTR_LEN(new_value)] = '\0';

    } else {

      ASSERTG(cb) = NULL;

    }

  }

  return SUCCESS;

}

/* }}} */

static PHP_INI_MH(OnUpdateActiveBool)

{

  bool *p = (bool *) ZEND_INI_GET_ADDR();

  *p = zend_ini_parse_bool(new_value);

  if (php_must_emit_ini_deprecation(stage) && !*p) {

    php_error_docref(NULL, E_DEPRECATED, "assert.active INI setting is deprecated");

  }

  return SUCCESS;

}

static PHP_INI_MH(OnUpdateBailBool)

{

  bool *p = (bool *) ZEND_INI_GET_ADDR();

  *p = zend_ini_parse_bool(new_value);

  if (php_must_emit_ini_deprecation(stage) && *p) {

    php_error_docref(NULL, E_DEPRECATED, "assert.bail INI setting is deprecated");

  }

  return SUCCESS;

}

static PHP_INI_MH(OnUpdateExceptionBool)

{

  bool *p = (bool *) ZEND_INI_GET_ADDR();

  *p = zend_ini_parse_bool(new_value);

  if (php_must_emit_ini_deprecation(stage) && !*p) {

    php_error_docref(NULL, E_DEPRECATED, "assert.exception INI setting is deprecated");

  }

  return SUCCESS;

}

static PHP_INI_MH(OnUpdateWarningBool)

{

  bool *p = (bool *) ZEND_INI_GET_ADDR();

  *p = zend_ini_parse_bool(new_value);

  if (php_must_emit_ini_deprecation(stage) && !*p) {

    php_error_docref(NULL, E_DEPRECATED, "assert.warning INI setting is deprecated");

  }

  return SUCCESS;

}

PHP_INI_BEGIN()

   STD_PHP_INI_BOOLEAN("assert.active",    "1",  PHP_INI_ALL, OnUpdateActiveBool,   active,       zend_assert_globals,    assert_globals)

   STD_PHP_INI_BOOLEAN("assert.bail",      "0",  PHP_INI_ALL, OnUpdateBailBool,   bail,       zend_assert_globals,    assert_globals)

   STD_PHP_INI_BOOLEAN("assert.warning",   "1",  PHP_INI_ALL, OnUpdateWarningBool,    warning,      zend_assert_globals,    assert_globals)

   PHP_INI_ENTRY("assert.callback",        NULL, PHP_INI_ALL, OnChangeCallback)

   STD_PHP_INI_BOOLEAN("assert.exception", "1",  PHP_INI_ALL, OnUpdateExceptionBool,    exception,      zend_assert_globals,    assert_globals)

PHP_INI_END()

static void php_assert_init_globals(zend_assert_globals *assert_globals_p) /* {{{ */

{

  ZVAL_UNDEF(&assert_globals_p->callback);

  assert_globals_p->cb = NULL;

}

/* }}} */

PHP_MINIT_FUNCTION(assert) /* {{{ */

{

  ZEND_INIT_MODULE_GLOBALS(assert, php_assert_init_globals, NULL);

  REGISTER_INI_ENTRIES();

  return SUCCESS;

}

/* }}} */

PHP_MSHUTDOWN_FUNCTION(assert) /* {{{ */

{

  if (ASSERTG(cb)) {

    pefree(ASSERTG(cb), 1);

    ASSERTG(cb) = NULL;

  }

  return SUCCESS;

}

/* }}} */

PHP_RSHUTDOWN_FUNCTION(assert) /* {{{ */

{

  if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {

    zval_ptr_dtor(&ASSERTG(callback));

    ZVAL_UNDEF(&ASSERTG(callback));

  }

  return SUCCESS;

}

/* }}} */

PHP_MINFO_FUNCTION(assert) /* {{{ */

{

  DISPLAY_INI_ENTRIES();

}

/* }}} */

/* {{{ Checks if assertion is false */

PHP_FUNCTION(assert)

{

  zval *assertion;

  zend_string *description_str = NULL;

  zend_object *description_obj = NULL;

  /* EG(assertions) <= 0 is only reachable by dynamic calls to assert(),

   * since calls known at compile time will skip the entire call when

   * assertions are disabled.

   */

  if (!ASSERTG(active) || EG(assertions) <= 0) {

    RETURN_TRUE;

  }

  ZEND_PARSE_PARAMETERS_START(1, 2)

    Z_PARAM_ZVAL(assertion)

    Z_PARAM_OPTIONAL

    Z_PARAM_OBJ_OF_CLASS_OR_STR_OR_NULL(description_obj, zend_ce_throwable, description_str)

  ZEND_PARSE_PARAMETERS_END();

  if (zend_is_true(assertion)) {

    RETURN_TRUE;

  }

  if (description_obj) {

    GC_ADDREF(description_obj);

    zend_throw_exception_internal(description_obj);

    RETURN_THROWS();

  }

  if (Z_TYPE(ASSERTG(callback)) == IS_UNDEF && ASSERTG(cb)) {

    ZVAL_STRING(&ASSERTG(callback), ASSERTG(cb));

  }

  if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {

    zval args[4];

    zval retval;

    uint32_t lineno = zend_get_executed_lineno();

    zend_string *filename = zend_get_executed_filename_ex();

    if (UNEXPECTED(!filename)) {

      filename = ZSTR_KNOWN(ZEND_STR_UNKNOWN_CAPITALIZED);

    }

    ZVAL_STR(&args[0], filename);

    ZVAL_LONG(&args[1], lineno);

    ZVAL_NULL(&args[2]);

    ZVAL_FALSE(&retval);

    if (description_str) {

      ZVAL_STR(&args[3], description_str);

      call_user_function(NULL, NULL, &ASSERTG(callback), &retval, 4, args);

    } else {

      call_user_function(NULL, NULL, &ASSERTG(callback), &retval, 3, args);

    }

    zval_ptr_dtor(&retval);

  }

  if (ASSERTG(exception)) {

    zend_throw_exception(assertion_error_ce, description_str ? ZSTR_VAL(description_str) : NULL, E_ERROR);

    if (ASSERTG(bail)) {

      /* When bail is turned on, the exception will not be caught. */

      zend_exception_error(EG(exception), E_ERROR);

    }

  } else if (ASSERTG(warning)) {

    php_error_docref(NULL, E_WARNING, "%s failed", description_str ? ZSTR_VAL(description_str) : "Assertion");

  }

  if (ASSERTG(bail)) {

    if (EG(exception)) {

      /* The callback might have thrown. Use E_WARNING to print the

       * exception so we can avoid bailout and use unwind_exit. */

      zend_exception_error(EG(exception), E_WARNING);

    }

    zend_throw_unwind_exit();

    RETURN_THROWS();

  } else {

    RETURN_FALSE;

  }

}

/* }}} */

/* {{{ Set/get the various assert flags */

PHP_FUNCTION(assert_options)

{

  zval *value = NULL;

  zend_long what;

  bool oldint;

  uint32_t ac = ZEND_NUM_ARGS();

  zend_string *key;

  ZEND_PARSE_PARAMETERS_START(1, 2)

    Z_PARAM_LONG(what)

    Z_PARAM_OPTIONAL

    Z_PARAM_ZVAL(value)

  ZEND_PARSE_PARAMETERS_END();

  switch (what) {

  case PHP_ASSERT_ACTIVE:

    oldint = ASSERTG(active);

    if (ac == 2) {

      zend_string *value_str = zval_try_get_string(value);

      if (UNEXPECTED(!value_str)) {

        RETURN_THROWS();

      }

      key = ZSTR_INIT_LITERAL("assert.active", 0);

      zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, ZEND_INI_STAGE_ASSERT_OPTIONS, 0);

      zend_string_release_ex(key, 0);

      zend_string_release_ex(value_str, 0);

    }

    RETURN_LONG(oldint);

    break;

  case PHP_ASSERT_BAIL:

    oldint = ASSERTG(bail);

    if (ac == 2) {

      zend_string *value_str = zval_try_get_string(value);

      if (UNEXPECTED(!value_str)) {

        RETURN_THROWS();

      }

      key = ZSTR_INIT_LITERAL("assert.bail", 0);

      zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, ZEND_INI_STAGE_ASSERT_OPTIONS, 0);

      zend_string_release_ex(key, 0);

      zend_string_release_ex(value_str, 0);

    }

    RETURN_LONG(oldint);

    break;

  case PHP_ASSERT_WARNING:

    oldint = ASSERTG(warning);

    if (ac == 2) {

      zend_string *value_str = zval_try_get_string(value);

      if (UNEXPECTED(!value_str)) {

        RETURN_THROWS();

      }

      key = ZSTR_INIT_LITERAL("assert.warning", 0);

      zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, ZEND_INI_STAGE_ASSERT_OPTIONS, 0);

      zend_string_release_ex(key, 0);

      zend_string_release_ex(value_str, 0);

    }

    RETURN_LONG(oldint);

    break;

  case PHP_ASSERT_CALLBACK:

    if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {

      ZVAL_COPY(return_value, &ASSERTG(callback));

    } else if (ASSERTG(cb)) {

      RETVAL_STRING(ASSERTG(cb));

    } else {

      RETVAL_NULL();

    }

    if (ac == 2) {

      zval_ptr_dtor(&ASSERTG(callback));

      if (Z_TYPE_P(value) == IS_NULL) {

        ZVAL_UNDEF(&ASSERTG(callback));

      } else {

        ZVAL_COPY(&ASSERTG(callback), value);

      }

    }

    return;

  case PHP_ASSERT_EXCEPTION:

    oldint = ASSERTG(exception);

    if (ac == 2) {

      zend_string *val = zval_try_get_string(value);

      if (UNEXPECTED(!val)) {

        RETURN_THROWS();

      }

      key = ZSTR_INIT_LITERAL("assert.exception", 0);

      zend_alter_ini_entry_ex(key, val, PHP_INI_USER, ZEND_INI_STAGE_ASSERT_OPTIONS, 0);

      zend_string_release_ex(val, 0);

      zend_string_release_ex(key, 0);

    }

    RETURN_LONG(oldint);

    break;

  default:

    zend_argument_value_error(1, "must be an ASSERT_* constant");

    RETURN_THROWS();

  }

}

/* }}} */