16400708798

Committed 20 Jul 2025 02:04PM UTC coverage: 93.107% (-0.1%) from 93.25%

Build # 16400708798

Build Type

push

github

Committed by

krakjoe

Commit Message

endings

Run Details

5808 of 6238 relevant lines covered (93.11%)

115945.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.36

/src/generators.c

/*
  +----------------------------------------------------------------------+
  | ort                                                                  |
  +----------------------------------------------------------------------+
  | Copyright (c) Joe Watkins 2025                                       |
  +----------------------------------------------------------------------+
  | 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:           |
  | http://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: krakjoe                                                      |
  +----------------------------------------------------------------------+
 */

#include "generators.h"
#include "generators/random.h"

zend_class_entry* php_ort_generator_ce;
zend_class_entry* php_ort_generator_internal_ce;
zend_object_handlers php_ort_generator_handlers;

typedef struct _php_ort_generator_context_t {
    zend_fcall_info       fci;
    zend_fcall_info_cache fcc;
} php_ort_generator_context_t;

static zend_object* php_ort_generator_create_user(
    zend_class_entry* ce) {
    php_ort_generator_t* generator = zend_object_alloc(
        sizeof(php_ort_generator_t), ce);

    zend_object_std_init(&generator->std, ce);
    object_properties_init(&generator->std, ce);

    generator->std.handlers =
        &php_ort_generator_handlers;

    php_ort_generator_context_t* context =
        emalloc(sizeof(php_ort_generator_context_t));

    memset(&context->fci, 0, sizeof(context->fci));
    memset(&context->fcc, 0, sizeof(context->fcc));

    context->fci.size = sizeof(context->fci);
    context->fci.object = &generator->std;
    context->fcc.object = &generator->std;
    context->fcc.function_handler =
        zend_hash_find_ptr(
            &ce->function_table,
            ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE));
    context->fcc.calling_scope = ce;
    context->fcc.called_scope = ce;

    generator->context = context;

    return &generator->std;
}

static zend_object* php_ort_generator_create_internal(
    zend_class_entry* ce) {
    php_ort_generator_t* generator = zend_object_alloc(
        sizeof(php_ort_generator_t), ce);

    zend_object_std_init(&generator->std, ce);
    object_properties_init(&generator->std, ce);

    generator->std.handlers =
        &php_ort_generator_handlers;

    return &generator->std;
}

static void php_ort_generator_destroy(zend_object* zo) {
    php_ort_generator_t* generator =
        php_ort_generator_fetch(zo);

    if (generator->context) {
        efree(generator->context);
    }

    zend_object_std_dtor(zo);
}

static zend_always_inline zend_bool
    php_ort_generator_invoke_user(
        php_ort_generator_t* generator,
        ONNXTensorElementDataType type,
        void* target) {
    zval rv;
    php_ort_generator_context_t* context =
        (php_ort_generator_context_t*)
            generator->context;

    ZVAL_UNDEF(&rv);

    ZVAL_OBJ(
        &context->fci.function_name,
        &generator->std);
    context->fci.retval = &rv;

    zend_call_function(
        &context->fci, &context->fcc);
    php_ort_tensor_store(
        type, target, &rv);
    zval_ptr_dtor(&rv);

    return !EG(exception);
}

static zend_always_inline zend_bool
    php_ort_generator_invoke_internal(
        php_ort_generator_t* generator,
        ONNXTensorElementDataType type,
        void* target) {
    zval rv;

    ZVAL_UNDEF(&rv);
    generator->invoke(generator, &rv);
    php_ort_tensor_store(
        type, target, &rv);
    zval_ptr_dtor(&rv);

    return !Z_ISUNDEF(rv);
}

zend_bool php_ort_generator_invoke(
    zval* zv,
    ONNXTensorElementDataType type,
    void* target) {
    zval rv;
    php_ort_generator_t* generator =
        php_ort_generator_fetch(Z_OBJ_P(zv));

    if (instanceof_function(
        generator->std.ce, php_ort_generator_internal_ce)) {
        return php_ort_generator_invoke_internal(
            generator, type, target);
    }

    if (instanceof_function(
        generator->std.ce, php_ort_generator_ce)) {
        return php_ort_generator_invoke_user(
            generator, type, target);
    }

    /* unexpected */
    return 0;
}

ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
    php_ort_generator_invoke_arginfo, 0, 0, IS_MIXED, 0)
ZEND_END_ARG_INFO()

zend_function_entry php_ort_generator_methods[] = {
    PHP_ABSTRACT_ME(Generator, __invoke, php_ort_generator_invoke_arginfo)
    PHP_FE_END
};

PHP_METHOD(Generator, __invoke) {
    ZEND_PARSE_PARAMETERS_NONE();
}

