// 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;
}
