// extern void TF_SetAttrTypeList(TF_OperationDescription* desc, // const char* attr_name, const TF_DataType* values, // int num_values); static PHP_METHOD(TensorFlow_OperationDescription, setAttrTypeList) { zend_string *name; zval* dtypes; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_STR(name) Z_PARAM_ARRAY(dtypes) ZEND_PARSE_PARAMETERS_END(); TF_DataType* tf_values = NULL; int tf_num_values = 0; HashTable *values_table = Z_ARRVAL_P(dtypes); tf_num_values = zend_hash_num_elements(values_table); // count of array if (tf_num_values > 0) { tf_values = (TF_DataType*)emalloc(sizeof(TF_DataType) * tf_num_values); HashPosition pos; zval* element; int index = 0; zend_hash_internal_pointer_reset_ex(values_table, &pos); while (zend_hash_has_more_elements_ex(values_table, &pos) == SUCCESS) { if (!(element = zend_hash_get_current_data_ex(values_table, &pos))) { zend_throw_exception(spl_ce_InvalidArgumentException, "dtypes something wrong", 0); return; } if (zval_get_type(element) != IS_LONG) { zend_throw_exception(spl_ce_InvalidArgumentException, "dtypes must be array of integer", 0); return; } if (!valid_dtype(Z_LVAL_P(element))) { zend_throw_exception(spl_ce_InvalidArgumentException, "each dtype must be from 1 to 20", 0); return; } // insert tf_values tf_values[index] = Z_LVAL_P(element); // php_printf("%d \n", element->value.lval); zend_hash_move_forward_ex(values_table, &pos); index++; } } // int i; // for (i = 0; i < tf_num_values; i++) { // php_printf("dtypes[%d] ? %d\n", i, tf_values[i]); // } // php_printf("tf_num_values ? %d\n", tf_num_values); // this t_tf_operation_description_object* intern = TF_OPERATION_DESCRIPTION_P_ZV(getThis()); t_tf_operation_description* node = intern->ptr; TF_SetAttrTypeList(node->src, name->val, tf_values, tf_num_values); }
SharedStringList KPHPArrayObject::GetPropertyNames() { SharedStringList property_names = new StringList(); HashPosition pos; HashTable *ht = Z_ARRVAL_P(this->list); for (zend_hash_internal_pointer_reset_ex(ht, &pos); zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS; zend_hash_move_forward_ex(ht, &pos)) { char *key; unsigned int keylen; unsigned long index; zend_hash_get_current_key_ex(ht, &key, &keylen, &index, 0, &pos); property_names->push_back(new std::string(key)); } zend_hash_destroy(ht); FREE_HASHTABLE(ht); return property_names; }
/** * Applies a format to a message before sending it to the log * * @param string $message * @param int $type * @param int $timestamp * @param array $context * @return string */ PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) { zval *message, *type, *type_str = NULL, *timestamp, *context, *interpolated = NULL; zval *payload, *body, *backtrace = NULL, *meta, *encoded; zval *show_backtrace, *enable_labels; int i_show_backtrace, i_enable_labels; smart_str result = { NULL, 0, 0 }; uint i; Bucket *p; phalcon_fetch_params(0, 4, 0, &message, &type, ×tamp, &context); /* * We intentionally do not use Phalcon's MM for better performance. * All variables allocated with ALLOC_INIT_ZVAL() will have * their reference count set to 1 and therefore they can be nicely * put into the result array; when that array will be destroyed, * all inserted variables will be automatically destroyed, too * and we will just save some time by not using Z_ADDREF_P and Z_DELREF_P */ if (Z_TYPE_P(context) == IS_ARRAY) { PHALCON_CALL_METHODW(&interpolated, this_ptr, "interpolate", message, context); } else { interpolated = message; Z_ADDREF_P(interpolated); } { zval *params[] = { type }; if (FAILURE == phalcon_call_method(&type_str, this_ptr, "gettypestring", 1, params TSRMLS_CC)) { zval_ptr_dtor(&interpolated); return; } } show_backtrace = phalcon_fetch_nproperty_this(getThis(), SL("_showBacktrace"), PH_NOISY TSRMLS_CC); enable_labels = phalcon_fetch_nproperty_this(getThis(), SL("_enableLabels"), PH_NOISY TSRMLS_CC); i_show_backtrace = zend_is_true(show_backtrace); i_enable_labels = zend_is_true(enable_labels); /* * Get the backtrace. This differs for different PHP versions. * 5.3.6+ allows us to skip the function arguments which will save some memory * For 5.4+ there is an extra argument. */ if (i_show_backtrace) { ALLOC_INIT_ZVAL(backtrace); #if PHP_VERSION_ID < 50306 zend_fetch_debug_backtrace(backtrace, 1, 0 TSRMLS_CC); #elif PHP_VERSION_ID < 50400 zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS TSRMLS_CC); #else zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS, 0 TSRMLS_CC); #endif if (Z_TYPE_P(backtrace) == IS_ARRAY) { HashPosition pos; HashTable *ht = Z_ARRVAL_P(backtrace); zval **ppzval; int found = 0; ulong idx; char *key; uint key_len; /* * At this point we know that the backtrace is the array. * Again, we intentionally do not use Phalcon's API because we know * that we are working with the array / hash table and thus we can * save some time by omitting Z_TYPE_P(x) == IS_ARRAY checks */ for ( zend_hash_internal_pointer_reset_ex(ht, &pos); zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS; ) { zend_hash_get_current_data_ex(ht, (void**)&ppzval, &pos); zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, &pos); zend_hash_move_forward_ex(ht, &pos); if (Z_TYPE_PP(ppzval) == IS_ARRAY) { /* * Here we need to skip the latest calls into Phalcon's core. * Calls to Zend internal functions will have "file" index not set. * We remove these entries from the array. */ if (!found && !zend_hash_quick_exists(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")))) { zend_hash_index_del(ht, idx); } else { /* * Remove args and object indices. They usually give * too much information; this is not suitable to send * in the HTTP headers */ zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "args", sizeof("args"), zend_inline_hash_func(SS("args"))); zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "object", sizeof("object"), zend_inline_hash_func(SS("object"))); found = 1; } } } /* * Now we need to renumber the hash table because we removed several * heading elements. If we don't do this, json_encode() will convert * this array to a JavaScript object which is an unwanted side effect */ p = ht->pListHead; i = 0; while (p != NULL) { p->nKeyLength = 0; p->h = i++; p = p->pListNext; } ht->nNextFreeElement = i; zend_hash_rehash(ht); } } /* * The result will looks like this: * * array( * array('Type' => 'message type', 'Label' => 'message'), * array('backtrace' => array(backtrace goes here) * ) */ MAKE_STD_ZVAL(payload); array_init_size(payload, 2); MAKE_STD_ZVAL(meta); array_init_size(meta, 4); add_assoc_zval_ex(meta, SS("Type"), type_str); if (i_show_backtrace && Z_TYPE_P(backtrace) == IS_ARRAY) { zval **ppzval; if (likely(SUCCESS == zend_hash_index_find(Z_ARRVAL_P(backtrace), 0, (void**)&ppzval)) && likely(Z_TYPE_PP(ppzval) == IS_ARRAY)) { zval **file = NULL, **line = NULL; zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")), (void**)&file); zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("line"), zend_inline_hash_func(SS("line")), (void**)&line); if (likely(file != NULL)) { Z_ADDREF_PP(file); add_assoc_zval_ex(meta, SS("File"), *file); } if (likely(line != NULL)) { Z_ADDREF_PP(line); add_assoc_zval_ex(meta, SS("Line"), *line); } } } if (i_enable_labels) { add_assoc_zval_ex(meta, SS("Label"), interpolated); } if (!i_enable_labels && !i_show_backtrace) { body = interpolated; } else if (i_enable_labels && !i_show_backtrace) { MAKE_STD_ZVAL(body); ZVAL_EMPTY_STRING(body); } else { MAKE_STD_ZVAL(body); array_init_size(body, 2); if (i_show_backtrace) { add_assoc_zval_ex(body, SS("backtrace"), backtrace); } if (!i_enable_labels) { add_assoc_zval_ex(body, SS("message"), interpolated); } } add_next_index_zval(payload, meta); add_next_index_zval(payload, body); /* Convert everything to JSON */ ALLOC_INIT_ZVAL(encoded); if (FAILURE == phalcon_json_encode(encoded, payload, 0 TSRMLS_CC)) { zval_ptr_dtor(&payload); zval_ptr_dtor(&encoded); return; } /* As promised, kill the payload and all associated elements */ zval_ptr_dtor(&payload); /* * We don't want to use Phalcon's concatenation API because it * requires the memory manager. Therefore we fall back to using smart strings. * smart_str_alloc4() will allocate all required memory amount (plus some more) * in one go and this allows us to avoid performance penalties due to * memory reallocations. */ if (Z_TYPE_P(encoded) == IS_STRING && Z_STRVAL_P(encoded) != NULL) { smart_str_alloc4(&result, (uint)(Z_STRLEN_P(encoded) + 2 + 5), 0, i); /* * The format is: * * <size>|[meta,body]| * * Meta and body are contained in encoded inside the array, as required * by the protocol specification * @see http://www.firephp.org/Wiki/Reference/Protocol */ smart_str_append_long(&result, Z_STRLEN_P(encoded)); smart_str_appendc(&result, '|'); smart_str_appendl(&result, Z_STRVAL_P(encoded), Z_STRLEN_P(encoded)); smart_str_appendc(&result, '|'); smart_str_0(&result); } /* We don't need the JSON message anymore */ zval_ptr_dtor(&encoded); /* Do not free the smart string because we steal its data for zval */ RETURN_STRINGL(result.c, result.len, 0); }
static zval *get_trace_detail(const jsonlite_decoder *self) { HashTable *array = NULL; HashPosition *pointer = NULL; zval *traces = NULL; zval *trace = NULL; zval **val = NULL; zval **msg = NULL; zval **range_start = NULL; zval **range_end = NULL; zval *range = NULL; char *str = NULL; zval *chars = NULL; zval **detail = NULL; int start = 0; int end = 0; array = Z_ARRVAL_P(self->trace); ALLOC_INIT_ZVAL(traces); array_init(traces); zend_hash_internal_pointer_reset_ex(array, pointer); while (zend_hash_has_more_elements_ex(array, pointer) == SUCCESS) { if (zend_hash_get_current_data_ex(array, (void **) &val, pointer) == SUCCESS) { if (val && Z_TYPE_PP(val) == IS_ARRAY) { zend_hash_index_find(Z_ARRVAL_PP(val), 0, (void **) &msg); zend_hash_index_find(Z_ARRVAL_PP(val), 1, (void **) &range_start); zend_hash_index_find(Z_ARRVAL_PP(val), 2, (void **) &range_end); if (zend_hash_index_exists(Z_ARRVAL_PP(val), 3) == 1) { zend_hash_index_find(Z_ARRVAL_PP(val), 3, (void **) &detail); } ALLOC_INIT_ZVAL(trace); array_init(trace); zval_add_ref(msg); add_assoc_zval_ex(trace, ZEND_STRS("msg"), *msg); ALLOC_INIT_ZVAL(range); array_init(range); zval_add_ref(range_start); add_next_index_zval(range, *range_start); zval_add_ref(range_end); add_next_index_zval(range, *range_end); add_assoc_zval_ex(trace, ZEND_STRS("range"), range); start = Z_LVAL_PP(range_start); if (start > 0) { start--; } end = Z_LVAL_PP(range_end); if (end < self->length) { end++; } str = zend_strndup((self->jsonlite + start), end - start); add_assoc_string_ex(trace, ZEND_STRS("chars"), str, 1); free(str); if (detail != NULL) { zval_add_ref(detail); add_assoc_zval_ex(trace, ZEND_STRS("detail"), *detail); } add_next_index_zval(traces, trace); detail = NULL; trace = NULL; } } if (zend_hash_move_forward_ex(array, pointer) == FAILURE) { break; } } return traces; }