diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index a168069cfb623..c123988d987ac 100644
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -2549,6 +2549,19 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_is_callable, 0, 0, 1)
 	ZEND_ARG_INFO(0, syntax_only)
 	ZEND_ARG_INFO(1, callable_name)
 ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_to_int, 0, 0, 1)
+	ZEND_ARG_INFO(0, from)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_to_float, 0, 0, 1)
+	ZEND_ARG_INFO(0, from)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_to_string, 0, 0, 1)
+	ZEND_ARG_INFO(0, from)
+ZEND_END_ARG_INFO()
+
 /* }}} */
 /* {{{ uniqid.c */
 #ifdef HAVE_GETTIMEOFDAY
@@ -3043,6 +3056,14 @@ const zend_function_entry basic_functions[] = { /* {{{ */
 	PHP_FE(is_scalar,														arginfo_is_scalar)
 	PHP_FE(is_callable,														arginfo_is_callable)
 
+	PHP_FE(to_int,															arginfo_to_int)
+	PHP_FE(try_int,															arginfo_to_int)
+	PHP_FE(to_float,														arginfo_to_float)
+	PHP_FE(try_float,														arginfo_to_float)
+	PHP_FE(to_string,														arginfo_to_string)
+	PHP_FE(try_string,														arginfo_to_string)
+
+
 	/* functions from file.c */
 	PHP_FE(pclose,															arginfo_pclose)
 	PHP_FE(popen,															arginfo_popen)
@@ -3612,6 +3633,7 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */
 	BASIC_MINIT_SUBMODULE(standard_filters)
 	BASIC_MINIT_SUBMODULE(user_filters)
 	BASIC_MINIT_SUBMODULE(password)
+	BASIC_MINIT_SUBMODULE(type)
 
 #if defined(HAVE_LOCALECONV) && defined(ZTS)
 	BASIC_MINIT_SUBMODULE(localeconv)
diff --git a/ext/standard/php_type.h b/ext/standard/php_type.h
index e6d8152b1be7d..acb809eebb0af 100644
--- a/ext/standard/php_type.h
+++ b/ext/standard/php_type.h
@@ -21,6 +21,8 @@
 #ifndef PHP_TYPE_H
 #define PHP_TYPE_H
 
+extern PHPAPI zend_class_entry *php_CastException_ce; 
+
 PHP_FUNCTION(intval);
 PHP_FUNCTION(floatval);
 PHP_FUNCTION(strval);
@@ -38,5 +40,11 @@ PHP_FUNCTION(is_array);
 PHP_FUNCTION(is_object);
 PHP_FUNCTION(is_scalar);
 PHP_FUNCTION(is_callable);
+PHP_FUNCTION(to_int);
+PHP_FUNCTION(try_int);
+PHP_FUNCTION(to_float);
+PHP_FUNCTION(try_float);
+PHP_FUNCTION(to_string);
+PHP_FUNCTION(try_string);
 
 #endif
diff --git a/ext/standard/tests/type/to_float.phpt b/ext/standard/tests/type/to_float.phpt
new file mode 100644
index 0000000000000..d39b66ff26c46
--- /dev/null
+++ b/ext/standard/tests/type/to_float.phpt
@@ -0,0 +1,121 @@
+--TEST--
+to_float()
+--FILE--
+<?php
+
+function to_float_wrapper($value) {
+    try {
+        return to_float($value);
+    } catch (CastException $e) {
+        return NULL;
+    }
+}
+
+// should pass
+var_dump(to_float_wrapper("0"));
+var_dump(to_float_wrapper(0));
+var_dump(to_float_wrapper(0.0));
+var_dump(to_float_wrapper("10"));
+var_dump(to_float_wrapper("+10"));
+var_dump(to_float_wrapper("-10"));
+var_dump(to_float_wrapper("10.0"));
+var_dump(to_float_wrapper(10));
+var_dump(to_float_wrapper(10.0));
+var_dump(to_float_wrapper((string)PHP_INT_MAX));
+var_dump(to_float_wrapper(PHP_INT_MAX));
+var_dump(to_float_wrapper((float)PHP_INT_MAX));
+var_dump(to_float_wrapper((string)PHP_INT_MIN));
+var_dump(to_float_wrapper(PHP_INT_MIN));
+var_dump(to_float_wrapper((float)PHP_INT_MIN));
+
+echo PHP_EOL;
+
+// disallowed types
+var_dump(to_float_wrapper(""));
+var_dump(to_float_wrapper("0x10"));
+var_dump(to_float_wrapper(NULL));
+var_dump(to_float_wrapper(TRUE));
+var_dump(to_float_wrapper(FALSE));
+var_dump(to_float_wrapper(new StdClass));
+var_dump(to_float_wrapper(fopen("data:text/html,foobar", "r")));
+var_dump(to_float_wrapper([]));
+
+echo PHP_EOL;
+
+var_dump(to_float_wrapper(1.5));
+var_dump(to_float_wrapper("1.5"));
+
+echo PHP_EOL;
+
+// reject leading, trailing chars
+var_dump(to_float_wrapper("010"));
+var_dump(to_float_wrapper("10abc"));
+var_dump(to_float_wrapper("abc10"));
+var_dump(to_float_wrapper("   100    "));
+var_dump(to_float_wrapper("\n\t\v\r\f   78 \n \t\v\r\f   \n"));
+var_dump(to_float_wrapper("\n\t\v\r\f78"));
+var_dump(to_float_wrapper("78\n\t\v\r\f"));
+
+echo PHP_EOL;
+
+// overflow/nan/inf
+var_dump(to_float_wrapper(INF));
+var_dump(to_float_wrapper(-INF));
+var_dump(to_float_wrapper(NAN));
+var_dump(to_float_wrapper(PHP_INT_MAX * 2));
+var_dump(to_float_wrapper(PHP_INT_MIN * 2));
+var_dump(to_float_wrapper((string)(PHP_INT_MAX * 2)));
+var_dump(to_float_wrapper((string)(PHP_INT_MIN * 2)));
+
+echo PHP_EOL;
+
+// check exponents work
+var_dump(to_float_wrapper("75e-5"));
+var_dump(to_float_wrapper("31e+7"));
+--EXPECTF--
+float(0)
+float(0)
+float(0)
+float(10)
+float(10)
+float(-10)
+float(10)
+float(10)
+float(10)
+float(%s)
+float(%s)
+float(%s)
+float(-%s)
+float(-%s)
+float(%s)
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+float(1.5)
+float(1.5)
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+float(INF)
+float(-INF)
+float(NAN)
+float(%s)
+float(%s)
+float(%s)
+float(%s)
+
+float(0.00075)
+float(310000000)
diff --git a/ext/standard/tests/type/to_int.phpt b/ext/standard/tests/type/to_int.phpt
new file mode 100644
index 0000000000000..4b608b6ddc451
--- /dev/null
+++ b/ext/standard/tests/type/to_int.phpt
@@ -0,0 +1,118 @@
+--TEST--
+to_int()
+--FILE--
+<?php
+
+function to_int_wrapper($value) {
+    try {
+        return to_int($value);
+    } catch (CastException $e) {
+        return NULL;
+    }
+}
+
+// should pass
+var_dump(to_int_wrapper("0"));
+var_dump(to_int_wrapper(0));
+var_dump(to_int_wrapper(0.0));
+var_dump(to_int_wrapper("10"));
+var_dump(to_int_wrapper("+10"));
+var_dump(to_int_wrapper("-10"));
+var_dump(to_int_wrapper(10));
+var_dump(to_int_wrapper(10.0));
+var_dump(to_int_wrapper((string)PHP_INT_MAX));
+var_dump(to_int_wrapper(PHP_INT_MAX));
+var_dump(to_int_wrapper((string)PHP_INT_MIN));
+var_dump(to_int_wrapper(PHP_INT_MIN));
+
+echo PHP_EOL;
+
+// shouldn't pass
+var_dump(to_int_wrapper(""));
+var_dump(to_int_wrapper("10.0"));
+var_dump(to_int_wrapper("75e-5"));
+var_dump(to_int_wrapper("31e+7"));
+var_dump(to_int_wrapper("0x10"));
+
+echo PHP_EOL;
+
+// disallowed types
+var_dump(to_int_wrapper(NULL));
+var_dump(to_int_wrapper(TRUE));
+var_dump(to_int_wrapper(FALSE));
+var_dump(to_int_wrapper(new StdClass));
+var_dump(to_int_wrapper(fopen("data:text/html,foobar", "r")));
+var_dump(to_int_wrapper([]));
+
+echo PHP_EOL;
+
+// check truncation
+var_dump(to_int_wrapper(1.5));
+var_dump(to_int_wrapper("1.5"));
+
+echo PHP_EOL;
+
+// reject leading, trailing chars
+var_dump(to_int_wrapper("010"));
+var_dump(to_int_wrapper("10abc"));
+var_dump(to_int_wrapper("abc10"));
+var_dump(to_int_wrapper("   100    "));
+var_dump(to_int_wrapper("\n\t\v\r\f   78 \n \t\v\r\f   \n"));
+var_dump(to_int_wrapper("\n\t\v\r\f78"));
+var_dump(to_int_wrapper("78\n\t\v\r\f"));
+
+echo PHP_EOL;
+
+// overflow/nan/inf
+var_dump(to_int_wrapper(INF));
+var_dump(to_int_wrapper(-INF));
+var_dump(to_int_wrapper(NAN));
+var_dump(to_int_wrapper(PHP_INT_MAX * 2));
+var_dump(to_int_wrapper(PHP_INT_MIN * 2));
+var_dump(to_int_wrapper((string)(PHP_INT_MAX * 2)));
+var_dump(to_int_wrapper((string)(PHP_INT_MIN * 2)));
+--EXPECTF--
+int(0)
+int(0)
+int(0)
+int(10)
+int(10)
+int(-10)
+int(10)
+int(10)
+int(%d)
+int(%d)
+int(-%d)
+int(-%d)
+
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
diff --git a/ext/standard/tests/type/to_string.phpt b/ext/standard/tests/type/to_string.phpt
new file mode 100644
index 0000000000000..10e4b35c9c991
--- /dev/null
+++ b/ext/standard/tests/type/to_string.phpt
@@ -0,0 +1,63 @@
+--TEST--
+to_string()
+--FILE--
+<?php
+
+function to_string_wrapper($value) {
+    try {
+        return to_string($value);
+    } catch (CastException $e) {
+        return NULL;
+    }
+}
+
+// valid
+var_dump(to_string_wrapper("foobar"));
+var_dump(to_string_wrapper(123));
+var_dump(to_string_wrapper(123.45));
+var_dump(to_string_wrapper(INF));
+var_dump(to_string_wrapper(-INF));
+var_dump(to_string_wrapper(NAN));
+var_dump(to_string_wrapper(""));
+
+echo PHP_EOL;
+
+// invalid
+var_dump(to_string_wrapper(NULL));
+var_dump(to_string_wrapper(TRUE));
+var_dump(to_string_wrapper(FALSE));
+var_dump(to_string_wrapper([]));
+var_dump(to_string_wrapper(fopen('data:text/plan,foobar', 'r')));
+
+echo PHP_EOL;
+
+class NotStringable {}
+class Stringable {
+	public function __toString() {
+		return "foobar";
+	}
+}
+
+// objects
+var_dump(to_string_wrapper(new StdClass));
+var_dump(to_string_wrapper(new NotStringable));
+var_dump(to_string_wrapper(new Stringable));
+
+--EXPECT--
+string(6) "foobar"
+string(3) "123"
+string(6) "123.45"
+string(3) "INF"
+string(4) "-INF"
+string(3) "NAN"
+string(0) ""
+
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+string(6) "foobar"
diff --git a/ext/standard/tests/type/try_float.phpt b/ext/standard/tests/type/try_float.phpt
new file mode 100644
index 0000000000000..9d625717ca273
--- /dev/null
+++ b/ext/standard/tests/type/try_float.phpt
@@ -0,0 +1,113 @@
+--TEST--
+try_float()
+--FILE--
+<?php
+
+// should pass
+var_dump(try_float("0"));
+var_dump(try_float(0));
+var_dump(try_float(0.0));
+var_dump(try_float("10"));
+var_dump(try_float("+10"));
+var_dump(try_float("-10"));
+var_dump(try_float("10.0"));
+var_dump(try_float(10));
+var_dump(try_float(10.0));
+var_dump(try_float((string)PHP_INT_MAX));
+var_dump(try_float(PHP_INT_MAX));
+var_dump(try_float((float)PHP_INT_MAX));
+var_dump(try_float((string)PHP_INT_MIN));
+var_dump(try_float(PHP_INT_MIN));
+var_dump(try_float((float)PHP_INT_MIN));
+
+echo PHP_EOL;
+
+// disallowed types
+var_dump(try_float(""));
+var_dump(try_float("0x10"));
+var_dump(try_float(NULL));
+var_dump(try_float(TRUE));
+var_dump(try_float(FALSE));
+var_dump(try_float(new StdClass));
+var_dump(try_float(fopen("data:text/html,foobar", "r")));
+var_dump(try_float([]));
+
+echo PHP_EOL;
+
+var_dump(try_float(1.5));
+var_dump(try_float("1.5"));
+
+echo PHP_EOL;
+
+// reject leading, trailing chars
+var_dump(try_float("010"));
+var_dump(try_float("10abc"));
+var_dump(try_float("abc10"));
+var_dump(try_float("   100    "));
+var_dump(try_float("\n\t\v\r\f   78 \n \t\v\r\f   \n"));
+var_dump(try_float("\n\t\v\r\f78"));
+var_dump(try_float("78\n\t\v\r\f"));
+
+echo PHP_EOL;
+
+// overflow/nan/inf
+var_dump(try_float(INF));
+var_dump(try_float(-INF));
+var_dump(try_float(NAN));
+var_dump(try_float(PHP_INT_MAX * 2));
+var_dump(try_float(PHP_INT_MIN * 2));
+var_dump(try_float((string)(PHP_INT_MAX * 2)));
+var_dump(try_float((string)(PHP_INT_MIN * 2)));
+
+echo PHP_EOL;
+
+// check exponents work
+var_dump(try_float("75e-5"));
+var_dump(try_float("31e+7"));
+--EXPECTF--
+float(0)
+float(0)
+float(0)
+float(10)
+float(10)
+float(-10)
+float(10)
+float(10)
+float(10)
+float(%s)
+float(%s)
+float(%s)
+float(-%s)
+float(-%s)
+float(%s)
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+float(1.5)
+float(1.5)
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+float(INF)
+float(-INF)
+float(NAN)
+float(%s)
+float(%s)
+float(%s)
+float(%s)
+
+float(0.00075)
+float(310000000)
diff --git a/ext/standard/tests/type/try_int.phpt b/ext/standard/tests/type/try_int.phpt
new file mode 100644
index 0000000000000..fcc7ca2faa898
--- /dev/null
+++ b/ext/standard/tests/type/try_int.phpt
@@ -0,0 +1,110 @@
+--TEST--
+try_int()
+--FILE--
+<?php
+
+// should pass
+var_dump(try_int("0"));
+var_dump(try_int(0));
+var_dump(try_int(0.0));
+var_dump(try_int("10"));
+var_dump(try_int("+10"));
+var_dump(try_int("-10"));
+var_dump(try_int(10));
+var_dump(try_int(10.0));
+var_dump(try_int((string)PHP_INT_MAX));
+var_dump(try_int(PHP_INT_MAX));
+var_dump(try_int((string)PHP_INT_MIN));
+var_dump(try_int(PHP_INT_MIN));
+
+echo PHP_EOL;
+
+// shouldn't pass
+var_dump(try_int(""));
+var_dump(try_int("10.0"));
+var_dump(try_int("75e-5"));
+var_dump(try_int("31e+7"));
+var_dump(try_int("0x10"));
+
+echo PHP_EOL;
+
+// disallowed types
+var_dump(try_int(NULL));
+var_dump(try_int(TRUE));
+var_dump(try_int(FALSE));
+var_dump(try_int(new StdClass));
+var_dump(try_int(fopen("data:text/html,foobar", "r")));
+var_dump(try_int([]));
+
+echo PHP_EOL;
+
+// check truncation
+var_dump(try_int(1.5));
+var_dump(try_int("1.5"));
+
+echo PHP_EOL;
+
+// reject leading, trailing chars
+var_dump(try_int("010"));
+var_dump(try_int("10abc"));
+var_dump(try_int("abc10"));
+var_dump(try_int("   100    "));
+var_dump(try_int("\n\t\v\r\f   78 \n \t\v\r\f   \n"));
+var_dump(try_int("\n\t\v\r\f78"));
+var_dump(try_int("78\n\t\v\r\f"));
+
+echo PHP_EOL;
+
+// overflow/nan/inf
+var_dump(try_int(INF));
+var_dump(try_int(-INF));
+var_dump(try_int(NAN));
+var_dump(try_int(PHP_INT_MAX * 2));
+var_dump(try_int(PHP_INT_MIN * 2));
+var_dump(try_int((string)(PHP_INT_MAX * 2)));
+var_dump(try_int((string)(PHP_INT_MIN * 2)));
+--EXPECTF--
+int(0)
+int(0)
+int(0)
+int(10)
+int(10)
+int(-10)
+int(10)
+int(10)
+int(%d)
+int(%d)
+int(-%d)
+int(-%d)
+
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
diff --git a/ext/standard/tests/type/try_string.phpt b/ext/standard/tests/type/try_string.phpt
new file mode 100644
index 0000000000000..aeab941b6b42f
--- /dev/null
+++ b/ext/standard/tests/type/try_string.phpt
@@ -0,0 +1,55 @@
+--TEST--
+try_string()
+--FILE--
+<?php
+
+// valid
+var_dump(try_string("foobar"));
+var_dump(try_string(123));
+var_dump(try_string(123.45));
+var_dump(try_string(INF));
+var_dump(try_string(-INF));
+var_dump(try_string(NAN));
+var_dump(try_string(""));
+
+echo PHP_EOL;
+
+// invalid
+var_dump(try_string(NULL));
+var_dump(try_string(TRUE));
+var_dump(try_string(FALSE));
+var_dump(try_string([]));
+var_dump(try_string(fopen('data:text/plan,foobar', 'r')));
+
+echo PHP_EOL;
+
+class NotStringable {}
+class Stringable {
+	public function __toString() {
+		return "foobar";
+	}
+}
+
+// objects
+var_dump(try_string(new StdClass));
+var_dump(try_string(new NotStringable));
+var_dump(try_string(new Stringable));
+
+--EXPECT--
+string(6) "foobar"
+string(3) "123"
+string(6) "123.45"
+string(3) "INF"
+string(4) "-INF"
+string(3) "NAN"
+string(0) ""
+
+NULL
+NULL
+NULL
+NULL
+NULL
+
+NULL
+NULL
+string(6) "foobar"
diff --git a/ext/standard/type.c b/ext/standard/type.c
index a773e6c53cb27..ef607a593f1e3 100644
--- a/ext/standard/type.c
+++ b/ext/standard/type.c
@@ -20,6 +20,18 @@
 
 #include "php.h"
 #include "php_incomplete_class.h"
+#include "zend_operators.h"
+#include "ext/spl/spl_exceptions.h"
+
+PHPAPI zend_class_entry *php_CastException_ce;
+
+PHP_MINIT_FUNCTION(type) /* {{{ */
+{
+	zend_class_entry ce;
+
+	INIT_CLASS_ENTRY_EX(ce, "CastException", sizeof("CastException") - 1, NULL);
+	php_CastException_ce = zend_register_internal_class_ex(&ce, spl_ce_RuntimeException TSRMLS_CC);
+}
 
 /* {{{ proto string gettype(mixed var)
    Returns the type of the variable */
@@ -420,6 +432,246 @@ PHP_FUNCTION(is_callable)
 }
 /* }}} */
 
+/* {{{ */
+static zend_always_inline zend_bool safe_cast_to_int(zval *var, zval *out)
+{
+	switch (Z_TYPE_P(var)) {
+		case IS_STRING:
+			{
+				zend_long lval;
+				char c = Z_STRVAL_P(var)[0], *endptr;
+				
+				/* special-case zero */
+				if (c == '0' && Z_STRLEN_P(var) == 1) {
+					ZVAL_LONG(out, 0);
+					return 1;
+				}
+
+				/* bans leading whitespace, empty string */
+				if (!('1' <= c && c <= '9') && c != '-' && c != '+') {
+					return 0;
+				}
+
+				errno = 0;
+				lval = ZEND_STRTOL(Z_STRVAL_P(var), &endptr, 10);
+				
+				if (errno) {
+					return 0;
+				}
+				
+				/* ban trailing chars */
+				if (endptr - Z_STRVAL_P(var) != Z_STRLEN_P(var)) {
+					return 0;
+				}
+
+				ZVAL_LONG(out, lval);
+				return 1;
+			}
+
+		case IS_DOUBLE:
+			if (Z_DVAL_P(var) == (double)(zend_long) Z_DVAL_P(var)) {
+				/* Exactly representable as zend_long
+				 * We don't need to use zend_dval_to_lval here, cast is safe
+				 */
+				ZVAL_LONG(out, (zend_long)Z_DVAL_P(var));
+				return 1;
+			} else {
+				return 0;
+			}
+
+		case IS_LONG:
+			ZVAL_LONG(out, Z_LVAL_P(var));
+			return 1;
+
+		default:
+			return 0;
+	}
+}
+/* }}} */
+
+/* {{{ proto int to_int(mixed from)
+   Strictly convert the given value to an integer, throwing an exception on failure. */
+PHP_FUNCTION(to_int)
+{
+	zval *var;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+		RETURN_NULL();
+	}
+
+	if (!safe_cast_to_int(var, return_value)) {
+		zend_throw_exception(php_CastException_ce, "Value could not be converted to int", 0 TSRMLS_CC);
+	}
+}
+/* }}} */
+
+/* {{{ proto int try_int(mixed from)
+   Strictly convert the given value to an integer, returning NULL on failure. */
+PHP_FUNCTION(try_int)
+{
+	zval *var;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+		RETURN_NULL();
+	}
+
+	if (!safe_cast_to_int(var, return_value)) {
+		RETURN_NULL();
+	}
+}
+/* }}} */
+
+/* {{{ */
+static zend_always_inline zend_bool safe_cast_to_float(zval *var, zval *out)
+{
+	switch (Z_TYPE_P(var)) {
+		case IS_STRING:
+			{
+				double dval;
+				char c = Z_STRVAL_P(var)[0], *endptr;
+
+				/* special-case zero */
+				if (c == '0' && Z_STRLEN_P(var) == 1) {
+					ZVAL_DOUBLE(out, 0);
+					return 1;
+				}
+
+				/* bans leading whitespace, + sign, empty string */
+				if (!('1' <= c && c <= '9') && c != '-' && c != '+') {
+					return 0;
+				}
+
+				dval = zend_strtod(Z_STRVAL_P(var), &endptr);
+				
+				/* ban trailing chars */
+				if (endptr - Z_STRVAL_P(var) != Z_STRLEN_P(var)) {
+					return 0;
+				}
+
+				ZVAL_DOUBLE(out, dval);
+				return 1;
+			}	
+
+		case IS_LONG:
+			ZVAL_DOUBLE(out, (double)Z_LVAL_P(var));
+			return 1;
+
+		case IS_DOUBLE:
+			ZVAL_DOUBLE(out, Z_DVAL_P(var));
+			return 1;
+
+		default:
+			return 0;
+	}
+}
+/* }}} */
+
+/* {{{ proto float to_float(mixed from)
+   Strictly convert the given value to a float, throwing an exception on failure. */
+PHP_FUNCTION(to_float)
+{
+	zval *var;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+		RETURN_NULL();
+	}
+
+	if (!safe_cast_to_float(var, return_value)) {
+		zend_throw_exception(php_CastException_ce, "Value could not be converted to float", 0 TSRMLS_CC);
+	}
+}
+/* }}} */
+
+/* {{{ proto float try_float(mixed from) 
+   Strictly convert the given value to a float, returning NULL on failure. */
+PHP_FUNCTION(try_float)
+{
+	zval *var;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+		RETURN_NULL();
+	}
+	
+	if (!safe_cast_to_float(var, return_value)) {
+		RETURN_NULL();
+	}
+}
+/* }}} */
+
+/* {{{ */
+static zend_always_inline zend_bool safe_cast_to_string(zval *var, zval *out TSRMLS_DC)
+{
+	switch (Z_TYPE_P(var)) {
+		case IS_STRING:
+			ZVAL_STR(out, zend_string_copy(Z_STR_P(var)));
+			return 1;
+		
+		case IS_LONG:
+			ZVAL_STR(out, zend_long_to_str(Z_LVAL_P(var)));
+			return 1;
+
+		case IS_DOUBLE:
+			ZVAL_STR(out, strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(var)));
+			return 1;
+
+		case IS_OBJECT:
+			{
+				ZVAL_UNDEF(out);
+				if (Z_OBJ_HT_P(var)->cast_object) {
+					if (Z_OBJ_HT_P(var)->cast_object(var, out, IS_STRING TSRMLS_CC) == SUCCESS) {
+						return 1;
+					}
+				} else if (Z_OBJ_HT_P(var)->get) {
+					zval *newop = Z_OBJ_HT_P(var)->get(var, out TSRMLS_CC);
+					if (Z_TYPE_P(newop) != IS_OBJECT) {
+						/* for safety - avoid loop */
+						ZVAL_COPY_VALUE(out, newop);
+						convert_to_string(out);
+
+						return 1;
+					}
+				}
+			}
+			return 0;
+
+		default:
+			return 0;
+	}
+}
+
+/* {{{ proto string to_string(mixed from)
+   Strictly convert the given value to a string, throwing an exception on failure. */
+PHP_FUNCTION(to_string)
+{
+	zval *var;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+		RETURN_NULL();
+	}
+
+	if (!safe_cast_to_string(var, return_value TSRMLS_CC)) {
+		zend_throw_exception(php_CastException_ce, "Value could not be converted to string", 0 TSRMLS_CC);
+	}
+}
+/* }}} */
+
+/* {{{ proto string try_string(mixed from)
+   Strictly convert the given value to a string, returning NULL on failure. */
+PHP_FUNCTION(try_string)
+{
+	zval *var;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+		RETURN_NULL();
+	}
+	
+	if (!safe_cast_to_string(var, return_value TSRMLS_CC)) {
+		RETURN_NULL();
+	}
+
+}
+/* }}} */
+
 /*
  * Local variables:
  * tab-width: 4