zend_function_entry php_ort_generator_internal_methods[] = {
    PHP_ME(Generator, __invoke,
        php_ort_generator_invoke_arginfo,
        ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
    PHP_FE_END
};

PHP_MINIT_FUNCTION(ORT_GENERATORS) 
{
    zend_class_entry ce;

    INIT_NS_CLASS_ENTRY(ce, "ORT\\Tensor",
        "Generator", php_ort_generator_methods);
    php_ort_generator_ce =
        zend_register_internal_class(&ce);
    php_ort_generator_ce->create_object =
        php_ort_generator_create_user;
    
    memcpy(
        &php_ort_generator_handlers,
        zend_get_std_object_handlers(),
        sizeof(zend_object_handlers));

    php_ort_generator_handlers.offset =
        XtOffsetOf(php_ort_generator_t, std);
    php_ort_generator_handlers.free_obj =
        php_ort_generator_destroy;
    php_ort_generator_handlers.clone_obj = NULL;

    INIT_NS_CLASS_ENTRY(ce, "ORT\\Tensor\\Generator",
        "Internal", php_ort_generator_internal_methods);
    php_ort_generator_internal_ce =
        zend_register_internal_class_ex(&ce, php_ort_generator_ce);
    php_ort_generator_internal_ce->create_object =
        php_ort_generator_create_internal;

    PHP_MINIT(ORT_GENERATORS_RANDOM)(INIT_FUNC_ARGS_PASSTHRU);

    return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(ORT_GENERATORS)
{
    PHP_MSHUTDOWN(ORT_GENERATORS_RANDOM)(INIT_FUNC_ARGS_PASSTHRU);

    return SUCCESS;
}

1	/*
2	+----------------------------------------------------------------------+
3	\| ort \|
4	+----------------------------------------------------------------------+
5	\| Copyright (c) Joe Watkins 2025 \|
6	+----------------------------------------------------------------------+
7	\| This source file is subject to version 3.01 of the PHP license, \|
8	\| that is bundled with this package in the file LICENSE, and is \|
9	\| available through the world-wide-web at the following url: \|
10	\| http://www.php.net/license/3_01.txt \|
11	\| If you did not receive a copy of the PHP license and are unable to \|
12	\| obtain it through the world-wide-web, please send a note to \|
13	\| license@php.net so we can mail you a copy immediately. \|
14	+----------------------------------------------------------------------+
15	\| Author: krakjoe \|
16	+----------------------------------------------------------------------+
17	*/
18
19	#include "generators.h"
20	#include "generators/random.h"
21
22	zend_class_entry* php_ort_generator_ce;
23	zend_class_entry* php_ort_generator_internal_ce;
24	zend_object_handlers php_ort_generator_handlers;
25
26	typedef struct _php_ort_generator_context_t {
27	zend_fcall_info fci;
28	zend_fcall_info_cache fcc;
29	} php_ort_generator_context_t;
30
31	static zend_object* php_ort_generator_create_user(	64✔
32	zend_class_entry* ce) {
33	php_ort_generator_t* generator = zend_object_alloc(	64✔
34	sizeof(php_ort_generator_t), ce);
35
36	zend_object_std_init(&generator->std, ce);	64✔
37	object_properties_init(&generator->std, ce);	64✔
38
39	generator->std.handlers =	64✔
40	&php_ort_generator_handlers;
41
42	php_ort_generator_context_t* context =	64✔
43	emalloc(sizeof(php_ort_generator_context_t));	64✔
44
45	memset(&context->fci, 0, sizeof(context->fci));	64✔
46	memset(&context->fcc, 0, sizeof(context->fcc));	64✔
47
48	context->fci.size = sizeof(context->fci);	64✔
49	context->fci.object = &generator->std;	64✔
50	context->fcc.object = &generator->std;	64✔
51	context->fcc.function_handler =	128✔
52	zend_hash_find_ptr(	128✔
53	&ce->function_table,	64✔
54	ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE));	64✔
55	context->fcc.calling_scope = ce;	64✔
56	context->fcc.called_scope = ce;	64✔
57
58	generator->context = context;	64✔
59
60	return &generator->std;	64✔
61	}
62
63	static zend_object* php_ort_generator_create_internal(	×
64	zend_class_entry* ce) {
65	php_ort_generator_t* generator = zend_object_alloc(	×
66	sizeof(php_ort_generator_t), ce);
67
68	zend_object_std_init(&generator->std, ce);	×
69	object_properties_init(&generator->std, ce);	×
70
71	generator->std.handlers =	×
72	&php_ort_generator_handlers;
73
74	return &generator->std;	×
75	}
76
77	static void php_ort_generator_destroy(zend_object* zo) {	496✔
78	php_ort_generator_t* generator =	496✔
79	php_ort_generator_fetch(zo);	496✔
80
81	if (generator->context) {	496✔
82	efree(generator->context);	496✔
83	}
84
85	zend_object_std_dtor(zo);	496✔
86	}	496✔
87
88	static zend_always_inline zend_bool
89	php_ort_generator_invoke_user(	4,144✔
90	php_ort_generator_t* generator,
91	ONNXTensorElementDataType type,
92	void* target) {
93	zval rv;	4,144✔
94	php_ort_generator_context_t* context =	4,144✔
95	(php_ort_generator_context_t*)
96	generator->context;
97
98	ZVAL_UNDEF(&rv);	4,144✔
99
100	ZVAL_OBJ(	4,144✔
101	&context->fci.function_name,
102	&generator->std);
103	context->fci.retval = &rv;	4,144✔
104
105	zend_call_function(	4,144✔
106	&context->fci, &context->fcc);
107	php_ort_tensor_store(	4,144✔
108	type, target, &rv);
109	zval_ptr_dtor(&rv);	4,144✔
110
111	return !EG(exception);	4,144✔
112	}
113
114	static zend_always_inline zend_bool
115	php_ort_generator_invoke_internal(	15,552✔
116	php_ort_generator_t* generator,
117	ONNXTensorElementDataType type,
118	void* target) {
119	zval rv;	15,552✔
120
121	ZVAL_UNDEF(&rv);	15,552✔
122	generator->invoke(generator, &rv);	15,552✔
123	php_ort_tensor_store(	15,552✔
124	type, target, &rv);
125	zval_ptr_dtor(&rv);	15,552✔
126
127	return !Z_ISUNDEF(rv);	15,552✔
128	}
129
130	zend_bool php_ort_generator_invoke(	19,696✔
131	zval* zv,
132	ONNXTensorElementDataType type,
133	void* target) {
134	zval rv;	19,696✔
135	php_ort_generator_t* generator =	19,696✔
136	php_ort_generator_fetch(Z_OBJ_P(zv));	19,696✔
137
138	if (instanceof_function(	39,392✔
139	generator->std.ce, php_ort_generator_internal_ce)) {	19,696✔
140	return php_ort_generator_invoke_internal(	31,104✔
141	generator, type, target);
142	}
143
144	if (instanceof_function(	27,984✔
145	generator->std.ce, php_ort_generator_ce)) {	4,144✔
146	return php_ort_generator_invoke_user(	8,288✔
147	generator, type, target);
148	}
149
150	/* unexpected */
151	return 0;
152	}
153
154	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
155	php_ort_generator_invoke_arginfo, 0, 0, IS_MIXED, 0)
156	ZEND_END_ARG_INFO()
157
158	zend_function_entry php_ort_generator_methods[] = {
159	PHP_ABSTRACT_ME(Generator, __invoke, php_ort_generator_invoke_arginfo)
160	PHP_FE_END
161	};
162
163	PHP_METHOD(Generator, __invoke) {	×
164	ZEND_PARSE_PARAMETERS_NONE();	×
165	}
166
167	zend_function_entry php_ort_generator_internal_methods[] = {
168	PHP_ME(Generator, __invoke,
169	php_ort_generator_invoke_arginfo,
170	ZEND_ACC_PUBLIC\|ZEND_ACC_FINAL)
171	PHP_FE_END
172	};
173
174	PHP_MINIT_FUNCTION(ORT_GENERATORS)	3,296✔
175	{
176	zend_class_entry ce;	3,296✔
177
178	INIT_NS_CLASS_ENTRY(ce, "ORT\\Tensor",	3,296✔
179	"Generator", php_ort_generator_methods);	3,296✔
180	php_ort_generator_ce =	6,592✔
181	zend_register_internal_class(&ce);	3,296✔
182	php_ort_generator_ce->create_object =	3,296✔
183	php_ort_generator_create_user;
184
185	memcpy(	3,296✔
186	&php_ort_generator_handlers,
187	zend_get_std_object_handlers(),
188	sizeof(zend_object_handlers));
189
190	php_ort_generator_handlers.offset =	3,296✔
191	XtOffsetOf(php_ort_generator_t, std);
192	php_ort_generator_handlers.free_obj =	3,296✔
193	php_ort_generator_destroy;
194	php_ort_generator_handlers.clone_obj = NULL;	3,296✔
195
196	INIT_NS_CLASS_ENTRY(ce, "ORT\\Tensor\\Generator",	3,296✔
197	"Internal", php_ort_generator_internal_methods);	3,296✔
198	php_ort_generator_internal_ce =	6,592✔
199	zend_register_internal_class_ex(&ce, php_ort_generator_ce);	3,296✔
200	php_ort_generator_internal_ce->create_object =	3,296✔
201	php_ort_generator_create_internal;
202
203	PHP_MINIT(ORT_GENERATORS_RANDOM)(INIT_FUNC_ARGS_PASSTHRU);	3,296✔
204
205	return SUCCESS;	3,296✔
206	}
207
208	PHP_MSHUTDOWN_FUNCTION(ORT_GENERATORS)	3,296✔
209	{
210	PHP_MSHUTDOWN(ORT_GENERATORS_RANDOM)(INIT_FUNC_ARGS_PASSTHRU);	3,296✔
211
212	return SUCCESS;	3,296✔
213	}

krakjoe / ort / 16400708798

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous