Detailed explanation of php define constants

class A {
 public function __toString() {
 return 'bar';
 }
}
$a = new A();
define('foo', $a);
echo foo;
 // Output bar

How define in php is implemented:

ZEND_FUNCTION(define)
{
 char *name;
 int name_len;
 zval *val;
 zval *val_free = NULL;
 zend_bool non_cs = 0;
 int case_sensitive = CONST _CS;
 zend_constant c;
 // Receive 3 parameters, string, zval, bool
 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) {
 return;
 }
 // Is it case sensitive?
 if(non_cs) {
 case_sensitive = 0;
 }
 / / If define a class constant, an error will be reported
 if (zend_memnstr(name, "::", sizeof("::") - 1, name + name_len)) {
 zend_error(E_WARNING, "Class constants cannot be defined or redefined" );
 RETURN_FALSE;
 }
 // Get the real value and save it with val
repeat:
 switch (Z_TYPE_P(val)) {
 case IS_LONG:
 case IS_DOUBLE:
 case IS_STRING :
 case IS_BOOL:
 case IS_RESOURCE:
 case IS_NULL:
 break;
 case IS_OBJECT:
 if (!val_free) {
 if (Z_OBJ_HT_P(val)->get) {
 val_free = val = Z_OBJ_HT_P(val)- >get(val TSRMLS_CC);
 goto repeat;
 } else if (Z_OBJ_HT_P(val)->cast_object) {
 ALLOC_INIT_ZVAL(val_free);
 if (Z_OBJ_HT_P(val)->cast_object(val, val_free, IS_STRING TSRMLS_CC) == SUCCESS) {
 val = val_free;
 break;
 }
 }
 }
 /* no break */
 default:
 zend_error(E_WARNING,"Constants may only evaluate to scalar values");
 if ( val_free) {
 zval_ptr_dtor(&val_free);
 }
 RETURN_FALSE;
 }

 //Construct constants
 c.value = *val;
 zval_copy_ctor(&c.value);
 if (val_free) {
 zval_ptr_dtor(&val_free);
 }
 c.flags = case_sensitive; /* non persistent */ // 0 if case-insensitive, 1 if case-sensitive
 c.name = zend_strndup(name, name_len);
 c.name_len = name_len+ 1;
 c.module_number = PHP_USER_CONSTANT; // Mark non-kernel constants, but user-defined constants

 // Register constants
 if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) {
 RETURN_TRUE;
 } else {
 RETURN_FALSE ;
 }
}

Note that a loop starting with repeat also uses the goto statement T_T

The function of this code is: For int, float, string, bool, resource, null, use these values ​​directly when actually defining the constants. For object, you need to convert the object into one of the above 6 types (if it is still an object after the conversion, continue the conversion) How to convert object into one of 6 types? From the code point of view, there are two methods:

if (Z_OBJ_HT_P(val)->get) {
 val_free = val = Z_OBJ_HT_P(val)->get(val TSRMLS_CC);
 goto repeat;
}
// __toString() method will Called in cast_object
else if (Z_OBJ_HT_P(val)->cast_object) {
 ALLOC_INIT_ZVAL(val_free);
 if (Z_OBJ_HT_P(val)->cast_object(val, val_free, IS_STRING TSRMLS_CC) == SUCCESS)
 {
 val = val_free;
 break;
 }
}

1, Z_OBJ_HT_P(val)->get, after macro expansion, it is (*val).value.obj.handlers->get

2, Z_OBJ_HT_P(val)->cast_object, after macro expansion, it is (*val).value.obj.handlers->cast_object

Handlers is a structure containing many function pointers. For detailed definition, see _zend_object_handlers. The function pointers in this structure are used to operate objects, such as reading/modifying object attributes, obtaining/calling object methods, etc... get and cast_object are also among them.

For general objects, PHP provides the standard cast_object function zend_std_cast_object_tostring. The code is located in php-src/zend/zend-object-handlers.c:

ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type TSRMLS_DC) /* {{{ */
{
 zval *retval;
 zend_class_entry *ce;
 switch (type) {
 case IS_STRING:
 ce = Z_OBJCE_P(readobj);

 // If __toString is defined in the user's class, try to call
 if (ce->__tostring &&
 (zend_call_method_with_0_params(&readobj, ce, &ce->__tostring, "__tostring", &retval) || EG(exception))) {
 ……

 }
 return FAILURE;
 ……
 }
 return FAILURE;
}

From the above specific implementation, the default cast_object is to find the __tostring method in the class and then call...

Back to the initial example, define('foo', $a), since $a is an instance of A, and __toString is defined in class A, the foo constant is actually equal to the return value bar of toString.

ps: Keep digging for little details.

1, define has a return value Usually we define constants directly as: define('foo', 123); However, judging from the implementation of define, it has a return value. According to the description in the manual:

Return TRUE on success, or FALSE on failure.

Under what circumstances will define fail? for example:

define('PHP_INT_MAX', 1); // Returns FALSE
define('FOO', 1); // Returns TRUE
define(' FOO', 2); // Return FALSE

The above code contains two situations. One is that we try to redefine the predefined constants of the PHP kernel, such as PHP_INT_MAX, which It will obviously fail. The second case is that we have defined a constant FOO somewhere in the code, and then define it again in the next program, which will also cause failure. Therefore, it is best to write all the constants that need to be defined together when coding to avoid name duplication.

2, there is no limit on constant names Let's review the implementation of define again, which only determines whether the name is in the form of XXX::YYY.

In other words, define has almost no requirements for its name, and of course it does not require that the name be a legal PHP variable name. Therefore, we can let define's constants have some weird names. For example:

define('>_<', 123); // Return TRUE
echo >_<; // syntax error

But if such a constant is defined, it is If it cannot be used directly, a syntax error will be reported. The correct usage is as follows:

define('>_<', 123); // Return TRUE
echo constant('>_<'); // Output 123