projects / awesomized / ext-ion / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
fix ion type arguments
[awesomized/ext-ion] / ion.c
1 /*
2 +--------------------------------------------------------------------+
3 | PECL :: ion |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2021, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 #ifdef HAVE_CONFIG_H
14 # include "config.h"
15 #endif
16
17 #include "php.h"
18 #include "ext/standard/info.h"
19
20 #include "Zend/zend_enum.h"
21 #include "Zend/zend_exceptions.h"
22 #include "Zend/zend_closures.h"
23 #include "Zend/zend_interfaces.h"
24 #include "Zend/zend_smart_str.h"
25
26 #include "ext/date/php_date.h"
27 #include "ext/spl/spl_exceptions.h"
28 #include "ext/spl/spl_iterators.h"
29
30 #include "php_ion.h"
31 #include "ion_private.h"
32
33 static ZEND_METHOD(ion_Symbol_ImportLocation, __construct)
34 {
35 php_ion_symbol_iloc *obj = php_ion_obj(symbol_iloc, Z_OBJ_P(ZEND_THIS));
36 PTR_CHECK(obj);
37
38 zend_long location;
39 ZEND_PARSE_PARAMETERS_START(2, 2)
40 Z_PARAM_STR(obj->name)
41 Z_PARAM_LONG(location)
42 ZEND_PARSE_PARAMETERS_END();
43
44 obj->loc.location = location;
45 php_ion_symbol_iloc_ctor(obj);
46 }
47 static ZEND_METHOD(ion_Symbol, __construct)
48 {
49 php_ion_symbol *obj = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
50 PTR_CHECK(obj);
51
52 zend_long sid = -1;
53 ZEND_PARSE_PARAMETERS_START(0, 3)
54 Z_PARAM_OPTIONAL
55 Z_PARAM_STR_OR_NULL(obj->value)
56 Z_PARAM_LONG(sid)
57 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->iloc, ce_Symbol_ImportLocation)
58 ZEND_PARSE_PARAMETERS_END();
59
60 obj->sym.sid = sid;
61 php_ion_symbol_ctor(obj);
62 }
63 static ZEND_METHOD(ion_Symbol, equals)
64 {
65 php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
66 OBJ_CHECK(sym);
67
68 zend_object *other_obj;
69 ZEND_PARSE_PARAMETERS_START(1, 1)
70 Z_PARAM_OBJ_OF_CLASS(other_obj, ce_Symbol)
71 ZEND_PARSE_PARAMETERS_END();
72
73 BOOL eq = FALSE;
74 iERR err = ion_symbol_is_equal(
75 &sym->sym,
76 &php_ion_obj(symbol, other_obj)->sym, &eq);
77 ION_CHECK(err);
78 RETVAL_BOOL(eq);
79 }
80 static ZEND_METHOD(ion_Symbol, __toString)
81 {
82 php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
83 OBJ_CHECK(sym);
84
85 ZEND_PARSE_PARAMETERS_NONE();
86
87 if (!sym->value) {
88 RETURN_EMPTY_STRING();
89 }
90 RETURN_STR_COPY(sym->value);
91 }
92 static ZEND_METHOD(ion_Symbol_Enum, toSymbol)
93 {
94 ZEND_PARSE_PARAMETERS_NONE();
95
96 zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
97 PTR_CHECK(zc);
98
99 zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
100 PTR_CHECK(zsym);
101 RETVAL_ZVAL(zsym, 1, 0);
102 }
103 static ZEND_METHOD(ion_Symbol_Enum, toSID)
104 {
105 ZEND_PARSE_PARAMETERS_NONE();
106
107 zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
108 PTR_CHECK(zc);
109
110 zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
111 PTR_CHECK(zsym);
112
113 zval tmp;
114 RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(zsym), Z_OBJ_P(zsym), ZEND_STRL("sid"), 0, &tmp), 1, 0);
115 }
116 static ZEND_METHOD(ion_Symbol_Enum, toString)
117 {
118 ZEND_PARSE_PARAMETERS_NONE();
119
120 zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
121 PTR_CHECK(zc);
122
123 zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
124 PTR_CHECK(zsym);
125
126 zval tmp;
127 RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(zsym), Z_OBJ_P(zsym), ZEND_STRL("value"), 0, &tmp), 1, 0);
128 }
129 static ZEND_FUNCTION(ion_Symbol_Table_System)
130 {
131 ZEND_PARSE_PARAMETERS_NONE();
132
133 object_init_ex(return_value, ce_Symbol_Table_Shared);
134 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(return_value));
135 ION_CHECK(ion_symbol_table_get_system_table(&obj->tab, 1));
136 php_ion_symbol_table_ctor(obj);
137 ion_symbol_table_lock(obj->tab);
138 }
139 static ZEND_FUNCTION(ion_Symbol_Table_PHP)
140 {
141 ZEND_PARSE_PARAMETERS_NONE();
142
143 object_init_ex(return_value, ce_Symbol_Table_Shared);
144 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(return_value));
145 obj->tab = g_sym_tab_php;
146 php_ion_symbol_table_ctor(obj);
147 ion_symbol_table_lock(obj->tab);
148 }
149 static ZEND_METHOD(ion_Symbol_Table_Local, __construct)
150 {
151 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
152 PTR_CHECK(obj);
153
154 ZEND_PARSE_PARAMETERS_NONE();
155
156 ION_CHECK(ion_symbol_table_open_with_type(&obj->tab, NULL, ist_LOCAL));
157 obj->dtor = ion_symbol_table_close;
158 OBJ_CHECK(obj);
159 }
160 static ZEND_METHOD(ion_Symbol_Table_Local, import)
161 {
162 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
163 OBJ_CHECK(obj);
164
165 zend_object *zo_import;
166 ZEND_PARSE_PARAMETERS_START(1, 1)
167 Z_PARAM_OBJ_OF_CLASS(zo_import, ce_Symbol_Table);
168 ZEND_PARSE_PARAMETERS_END();
169
170 php_ion_symbol_table_import(obj, php_ion_obj(symbol_table, zo_import));
171 }
172 static ZEND_METHOD(ion_Symbol_Table_Shared, __construct)
173 {
174 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
175 PTR_CHECK(obj);
176
177 zend_string *zname;
178 zend_long version = 1;
179 HashTable *ht_sym = NULL;
180 ZEND_PARSE_PARAMETERS_START(1, 3)
181 Z_PARAM_STR(zname)
182 Z_PARAM_OPTIONAL
183 Z_PARAM_LONG(version)
184 Z_PARAM_ARRAY_HT_OR_NULL(ht_sym)
185 ZEND_PARSE_PARAMETERS_END();
186
187 ION_CHECK(ion_symbol_table_open_with_type(&obj->tab, NULL, ist_SHARED));
188 obj->dtor = ion_symbol_table_close;
189
190 ION_STRING is;
191 ION_CHECK(ion_symbol_table_set_name(obj->tab, ion_string_from_zend(&is, zname)));
192 ION_CHECK(ion_symbol_table_set_version(obj->tab, version));
193
194 php_ion_symbol_table_ctor(obj);
195
196 zval *zsym;
197 if (ht_sym) ZEND_HASH_FOREACH_VAL(ht_sym, zsym)
198 {
199 zend_string *str = zval_get_string(zsym);
200 if (EG(exception)) {
201 break;
202 }
203
204 ION_STRING is;
205 ION_CHECK(ion_symbol_table_add_symbol(obj->tab, ion_string_from_zend(&is, str), NULL), zend_string_release(str));
206 zend_string_release(str);
207 }
208 ZEND_HASH_FOREACH_END();
209 }
210 static ZEND_METHOD(ion_Symbol_Table, getMaxId)
211 {
212 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
213 OBJ_CHECK(obj);
214
215 ZEND_PARSE_PARAMETERS_NONE();
216
217 SID max_sid;
218 ION_CHECK(ion_symbol_table_get_max_sid(obj->tab, &max_sid));
219 RETURN_LONG(max_sid);
220 }
221 static ZEND_METHOD(ion_Symbol_Table, add)
222 {
223 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
224 OBJ_CHECK(obj);
225
226 zend_object *zo_sym = NULL;
227 zend_string *zs_sym = NULL;
228 ZEND_PARSE_PARAMETERS_START(1, 1)
229 Z_PARAM_OBJ_OF_CLASS_OR_STR(zo_sym, ce_Symbol, zs_sym)
230 ZEND_PARSE_PARAMETERS_END();
231
232 if (zo_sym) {
233 zval z_sym;
234 ZVAL_OBJ(&z_sym, zo_sym);
235 zs_sym = zval_get_string(&z_sym);
236 ION_CATCH();
237 }
238 SID sid;
239 ION_STRING is;
240 ION_CHECK(ion_symbol_table_add_symbol(obj->tab, ion_string_from_zend(&is, zs_sym), &sid),
241 if (zo_sym) {
242 zend_string_release(zs_sym);
243 });
244 if (zo_sym) {
245 zend_string_release(zs_sym);
246 }
247 RETURN_LONG(sid);
248 }
249 static ZEND_METHOD(ion_Symbol_Table, find)
250 {
251 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
252 OBJ_CHECK(obj);
253
254 zend_long zsid;
255 zend_string *zstring = NULL;
256 ZEND_PARSE_PARAMETERS_START(1, 1)
257 Z_PARAM_STR_OR_LONG(zstring, zsid)
258 ZEND_PARSE_PARAMETERS_END();
259
260 if (zstring) {
261 SID sid;
262 ION_STRING is;
263 ION_CHECK(ion_symbol_table_find_by_name(obj->tab, ion_string_from_zend(&is, zstring), &sid));
264 zsid = sid;
265 }
266 ION_SYMBOL *sym;
267 ION_CHECK(ion_symbol_table_get_symbol(obj->tab, zsid, &sym));
268 if (sym) {
269 php_ion_symbol_table_symbol_zval(obj, sym, return_value);
270 }
271 }
272 static ZEND_METHOD(ion_Symbol_Table, findLocal)
273 {
274 php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
275 OBJ_CHECK(obj);
276
277 zend_long zsid;
278 zend_string *zstring;
279 ZEND_PARSE_PARAMETERS_START(1, 1)
280 Z_PARAM_STR_OR_LONG(zstring, zsid)
281 ZEND_PARSE_PARAMETERS_END();
282
283 if (zstring) {
284 SID sid;
285 ION_STRING is;
286 ION_CHECK(ion_symbol_table_find_by_name(obj->tab, ion_string_from_zend(&is, zstring), &sid));
287 zsid = sid;
288 }
289 ION_SYMBOL *sym;
290 ION_CHECK(ion_symbol_table_get_local_symbol(obj->tab, zsid, &sym));
291 if (sym) {
292 php_ion_symbol_table_symbol_zval(obj, sym, return_value);
293 }
294 }
295 static ZEND_METHOD(ion_Catalog, __construct)
296 {
297 php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
298 PTR_CHECK(obj);
299
300 ZEND_PARSE_PARAMETERS_NONE();
301
302 php_ion_catalog_ctor(obj);
303 }
304 static ZEND_METHOD(ion_Catalog, count)
305 {
306 php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
307 OBJ_CHECK(obj);
308
309 ZEND_PARSE_PARAMETERS_NONE();
310
311 int32_t c;
312 ION_CHECK(ion_catalog_get_symbol_table_count(obj->cat, &c));
313 RETURN_LONG(c);
314 }
315 static ZEND_METHOD(ion_Catalog, add)
316 {
317 php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
318 OBJ_CHECK(obj);
319
320 zend_object *zo_symtab;
321 ZEND_PARSE_PARAMETERS_START(1, 1)
322 Z_PARAM_OBJ_OF_CLASS(zo_symtab, ce_Symbol_Table)
323 ZEND_PARSE_PARAMETERS_END();
324
325 php_ion_symbol_table *o_symtab = php_ion_obj(symbol_table, zo_symtab);
326 php_ion_catalog_add_symbol_table(obj, o_symtab);
327 }
328
329 static ZEND_METHOD(ion_Catalog, remove)
330 {
331 php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
332 OBJ_CHECK(obj);
333
334 zend_object *zo_symtab = NULL;
335 zend_string *zs_symtab = NULL;
336 ZEND_PARSE_PARAMETERS_START(1, 1)
337 Z_PARAM_OBJ_OF_CLASS_OR_STR(zo_symtab, ce_Symbol_Table, zs_symtab)
338 ZEND_PARSE_PARAMETERS_END();
339
340 RETVAL_FALSE;
341
342 zval tmp;
343 zval *ztabs = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("symbolTables"), 0, &tmp);
344 if (ztabs) {
345 if (zo_symtab) {
346 // fast path
347 zend_ulong idx = (uintptr_t) &zo_symtab->gc;
348 RETVAL_BOOL(SUCCESS == zend_hash_index_del(Z_ARRVAL_P(ztabs), idx));
349 ION_CHECK(ion_catalog_release_symbol_table(obj->cat, php_ion_obj(symbol_table, zo_symtab)->tab));
350 } else {
351 bool deleted = false;
352 ION_SYMBOL_TABLE *tab;
353 ION_STRING is;
354 ion_string_from_zend(&is, zs_symtab);
355 do {
356 tab = NULL;
357 ION_CHECK(ion_catalog_find_best_match(obj->cat, &is, 0, &tab));
358 if (tab) {
359 ION_CHECK(ion_catalog_release_symbol_table(obj->cat, tab));
360 deleted = true;
361 }
362 } while(tab);
363 RETVAL_BOOL(deleted);
364 }
365 }
366 }
367 static ZEND_METHOD(ion_Catalog, find)
368 {
369 php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
370 OBJ_CHECK(obj);
371
372 zend_long zversion = 0;
373 zend_string *zname;
374 ZEND_PARSE_PARAMETERS_START(1, 2)
375 Z_PARAM_STR(zname)
376 Z_PARAM_OPTIONAL
377 Z_PARAM_LONG(zversion)
378 ZEND_PARSE_PARAMETERS_END();
379
380 ION_STRING is;
381 ION_SYMBOL_TABLE *tab_ptr = NULL;
382 ION_CHECK(ion_catalog_find_symbol_table(obj->cat, ion_string_from_zend(&is, zname), zversion, &tab_ptr));
383 if (tab_ptr) {
384 php_ion_catalog_symbol_table_zval(obj, tab_ptr, return_value);
385 }
386 }
387 static ZEND_METHOD(ion_Catalog, findBest)
388 {
389 php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
390 OBJ_CHECK(obj);
391
392 zend_long zversion = 0;
393 zend_string *zname;
394 ZEND_PARSE_PARAMETERS_START(1, 2)
395 Z_PARAM_STR(zname)
396 Z_PARAM_OPTIONAL
397 Z_PARAM_LONG(zversion)
398 ZEND_PARSE_PARAMETERS_END();
399
400 ION_STRING is;
401 ION_SYMBOL_TABLE *tab_ptr = NULL;
402 ION_CHECK(ion_catalog_find_best_match(obj->cat, ion_string_from_zend(&is, zname), zversion, &tab_ptr));
403 if (tab_ptr) {
404 php_ion_catalog_symbol_table_zval(obj, tab_ptr, return_value);
405 }
406 }
407 static ZEND_METHOD(ion_Timestamp, __construct)
408 {
409 php_ion_timestamp *obj = php_ion_obj(timestamp, Z_OBJ_P(ZEND_THIS));
410 PTR_CHECK(obj);
411
412 zend_long precision;
413 zend_object *precision_obj;
414 zend_string *fmt = NULL, *dt = NULL;
415 zval *tz = NULL;
416 ZEND_PARSE_PARAMETERS_START(1, 4)
417 Z_PARAM_OBJ_OF_CLASS_OR_LONG(precision_obj, ce_Timestamp_Precision, precision)
418 Z_PARAM_OPTIONAL
419 Z_PARAM_STR_OR_NULL(fmt)
420 Z_PARAM_STR_OR_NULL(dt)
421 Z_PARAM_ZVAL(tz)
422 ZEND_PARSE_PARAMETERS_END();
423
424 if (precision_obj) {
425 precision = Z_LVAL_P(zend_enum_fetch_case_value(precision_obj));
426 }
427 php_ion_timestamp_ctor(obj, precision, fmt, dt, tz);
428 }
429 static ZEND_METHOD(ion_Timestamp, __toString)
430 {
431 php_ion_timestamp *obj = php_ion_obj(timestamp, Z_OBJ_P(ZEND_THIS));
432 OBJ_CHECK(obj);
433
434 ZEND_PARSE_PARAMETERS_NONE();
435
436 zval fmt;
437 ZVAL_NULL(&fmt);
438 zend_call_method_with_1_params(&obj->std, obj->std.ce, NULL, "format", return_value,
439 zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("format"), 0, &fmt));
440 }
441 static ZEND_METHOD(ion_Decimal_Context, __construct)
442 {
443 php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(ZEND_THIS));
444 PTR_CHECK(obj);
445
446 zend_bool clamp;
447 zend_object *o_round = NULL;
448 zend_long digits, emax, emin, round;
449 ZEND_PARSE_PARAMETERS_START(5, 5)
450 Z_PARAM_LONG(digits)
451 Z_PARAM_LONG(emax)
452 Z_PARAM_LONG(emin)
453 Z_PARAM_OBJ_OF_CLASS_OR_LONG(o_round, ce_Decimal_Context_Rounding, round)
454 Z_PARAM_BOOL(clamp)
455 ZEND_PARSE_PARAMETERS_END();
456
457 if (o_round) {
458 round = Z_LVAL_P(zend_enum_fetch_case_value(o_round));
459 }
460 php_ion_decimal_ctx_init(&obj->ctx, digits, emax, emin, round, clamp);
461 php_ion_decimal_ctx_ctor(obj, o_round);
462 }
463 static inline void make_decimal_ctx(INTERNAL_FUNCTION_PARAMETERS, int kind)
464 {
465 ZEND_PARSE_PARAMETERS_NONE();
466
467 object_init_ex(return_value, ce_Decimal_Context);
468 php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(return_value));
469 decContextDefault(&obj->ctx, kind);
470 php_ion_decimal_ctx_ctor(obj, NULL);
471 }
472 static ZEND_METHOD(ion_Decimal_Context, Dec32)
473 {
474 make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL32);
475 }
476 static ZEND_METHOD(ion_Decimal_Context, Dec64)
477 {
478 make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL64);
479 }
480 static ZEND_METHOD(ion_Decimal_Context, Dec128)
481 {
482 make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL128);
483 }
484 static ZEND_METHOD(ion_Decimal_Context, DecMax)
485 {
486 zend_object *o_round = NULL;
487 zend_long round = DEC_ROUND_HALF_EVEN;
488 ZEND_PARSE_PARAMETERS_START(0, 1)
489 Z_PARAM_OPTIONAL
490 Z_PARAM_OBJ_OF_CLASS_OR_LONG(o_round, ce_Decimal_Context_Rounding, round)
491 ZEND_PARSE_PARAMETERS_END();
492
493 if (o_round) {
494 round = Z_LVAL_P(zend_enum_fetch_case_value(o_round));
495 }
496 object_init_ex(return_value, ce_Decimal_Context);
497 php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(return_value));
498 php_ion_decimal_ctx_init_max(&obj->ctx, round);
499 php_ion_decimal_ctx_ctor(obj, o_round);
500 }
501 static ZEND_METHOD(ion_Decimal, __construct)
502 {
503 php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
504 PTR_CHECK(obj);
505
506 zend_long num;
507 zend_string *zstr;
508 ZEND_PARSE_PARAMETERS_START(1, 2)
509 Z_PARAM_STR_OR_LONG(zstr, num)
510 Z_PARAM_OPTIONAL
511 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->ctx, ce_Decimal_Context)
512 ZEND_PARSE_PARAMETERS_END();
513
514 if (obj->ctx) {
515 GC_ADDREF(obj->ctx);
516 } else {
517 zval zdc;
518 object_init_ex(&zdc, ce_Decimal_Context);
519 obj->ctx = Z_OBJ(zdc);
520 php_ion_decimal_ctx_ctor(php_ion_obj(decimal_ctx, obj->ctx), NULL);
521 }
522
523 decContext *ctx = &php_ion_obj(decimal_ctx, obj->ctx)->ctx;
524
525 if (zstr) {
526 ION_CHECK(ion_decimal_from_string(&obj->dec, zstr->val, ctx), OBJ_RELEASE(obj->ctx));
527 } else {
528 php_ion_decimal_from_zend_long(&obj->dec, ctx, num);
529 }
530
531 php_ion_decimal_ctor(obj);
532 OBJ_RELEASE(obj->ctx);
533 }
534 static ZEND_METHOD(ion_Decimal, equals)
535 {
536 php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
537 PTR_CHECK(obj);
538
539 zend_object *dec_obj;
540 ZEND_PARSE_PARAMETERS_START(1, 1)
541 Z_PARAM_OBJ_OF_CLASS(dec_obj, ce_Decimal)
542 ZEND_PARSE_PARAMETERS_END();
543
544 BOOL is = FALSE;
545 ION_CHECK(ion_decimal_equals(&obj->dec, &php_ion_obj(decimal, dec_obj)->dec,
546 obj->ctx ? &php_ion_obj(decimal_ctx, obj->ctx)->ctx : NULL, &is));
547 RETURN_BOOL(is);
548 }
549 static ZEND_METHOD(ion_Decimal, __toString)
550 {
551 php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
552 PTR_CHECK(obj);
553
554 ZEND_PARSE_PARAMETERS_NONE();
555
556 RETURN_STR(php_ion_decimal_to_string(&obj->dec));
557 }
558 static ZEND_METHOD(ion_Decimal, toInt)
559 {
560 php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
561 PTR_CHECK(obj);
562
563 ZEND_PARSE_PARAMETERS_NONE();
564
565 zend_long l;
566 php_ion_decimal_to_zend_long(&obj->dec, &php_ion_obj(decimal_ctx, obj->ctx)->ctx, &l);
567 RETURN_LONG(l);
568 }
569 static ZEND_METHOD(ion_Decimal, isInt)
570 {
571 php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
572 PTR_CHECK(obj);
573
574 ZEND_PARSE_PARAMETERS_NONE();
575
576 RETURN_BOOL(ion_decimal_is_integer(&obj->dec));
577 }
578 static ZEND_METHOD(ion_LOB, __construct)
579 {
580 zend_string *value;
581 zend_object *type = NULL;
582 ZEND_PARSE_PARAMETERS_START(1, 2)
583 Z_PARAM_STR(value)
584 Z_PARAM_OPTIONAL
585 Z_PARAM_OBJ_OF_CLASS(type, ce_Type)
586 ZEND_PARSE_PARAMETERS_END();
587
588 if (!type) {
589 type = zend_enum_get_case_cstr(ce_Type, "CLob");
590 }
591 update_property_obj(Z_OBJ_P(ZEND_THIS), ZEND_STRL("type"), type);
592 zend_update_property_str(Z_OBJCE_P(ZEND_THIS), Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), value);
593 }
594 static ZEND_METHOD(ion_Reader_Options, __construct)
595 {
596 php_ion_reader_options *opt = php_ion_obj(reader_options, Z_OBJ_P(ZEND_THIS));
597 zend_bool ret_sys_val = false, skip_validation = false;
598 zend_long ch_nl = 0xa, max_depth = 10, max_ann = 10, max_ann_buf = 512,
599 sym_thr = 0x4000, uval_thr = 0x4000, chunk_thr = 0x4000, alloc_pgsz = 0x10000;
600
601 PTR_CHECK(opt);
602
603 ZEND_PARSE_PARAMETERS_START(0, 13)
604 Z_PARAM_OPTIONAL
605 // public readonly ?\ion\Catalog $catalog = null,
606 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->cat, ce_Catalog)
607 // public readonly ?\ion\Decimal\Context $decimalContext = null,
608 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->dec_ctx, ce_Decimal_Context)
609 // public readonly ?\Closure $onContextChange = null,
610 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->cb, zend_ce_closure);
611 // public readonly bool $returnSystemValues = false,
612 Z_PARAM_BOOL(ret_sys_val)
613 // public readonly int $newLine = 0xa,
614 Z_PARAM_LONG(ch_nl)
615 // public readonly int $maxContainerDepth = 10,
616 Z_PARAM_LONG(max_depth)
617 // public readonly int $maxAnnotations = 10,
618 Z_PARAM_LONG(max_ann)
619 // public readonly int $maxAnnotationBuffered = 512,
620 Z_PARAM_LONG(max_ann_buf)
621 // public readonly int $symbolThreshold = 0x4000,
622 Z_PARAM_LONG(sym_thr)
623 // public readonly int $userValueThreshold = 0x4000,
624 Z_PARAM_LONG(uval_thr)
625 // public readonly int $chunkThreshold = 0x4000,
626 Z_PARAM_LONG(chunk_thr)
627 // public readonly int $allocationPageSize = 0x10000,
628 Z_PARAM_LONG(alloc_pgsz)
629 // public readonly bool $skipCharacterValidation = false,
630 Z_PARAM_BOOL(skip_validation)
631 ZEND_PARSE_PARAMETERS_END();
632
633 if (opt->cb) {
634 zval zcb;
635 ZVAL_OBJ(&zcb, opt->cb);
636 zend_fcall_info_init(&zcb, 0, &opt->ccn.fci, &opt->ccn.fcc, NULL, NULL);
637 opt->opt.context_change_notifier.context = &opt->ccn;
638 update_property_obj(&opt->std, ZEND_STRL("onContextChange"), opt->cb);
639 } else {
640 zend_update_property_null(NULL, &opt->std, ZEND_STRL("onContextChange"));
641 }
642 if (opt->cat) {
643 update_property_obj(&opt->std, ZEND_STRL("catalog"), opt->cat);
644 opt->opt.pcatalog = php_ion_obj(catalog, opt->cat)->cat;
645 } else {
646 zend_update_property_null(NULL, &opt->std, ZEND_STRL("catalog"));
647 }
648 if (opt->dec_ctx) {
649 update_property_obj(&opt->std, ZEND_STRL("decimalContext"), opt->dec_ctx);
650 opt->opt.decimal_context = &php_ion_obj(decimal_ctx, opt->dec_ctx)->ctx;
651 } else {
652 zend_update_property_null(NULL, &opt->std, ZEND_STRL("decimalContext"));
653 }
654 zend_update_property_bool(opt->std.ce, &opt->std, ZEND_STRL("returnSystemValues"),
655 opt->opt.return_system_values = ret_sys_val);
656 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("newLine"),
657 opt->opt.new_line_char = ch_nl);
658 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("maxContainerDepth"),
659 opt->opt.max_container_depth = max_depth);
660 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("maxAnnotations"),
661 opt->opt.max_annotation_count = max_ann);
662 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("maxAnnotationBuffered"),
663 opt->opt.max_annotation_buffered = max_ann_buf);
664 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("symbolThreshold"),
665 opt->opt.symbol_threshold = sym_thr);
666 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("userValueThreshold"),
667 opt->opt.user_value_threshold = uval_thr);
668 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("chunkThreshold"),
669 opt->opt.chunk_threshold = chunk_thr);
670 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("allocationPageSize"),
671 opt->opt.allocation_page_size = alloc_pgsz);
672 zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("skipCharacterValidation"),
673 opt->opt.skip_character_validation = skip_validation);
674 }
675 static ZEND_METHOD(ion_Reader_Reader, hasChildren)
676 {
677 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
678
679 OBJ_CHECK(obj);
680 ZEND_PARSE_PARAMETERS_NONE();
681
682 ION_TYPE t;
683 ION_CHECK(ion_reader_get_type(obj->reader, &t));
684 switch (ION_TYPE_INT(t)) {
685 case tid_LIST_INT:
686 case tid_SEXP_INT:
687 case tid_STRUCT_INT:
688 RETVAL_TRUE;
689 break;
690 default:
691 RETVAL_FALSE;
692 break;
693 }
694 }
695 static ZEND_METHOD(ion_Reader_Reader, getChildren)
696 {
697 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
698 OBJ_CHECK(obj);
699
700 ZEND_PARSE_PARAMETERS_NONE();
701
702 ION_CHECK(ion_reader_step_in(obj->reader));
703
704 RETURN_ZVAL(ZEND_THIS, 1, 0);
705 }
706 static ZEND_METHOD(ion_Reader_Reader, rewind)
707 {
708 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
709 OBJ_CHECK(obj);
710
711 ZEND_PARSE_PARAMETERS_NONE();
712
713 ION_CHECK(ion_reader_next(obj->reader, &obj->state));
714 }
715 static ZEND_METHOD(ion_Reader_Reader, next)
716 {
717 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
718 OBJ_CHECK(obj);
719
720 ZEND_PARSE_PARAMETERS_NONE();
721
722 if (obj->state == tid_EOF) {
723 SIZE depth = 0;
724 ION_CHECK(ion_reader_get_depth(obj->reader, &depth));
725 if (depth) {
726 ION_CHECK(ion_reader_step_out(obj->reader));
727 }
728 }
729 ION_CHECK(ion_reader_next(obj->reader, &obj->state));
730 }
731 static ZEND_METHOD(ion_Reader_Reader, valid)
732 {
733 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
734 OBJ_CHECK(obj);
735
736 ZEND_PARSE_PARAMETERS_NONE();
737 RETURN_BOOL(obj->state != tid_none && obj->state != tid_EOF);
738 }
739 static ZEND_METHOD(ion_Reader_Reader, key)
740 {
741 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
742 OBJ_CHECK(obj);
743
744 ZEND_PARSE_PARAMETERS_NONE();
745 RETURN_IONTYPE(obj->state);
746 }
747 static ZEND_METHOD(ion_Reader_Reader, current)
748 {
749 ZEND_PARSE_PARAMETERS_NONE();
750 RETURN_ZVAL(ZEND_THIS, 1, 0);
751 }
752 static ZEND_METHOD(ion_Reader_Reader, getType)
753 {
754 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
755 OBJ_CHECK(obj);
756
757 ZEND_PARSE_PARAMETERS_NONE();
758
759 ION_TYPE typ;
760 ION_CHECK(ion_reader_get_type(obj->reader, &typ));
761 RETURN_IONTYPE(typ);
762 }
763 static ZEND_METHOD(ion_Reader_Reader, hasAnnotations)
764 {
765 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
766 OBJ_CHECK(obj);
767
768 ZEND_PARSE_PARAMETERS_NONE();
769
770 BOOL has = FALSE;
771 ION_CHECK(ion_reader_has_any_annotations(obj->reader, &has));
772 RETURN_BOOL(has);
773 }
774 static ZEND_METHOD(ion_Reader_Reader, hasAnnotation)
775 {
776 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
777 OBJ_CHECK(obj);
778
779 zend_string *ann_zstr;
780 ZEND_PARSE_PARAMETERS_START(1, 1);
781 Z_PARAM_STR(ann_zstr);
782 ZEND_PARSE_PARAMETERS_END();
783
784 ION_STRING ann_istr;
785 BOOL has = FALSE;
786 ION_CHECK(ion_reader_has_annotation(obj->reader, ion_string_from_zend(&ann_istr, ann_zstr), &has));
787 RETURN_BOOL(has);
788 }
789 static ZEND_METHOD(ion_Reader_Reader, isNull)
790 {
791 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
792 OBJ_CHECK(obj);
793
794 ZEND_PARSE_PARAMETERS_NONE();
795
796 BOOL is = FALSE;
797 ION_CHECK(ion_reader_is_null(obj->reader, &is));
798 RETURN_BOOL(is);
799 }
800 static ZEND_METHOD(ion_Reader_Reader, isInStruct)
801 {
802 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
803 OBJ_CHECK(obj);
804
805 ZEND_PARSE_PARAMETERS_NONE();
806
807 BOOL is = FALSE;
808 ION_CHECK(ion_reader_is_in_struct(obj->reader, &is));
809 RETURN_BOOL(is);
810 }
811 static ZEND_METHOD(ion_Reader_Reader, getFieldName)
812 {
813 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
814 OBJ_CHECK(obj);
815
816 ZEND_PARSE_PARAMETERS_NONE();
817
818 ION_STRING name;
819 ION_CHECK(ion_reader_get_field_name(obj->reader, &name));
820 RETURN_STRINGL((char *) name.value, name.length);
821 }
822 static ZEND_METHOD(ion_Reader_Reader, getFieldNameSymbol)
823 {
824 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
825 OBJ_CHECK(obj);
826
827 ZEND_PARSE_PARAMETERS_NONE();
828
829 ION_SYMBOL *sym_ptr;
830 ION_CHECK(ion_reader_get_field_name_symbol(obj->reader, &sym_ptr));
831
832 php_ion_symbol_zval(sym_ptr, return_value);
833 }
834 static ZEND_METHOD(ion_Reader_Reader, getAnnotations)
835 {
836 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
837 OBJ_CHECK(obj);
838
839 ZEND_PARSE_PARAMETERS_NONE();
840
841 int32_t count, max;
842 if (obj->opt) {
843 max = php_ion_obj(reader_options, obj->opt)->opt.max_annotation_count;
844 } else {
845 max = 10;
846 }
847 ION_STRING *ptr = ecalloc(sizeof(*ptr), max);
848 iERR err = ion_reader_get_annotations(obj->reader, ptr, max, &count);
849 if (!err) {
850 array_init_size(return_value, count);
851 for (int32_t i = 0; i < count; ++i) {
852 add_next_index_str(return_value, zend_string_from_ion(&ptr[i]));
853 }
854 }
855 efree(ptr);
856 ION_CHECK(err);
857 }
858 static ZEND_METHOD(ion_Reader_Reader, getAnnotationSymbols)
859 {
860 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
861 OBJ_CHECK(obj);
862
863 ZEND_PARSE_PARAMETERS_NONE();
864
865 int32_t count, max = php_ion_obj(reader_options, obj->opt)->opt.max_annotation_count;
866 ION_SYMBOL *ptr = ecalloc(sizeof(*ptr), max);
867 iERR err = ion_reader_get_annotation_symbols(obj->reader, ptr, max, &count);
868 if (!err) {
869 array_init_size(return_value, count);
870 for (int32_t i = 0; i < count; ++i) {
871 zval zsym;
872 php_ion_symbol_zval(&ptr[i], &zsym);
873 add_next_index_zval(return_value, &zsym);
874 }
875 }
876 efree(ptr);
877 ION_CHECK(err);
878 }
879 static ZEND_METHOD(ion_Reader_Reader, countAnnotations)
880 {
881 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
882 OBJ_CHECK(obj);
883
884 ZEND_PARSE_PARAMETERS_NONE();
885
886 SIZE sz = 0;
887 ION_CHECK(ion_reader_get_annotation_count(obj->reader, &sz));
888 RETURN_LONG(sz);
889 }
890 static ZEND_METHOD(ion_Reader_Reader, getAnnotation)
891 {
892 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
893 OBJ_CHECK(obj);
894
895 zend_long idx;
896 ZEND_PARSE_PARAMETERS_START(1, 1)
897 Z_PARAM_LONG(idx);
898 ZEND_PARSE_PARAMETERS_END();
899
900 ION_STRING ann;
901 ION_CHECK(ion_reader_get_an_annotation(obj->reader, idx, &ann));
902 RETURN_STRINGL((char *) ann.value, ann.length);
903 }
904 static ZEND_METHOD(ion_Reader_Reader, getAnnotationSymbol)
905 {
906 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
907 OBJ_CHECK(obj);
908
909 zend_long idx;
910 ZEND_PARSE_PARAMETERS_START(1, 1)
911 Z_PARAM_LONG(idx);
912 ZEND_PARSE_PARAMETERS_END();
913
914 ION_SYMBOL sym;
915 ION_CHECK(ion_reader_get_an_annotation_symbol(obj->reader, idx, &sym));
916 php_ion_symbol_zval(&sym, return_value);
917 }
918 static ZEND_METHOD(ion_Reader_Reader, readNull)
919 {
920 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
921 OBJ_CHECK(obj);
922
923 ZEND_PARSE_PARAMETERS_NONE();
924
925 ION_TYPE typ;
926 ION_CHECK(ion_reader_read_null(obj->reader, &typ));
927 RETURN_IONTYPE(typ);
928 }
929 static ZEND_METHOD(ion_Reader_Reader, readBool)
930 {
931 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
932 OBJ_CHECK(obj);
933
934 ZEND_PARSE_PARAMETERS_NONE();
935
936 BOOL b;
937 ION_CHECK(ion_reader_read_bool(obj->reader, &b));
938 RETURN_BOOL(b);
939 }
940 static ZEND_METHOD(ion_Reader_Reader, readInt)
941 {
942 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
943 OBJ_CHECK(obj);
944
945 ZEND_PARSE_PARAMETERS_NONE();
946
947 php_ion_reader_read_int(obj->reader, return_value);
948 }
949 static ZEND_METHOD(ion_Reader_Reader, readFloat)
950 {
951 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
952 OBJ_CHECK(obj);
953
954 ZEND_PARSE_PARAMETERS_NONE();
955
956 ION_CHECK(ion_reader_read_double(obj->reader, &Z_DVAL_P(return_value)));
957 }
958 static ZEND_METHOD(ion_Reader_Reader, readDecimal)
959 {
960 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
961 OBJ_CHECK(obj);
962
963 ZEND_PARSE_PARAMETERS_NONE();
964
965 object_init_ex(return_value, ce_Decimal);
966 php_ion_decimal *dec = php_ion_obj(decimal, Z_OBJ_P(return_value));
967 ION_CHECK(ion_reader_read_ion_decimal(obj->reader, &dec->dec));
968 php_ion_decimal_ctor(dec);
969 }
970 static ZEND_METHOD(ion_Reader_Reader, readTimestamp)
971 {
972 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
973 OBJ_CHECK(obj);
974
975 ZEND_PARSE_PARAMETERS_NONE();
976
977 php_ion_reader_read_timestamp(obj->reader, obj->opt ? &php_ion_obj(reader_options, obj->opt)->opt : NULL, return_value);
978 }
979 static ZEND_METHOD(ion_Reader_Reader, readSymbol)
980 {
981 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
982 OBJ_CHECK(obj);
983
984 ZEND_PARSE_PARAMETERS_NONE();
985
986 ION_SYMBOL sym;
987 ION_CHECK(ion_reader_read_ion_symbol(obj->reader, &sym));
988 php_ion_symbol_zval(&sym, return_value);
989 }
990 static ZEND_METHOD(ion_Reader_Reader, readString)
991 {
992 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
993 OBJ_CHECK(obj);
994
995 ZEND_PARSE_PARAMETERS_NONE();
996
997 ION_STRING str;
998 ION_CHECK(ion_reader_read_string(obj->reader, &str));
999 RETURN_STRINGL((char *) str.value, str.length);
1000 }
1001
1002 typedef iERR (*read_part_fn)(ION_READER *, BYTE *, SIZE, SIZE *);
1003 static void read_part(INTERNAL_FUNCTION_PARAMETERS, read_part_fn fn)
1004 {
1005 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1006 OBJ_CHECK(obj);
1007
1008 zval *ref;
1009 zend_string *zstr;
1010 zend_long len = 0x1000;
1011 ZEND_PARSE_PARAMETERS_START(1, 1)
1012 Z_PARAM_ZVAL(ref)
1013 Z_PARAM_OPTIONAL
1014 Z_PARAM_LONG(len)
1015 ZEND_PARSE_PARAMETERS_END();
1016
1017 ZVAL_DEREF(ref);
1018
1019 if (Z_TYPE_P(ref) == IS_STRING && Z_STRLEN_P(ref) == len) {
1020 /* reuse */
1021 zstr = Z_STR_P(ref);
1022 } else {
1023 zval_dtor(ref);
1024 zstr = zend_string_alloc(len, 0);
1025 }
1026
1027 SIZE read = 0;
1028 ION_CHECK(fn(obj->reader, (BYTE *) zstr->val, zstr->len, &read), goto fail);
1029 if (read > 0) {
1030 if (read < zstr->len) {
1031 zstr = zend_string_truncate(zstr, read, 0);
1032 }
1033 ZVAL_STR(ref, zstr);
1034 RETURN_TRUE;
1035 }
1036 fail:
1037 if (zstr != Z_STR_P(ref)) {
1038 zend_string_release(zstr);
1039 }
1040 ZVAL_EMPTY_STRING(ref);
1041 RETURN_FALSE;
1042 }
1043 static ZEND_METHOD(ion_Reader_Reader, readStringPart)
1044 {
1045 read_part(INTERNAL_FUNCTION_PARAM_PASSTHRU, ion_reader_read_partial_string);
1046 }
1047 static ZEND_METHOD(ion_Reader_Reader, readLob)
1048 {
1049 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1050 OBJ_CHECK(obj);
1051
1052 ZEND_PARSE_PARAMETERS_NONE();
1053
1054 php_ion_reader_read_lob(obj->reader, return_value);
1055 }
1056 static ZEND_METHOD(ion_Reader_Reader, readLobPart)
1057 {
1058 read_part(INTERNAL_FUNCTION_PARAM_PASSTHRU, ion_reader_read_lob_partial_bytes);
1059 }
1060 static ZEND_METHOD(ion_Reader_Reader, getPosition)
1061 {
1062 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1063 OBJ_CHECK(obj);
1064
1065 ZEND_PARSE_PARAMETERS_NONE();
1066
1067 int64_t bytes = 0;
1068 int32_t dummy;
1069 ION_CHECK(ion_reader_get_position(obj->reader, &bytes, &dummy, &dummy));
1070 RETURN_LONG(bytes);
1071 }
1072 static ZEND_METHOD(ion_Reader_Reader, getDepth)
1073 {
1074 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1075 OBJ_CHECK(obj);
1076
1077 ZEND_PARSE_PARAMETERS_NONE();
1078
1079 SIZE depth = 0;
1080 ION_CHECK(ion_reader_get_depth(obj->reader, &depth));
1081 RETURN_LONG(depth);
1082 }
1083 static ZEND_METHOD(ion_Reader_Reader, seek)
1084 {
1085 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1086 OBJ_CHECK(obj);
1087
1088 zend_long off, len = -1;
1089 ZEND_PARSE_PARAMETERS_START(1, 2)
1090 Z_PARAM_LONG(off)
1091 Z_PARAM_OPTIONAL
1092 Z_PARAM_LONG(len)
1093 ZEND_PARSE_PARAMETERS_END();
1094
1095 ION_CHECK(ion_reader_seek(obj->reader, off, len));
1096 }
1097 static ZEND_METHOD(ion_Reader_Reader, getValueOffset)
1098 {
1099 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1100 OBJ_CHECK(obj);
1101
1102 ZEND_PARSE_PARAMETERS_NONE();
1103
1104 POSITION off = 0;
1105 ION_CHECK(ion_reader_get_value_offset(obj->reader, &off));
1106 RETURN_LONG(off);
1107 }
1108 static ZEND_METHOD(ion_Reader_Reader, getValueLength)
1109 {
1110 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1111 OBJ_CHECK(obj);
1112
1113 ZEND_PARSE_PARAMETERS_NONE();
1114
1115 SIZE len = 0;
1116 ION_CHECK(ion_reader_get_value_length(obj->reader, &len));
1117 RETURN_LONG(len);
1118 }
1119 static ZEND_METHOD(ion_Reader_Buffer_Reader, __construct)
1120 {
1121 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1122 PTR_CHECK(obj);
1123
1124 zend_string *zstr;
1125 ZEND_PARSE_PARAMETERS_START(1, 2)
1126 Z_PARAM_STR(zstr)
1127 Z_PARAM_OPTIONAL
1128 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1129 ZEND_PARSE_PARAMETERS_END();
1130
1131 obj->type = BUFFER_READER;
1132 obj->buffer = zend_string_copy(zstr);
1133
1134 php_ion_reader_ctor(obj);
1135 }
1136 static ZEND_METHOD(ion_Reader_Buffer_Reader, getBuffer)
1137 {
1138 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1139 OBJ_CHECK(obj);
1140
1141 ZEND_PARSE_PARAMETERS_NONE();
1142 RETURN_STR_COPY(obj->buffer);
1143 }
1144
1145 static ZEND_METHOD(ion_Reader_Stream_Reader, __construct)
1146 {
1147 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1148 PTR_CHECK(obj);
1149
1150 zval *zstream;
1151 ZEND_PARSE_PARAMETERS_START(1, 2)
1152 Z_PARAM_RESOURCE(zstream)
1153 Z_PARAM_OPTIONAL
1154 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1155 ZEND_PARSE_PARAMETERS_END();
1156
1157 obj->type = STREAM_READER;
1158 php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1159
1160 php_ion_reader_ctor(obj);
1161 }
1162 static ZEND_METHOD(ion_Reader_Stream_Reader, getStream)
1163 {
1164 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1165 OBJ_CHECK(obj);
1166
1167 ZEND_PARSE_PARAMETERS_NONE();
1168 PTR_CHECK(obj->stream.ptr);
1169
1170 GC_ADDREF(obj->stream.ptr->res);
1171 RETURN_RES(obj->stream.ptr->res);
1172 }
1173 static ZEND_METHOD(ion_Reader_Stream_Reader, resetStream)
1174 {
1175 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1176 OBJ_CHECK(obj);
1177
1178 zval *zstream;
1179 ZEND_PARSE_PARAMETERS_START(1, 1);
1180 Z_PARAM_RESOURCE(zstream);
1181 ZEND_PARSE_PARAMETERS_END();
1182
1183 ION_CHECK(ion_reader_reset_stream(&obj->reader, obj, php_ion_reader_stream_handler));
1184
1185 if (obj->stream.ptr) {
1186 zend_list_delete(obj->stream.ptr->res);
1187 }
1188 php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1189 PTR_CHECK(obj->stream.ptr);
1190 Z_ADDREF_P(zstream);
1191 }
1192 static ZEND_METHOD(ion_Reader_Stream_Reader, resetStreamWithLength)
1193 {
1194 php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1195 OBJ_CHECK(obj);
1196
1197 zval *zstream;
1198 zend_long length;
1199 ZEND_PARSE_PARAMETERS_START(1, 2);
1200 Z_PARAM_RESOURCE(zstream);
1201 Z_PARAM_LONG(length)
1202 ZEND_PARSE_PARAMETERS_END();
1203
1204 ION_CHECK(ion_reader_reset_stream_with_length(&obj->reader, obj, php_ion_reader_stream_handler, length));
1205
1206 if (obj->stream.ptr) {
1207 zend_list_delete(obj->stream.ptr->res);
1208 }
1209 php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1210 PTR_CHECK(obj->stream.ptr);
1211 Z_ADDREF_P(zstream);
1212 }
1213 static ZEND_METHOD(ion_Writer_Options, __construct)
1214 {
1215 php_ion_writer_options *obj = php_ion_obj(writer_options, Z_OBJ_P(ZEND_THIS));
1216 PTR_CHECK(obj);
1217
1218 zend_bool binary = false, compact_floats = false, escape = false, pretty = false,
1219 tabs = true, small_cntr_inl = true, suppress_sys = false, flush = false;
1220 zend_long indent = 2, max_depth = 10, max_ann = 10, temp = 0x4000, alloc = 0x10000;
1221 ZEND_PARSE_PARAMETERS_START(0, 16)
1222 Z_PARAM_OPTIONAL
1223 //public readonly ?\ion\Catalog $catalog = null,
1224 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->cat, ce_Catalog)
1225 //public readonly ?\ion\Decimal\Context $decimalContext = null,
1226 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->dec_ctx, ce_Decimal_Context)
1227 //public readonly bool $outputBinary = false,
1228 Z_PARAM_BOOL(binary)
1229 //public readonly bool $compactFloats = false,
1230 Z_PARAM_BOOL(compact_floats)
1231 //public readonly bool $escapeNonAscii = false,
1232 Z_PARAM_BOOL(escape)
1233 //public readonly bool $prettyPrint = false,
1234 Z_PARAM_BOOL(pretty)
1235 //public readonly bool $indentTabs = true,
1236 Z_PARAM_BOOL(tabs)
1237 //public readonly int $indentSize = 2,
1238 Z_PARAM_LONG(indent)
1239 //public readonly bool $smallContainersInline = true,
1240 Z_PARAM_BOOL(small_cntr_inl)
1241 //public readonly bool $suppressSystemValues = false,
1242 Z_PARAM_BOOL(suppress_sys)
1243 //public readonly bool $flushEveryValue = false,
1244 Z_PARAM_BOOL(flush)
1245 //public readonly int $maxContainerDepth = 10,
1246 Z_PARAM_LONG(max_depth)
1247 //public readonly int $maxAnnotations = 10,
1248 Z_PARAM_LONG(max_ann)
1249 //public readonly int $tempBufferSize = 0x4000,
1250 Z_PARAM_LONG(temp)
1251 //public readonly int $allocationPageSize = 0x10000,
1252 Z_PARAM_LONG(alloc)
1253 ZEND_PARSE_PARAMETERS_END();
1254
1255 if (obj->cat) {
1256 update_property_obj(&obj->std, ZEND_STRL("catalog"), obj->cat);
1257 obj->opt.pcatalog = php_ion_obj(catalog, obj->cat)->cat;
1258 } else {
1259 zend_update_property_null(NULL, &obj->std, ZEND_STRL("catalog"));
1260 }
1261 if (obj->dec_ctx) {
1262 update_property_obj(&obj->std, ZEND_STRL("decimalContext"), obj->dec_ctx);
1263 obj->opt.decimal_context = &php_ion_obj(decimal_ctx, obj->dec_ctx)->ctx;
1264 } else {
1265 zend_update_property_null(NULL, &obj->std, ZEND_STRL("decimalContext"));
1266 }
1267 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("outputBinary"),
1268 obj->opt.output_as_binary = binary);
1269 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("compactFloats"),
1270 obj->opt.compact_floats = compact_floats);
1271 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("escapeNonAscii"),
1272 obj->opt.escape_all_non_ascii = escape);
1273 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("prettyPrint"),
1274 obj->opt.pretty_print = pretty);
1275 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("indentTabs"),
1276 obj->opt.indent_with_tabs = tabs);
1277 zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("indentSize"),
1278 obj->opt.indent_size = indent);
1279 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("smallContainersInline"),
1280 obj->opt.small_containers_in_line = small_cntr_inl);
1281 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("suppressSystemValues"),
1282 obj->opt.supress_system_values = suppress_sys);
1283 zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("flushEveryValue"),
1284 obj->opt.flush_every_value = flush);
1285 zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxContainerDepth"),
1286 obj->opt.max_container_depth = max_depth);
1287 zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxAnnotations"),
1288 obj->opt.max_annotation_count = max_ann);
1289 zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("tempBufferSize"),
1290 obj->opt.temp_buffer_size = temp);
1291 zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("allocationPageSize"),
1292 obj->opt.allocation_page_size = alloc);
1293 }
1294 static ZEND_METHOD(ion_Writer_Writer, writeNull)
1295 {
1296 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1297 OBJ_CHECK(obj);
1298
1299 ZEND_PARSE_PARAMETERS_NONE();
1300
1301 ION_CHECK(ion_writer_write_null(obj->writer));
1302 }
1303 static ZEND_METHOD(ion_Writer_Writer, writeTypedNull)
1304 {
1305 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1306 OBJ_CHECK(obj);
1307
1308 zend_object *typ_obj;
1309 ZEND_PARSE_PARAMETERS_START(1, 1)
1310 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1311 ZEND_PARSE_PARAMETERS_END();
1312
1313 ION_CHECK(ion_writer_write_typed_null(obj->writer, ion_type_from_enum(typ_obj)));
1314 }
1315 static ZEND_METHOD(ion_Writer_Writer, writeBool)
1316 {
1317 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1318 OBJ_CHECK(obj);
1319
1320 zend_bool b;
1321 ZEND_PARSE_PARAMETERS_START(1, 1)
1322 Z_PARAM_BOOL(b)
1323 ZEND_PARSE_PARAMETERS_END();
1324
1325 ION_CHECK(ion_writer_write_bool(obj->writer, b));
1326 }
1327 static ZEND_METHOD(ion_Writer_Writer, writeInt)
1328 {
1329 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1330 OBJ_CHECK(obj);
1331
1332 zend_long l;
1333 zend_string *s;
1334 ZEND_PARSE_PARAMETERS_START(1, 1)
1335 Z_PARAM_STR_OR_LONG(s, l)
1336 ZEND_PARSE_PARAMETERS_END();
1337
1338 if (s) {
1339 ION_INT *i;
1340 ION_CHECK(ion_int_alloc(obj->writer, &i));
1341 ION_CHECK(ion_int_from_chars(i, s->val, s->len));
1342 ION_CHECK(ion_writer_write_ion_int(obj->writer, i));
1343 ion_int_free(i);
1344 } else {
1345 ION_CHECK(ion_writer_write_int64(obj->writer, l));
1346 }
1347 }
1348 static ZEND_METHOD(ion_Writer_Writer, writeFloat)
1349 {
1350 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1351 OBJ_CHECK(obj);
1352
1353 double d;
1354 ZEND_PARSE_PARAMETERS_START(1, 1)
1355 Z_PARAM_DOUBLE(d)
1356 ZEND_PARSE_PARAMETERS_END();
1357
1358 ION_CHECK(ion_writer_write_double(obj->writer, d));
1359 }
1360 static ZEND_METHOD(ion_Writer_Writer, writeDecimal)
1361 {
1362 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1363 OBJ_CHECK(obj);
1364
1365 zend_object *dec_obj;
1366 zend_string *dec_str;
1367 ZEND_PARSE_PARAMETERS_START(1, 1)
1368 Z_PARAM_OBJ_OF_CLASS_OR_STR(dec_obj, ce_Decimal, dec_str)
1369 ZEND_PARSE_PARAMETERS_END();
1370
1371 if (dec_str) {
1372 ION_STRING s;
1373 ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&s, dec_str)));
1374 } else {
1375 php_ion_decimal *dec = php_ion_obj(decimal, dec_obj);
1376 ION_CHECK(ion_writer_write_ion_decimal(obj->writer, &dec->dec));
1377 }
1378 }
1379 static ZEND_METHOD(ion_Writer_Writer, writeTimestamp)
1380 {
1381 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1382 OBJ_CHECK(obj);
1383
1384 zend_object *ts_obj;
1385 zend_string *ts_str;
1386 ZEND_PARSE_PARAMETERS_START(1, 1)
1387 Z_PARAM_OBJ_OF_CLASS_OR_STR(ts_obj, ce_Timestamp, ts_str)
1388 ZEND_PARSE_PARAMETERS_END();
1389
1390 decContext *ctx = NULL;
1391 if (obj->opt) {
1392 ctx = php_ion_obj(reader_options, obj->opt)->opt.decimal_context;
1393 }
1394
1395 ION_TIMESTAMP tmp = {0};
1396 if (ts_str) {
1397 SIZE used;
1398 ION_CHECK(ion_timestamp_parse(&tmp, ts_str->val, ts_str->len, &used, ctx));
1399 } else {
1400 php_ion_timestamp *ts = php_ion_obj(timestamp, ts_obj);
1401 OBJ_CHECK(ts);
1402 ion_timestamp_from_php(&tmp, ts, ctx);
1403 }
1404 ION_CHECK(ion_writer_write_timestamp(obj->writer, &tmp));
1405 }
1406 static ZEND_METHOD(ion_Writer_Writer, writeSymbol)
1407 {
1408 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1409 OBJ_CHECK(obj);
1410
1411 zend_object *sym_obj;
1412 zend_string *sym_str;
1413 ZEND_PARSE_PARAMETERS_START(1, 1)
1414 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1415 ZEND_PARSE_PARAMETERS_END();
1416
1417 if (sym_str) {
1418 ION_STRING is;
1419 ION_CHECK(ion_writer_write_symbol(obj->writer, ion_string_from_zend(&is, sym_str)));
1420 } else {
1421 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1422 PTR_CHECK(sym);
1423 ION_CHECK(ion_writer_write_ion_symbol(obj->writer, &sym->sym));
1424 }
1425 }
1426 static ZEND_METHOD(ion_Writer_Writer, writeString)
1427 {
1428 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1429 OBJ_CHECK(obj);
1430
1431 zend_string *str;
1432 ZEND_PARSE_PARAMETERS_START(1, 1)
1433 Z_PARAM_STR(str)
1434 ZEND_PARSE_PARAMETERS_END();
1435
1436 ION_STRING is;
1437 ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&is, str)));
1438 }
1439 static ZEND_METHOD(ion_Writer_Writer, writeCLob)
1440 {
1441 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1442 OBJ_CHECK(obj);
1443
1444 zend_string *str;
1445 ZEND_PARSE_PARAMETERS_START(1, 1)
1446 Z_PARAM_STR(str)
1447 ZEND_PARSE_PARAMETERS_END();
1448
1449 ION_CHECK(ion_writer_write_clob(obj->writer, (BYTE *) str->val, str->len));
1450 }
1451 static ZEND_METHOD(ion_Writer_Writer, writeBLob)
1452 {
1453 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1454 OBJ_CHECK(obj);
1455
1456 zend_string *str;
1457 ZEND_PARSE_PARAMETERS_START(1, 1)
1458 Z_PARAM_STR(str)
1459 ZEND_PARSE_PARAMETERS_END();
1460
1461 ION_CHECK(ion_writer_write_blob(obj->writer, (BYTE *) str->val, str->len));
1462 }
1463 static ZEND_METHOD(ion_Writer_Writer, startLob)
1464 {
1465 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1466 OBJ_CHECK(obj);
1467
1468 zend_object *typ_obj;
1469 ZEND_PARSE_PARAMETERS_START(1, 1)
1470 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1471 ZEND_PARSE_PARAMETERS_END();
1472
1473 ION_CHECK(ion_writer_start_lob(obj->writer, ion_type_from_enum(typ_obj)));
1474 }
1475 static ZEND_METHOD(ion_Writer_Writer, appendLob)
1476 {
1477 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1478 OBJ_CHECK(obj);
1479
1480 zend_string *str;
1481 ZEND_PARSE_PARAMETERS_START(1, 1)
1482 Z_PARAM_STR(str)
1483 ZEND_PARSE_PARAMETERS_END();
1484
1485 ION_CHECK(ion_writer_append_lob(obj->writer, (BYTE *) str->val, str->len));
1486 }
1487 static ZEND_METHOD(ion_Writer_Writer, finishLob)
1488 {
1489 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1490 OBJ_CHECK(obj);
1491
1492 ZEND_PARSE_PARAMETERS_NONE();
1493
1494 ION_CHECK(ion_writer_finish_lob(obj->writer));
1495 }
1496 static ZEND_METHOD(ion_Writer_Writer, startContainer)
1497 {
1498 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1499 OBJ_CHECK(obj);
1500
1501 zend_object *typ_obj;
1502 ZEND_PARSE_PARAMETERS_START(1, 1)
1503 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1504 ZEND_PARSE_PARAMETERS_END();
1505
1506 ION_CHECK(ion_writer_start_container(obj->writer, ion_type_from_enum(typ_obj)));
1507 }
1508 static ZEND_METHOD(ion_Writer_Writer, finishContainer)
1509 {
1510 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1511 OBJ_CHECK(obj);
1512
1513 ZEND_PARSE_PARAMETERS_NONE();
1514
1515 ION_CHECK(ion_writer_finish_container(obj->writer));
1516 }
1517 static ZEND_METHOD(ion_Writer_Writer, writeFieldName)
1518 {
1519 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1520 OBJ_CHECK(obj);
1521
1522 zend_object *sym_obj;
1523 zend_string *sym_str;
1524 ZEND_PARSE_PARAMETERS_START(1, 1)
1525 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1526 ZEND_PARSE_PARAMETERS_END();
1527
1528 if (sym_str) {
1529 ION_STRING is;
1530 ION_CHECK(ion_writer_write_field_name(obj->writer, ion_string_from_zend(&is, sym_str)));
1531 } else {
1532 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1533 PTR_CHECK(sym);
1534 ION_CHECK(ion_writer_write_field_name_symbol(obj->writer, &sym->sym));
1535 }
1536 }
1537 static ZEND_METHOD(ion_Writer_Writer, writeAnnotation)
1538 {
1539 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1540 OBJ_CHECK(obj);
1541
1542 zval *args;
1543 unsigned argc;
1544 ZEND_PARSE_PARAMETERS_START(1, -1)
1545 Z_PARAM_VARIADIC('+', args, argc);
1546 ZEND_PARSE_PARAMETERS_END();
1547
1548 for (unsigned i = 0; i < argc; ++i) {
1549 switch (Z_TYPE(args[i])) {
1550 case IS_STRING:
1551 ION_STRING is;
1552 ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, Z_STR(args[i]))));
1553 break;
1554
1555 case IS_OBJECT:
1556 ION_CHECK(ion_writer_add_annotation_symbol(obj->writer, &php_ion_obj(symbol, Z_OBJ(args[i]))->sym));
1557 break;
1558 }
1559 }
1560 }
1561 static ZEND_METHOD(ion_Writer_Writer, getDepth)
1562 {
1563 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1564 OBJ_CHECK(obj);
1565
1566 ZEND_PARSE_PARAMETERS_NONE();
1567
1568 SIZE depth;
1569 ION_CHECK(ion_writer_get_depth(obj->writer, &depth));
1570 RETURN_LONG(depth);
1571 }
1572 static ZEND_METHOD(ion_Writer_Writer, flush)
1573 {
1574 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1575 OBJ_CHECK(obj);
1576
1577 ZEND_PARSE_PARAMETERS_NONE();
1578
1579 SIZE flushed;
1580 ION_CHECK(ion_writer_flush(obj->writer, &flushed));
1581 if (obj->type == BUFFER_WRITER) {
1582 smart_str_0(&obj->buffer.str);
1583 }
1584 RETURN_LONG(flushed);
1585 }
1586 static ZEND_METHOD(ion_Writer_Writer, finish)
1587 {
1588 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1589 OBJ_CHECK(obj);
1590
1591 ZEND_PARSE_PARAMETERS_NONE();
1592
1593 SIZE flushed;
1594 ION_CHECK(ion_writer_finish(obj->writer, &flushed));
1595 if (obj->type == BUFFER_WRITER) {
1596 smart_str_0(&obj->buffer.str);
1597 }
1598 RETURN_LONG(flushed);
1599 }
1600 static ZEND_METHOD(ion_Writer_Writer, writeOne)
1601 {
1602 }
1603 static ZEND_METHOD(ion_Writer_Writer, writeAll)
1604 {
1605 }
1606 static ZEND_METHOD(ion_Writer_Buffer_Writer, __construct)
1607 {
1608 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1609 PTR_CHECK(obj);
1610
1611 zval *ref;
1612 ZEND_PARSE_PARAMETERS_START(1, 2)
1613 Z_PARAM_ZVAL(ref)
1614 Z_PARAM_OPTIONAL
1615 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1616 ZEND_PARSE_PARAMETERS_END();
1617
1618 obj->type = BUFFER_WRITER;
1619 ZVAL_COPY(&obj->buffer.val, ref);
1620 zval_dtor(Z_REFVAL_P(ref));
1621
1622 php_ion_writer_ctor(obj);
1623 }
1624 static ZEND_METHOD(ion_Writer_Buffer_Writer, getBuffer)
1625 {
1626 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1627 OBJ_CHECK(obj);
1628
1629 ZEND_PARSE_PARAMETERS_NONE();
1630
1631 RETVAL_STR(zend_string_dup(obj->buffer.str.s, 0));
1632 }
1633 static ZEND_METHOD(ion_Writer_Stream_Writer, __construct)
1634 {
1635 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1636 PTR_CHECK(obj);
1637
1638 zval *zstream;
1639 ZEND_PARSE_PARAMETERS_START(1, 2)
1640 Z_PARAM_RESOURCE(zstream)
1641 Z_PARAM_OPTIONAL
1642 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1643 ZEND_PARSE_PARAMETERS_END();
1644
1645 obj->type = STREAM_WRITER;
1646 php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1647
1648 php_ion_writer_ctor(obj);
1649 }
1650 static ZEND_METHOD(ion_Writer_Stream_Writer, getStream)
1651 {
1652 php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1653 OBJ_CHECK(obj);
1654
1655 ZEND_PARSE_PARAMETERS_NONE();
1656 PTR_CHECK(obj->stream.ptr);
1657
1658 GC_ADDREF(obj->stream.ptr->res);
1659 RETURN_RES(obj->stream.ptr->res);
1660 }
1661
1662 static ZEND_METHOD(ion_Serializer_PHP, __construct)
1663 {
1664 php_ion_serializer_php *obj = php_ion_obj(serializer_php, Z_OBJ_P(ZEND_THIS));
1665 PTR_CHECK(obj);
1666
1667 obj->serializer.call_magic = true;
1668
1669 ZEND_PARSE_PARAMETERS_START(0, 4)
1670 Z_PARAM_OPTIONAL
1671 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1672 Z_PARAM_BOOL(obj->serializer.multi_seq)
1673 Z_PARAM_BOOL(obj->serializer.call_magic)
1674 Z_PARAM_STR_OR_NULL(obj->serializer.call_custom)
1675 ZEND_PARSE_PARAMETERS_END();
1676
1677 php_ion_serializer_php_ctor(obj);
1678 }
1679 static ZEND_METHOD(ion_Serializer_PHP, serialize)
1680 {
1681 zend_object *obj = Z_OBJ_P(ZEND_THIS);
1682
1683 zval *data;
1684 ZEND_PARSE_PARAMETERS_START(1, 1)
1685 Z_PARAM_ZVAL(data)
1686 ZEND_PARSE_PARAMETERS_END();
1687
1688 php_ion_serialize(&php_ion_obj(serializer_php, obj)->serializer, data, return_value);
1689 }
1690 static ZEND_FUNCTION(ion_serialize)
1691 {
1692 zval *data;
1693 zend_object *zo_ser = NULL;
1694 ZEND_PARSE_PARAMETERS_START(1, 2)
1695 Z_PARAM_ZVAL(data)
1696 Z_PARAM_OPTIONAL
1697 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Serializer)
1698 ZEND_PARSE_PARAMETERS_END();
1699
1700 if (!zo_ser || zo_ser->ce == ce_Serializer_PHP) {
1701 // default, fast path
1702 php_ion_serializer *ser = zo_ser ? &php_ion_obj(serializer_php, zo_ser)->serializer : NULL;
1703 php_ion_serialize(ser, data, return_value);
1704 } else {
1705 zend_call_method_with_1_params(zo_ser, NULL, NULL, "serialize", return_value, data);
1706 }
1707 }
1708
1709 static ZEND_METHOD(ion_Unserializer_PHP, __construct)
1710 {
1711 php_ion_unserializer_php *obj = php_ion_obj(unserializer_php, Z_OBJ_P(ZEND_THIS));
1712 PTR_CHECK(obj);
1713
1714 obj->unserializer.call_magic = true;
1715
1716 ZEND_PARSE_PARAMETERS_START(0, 4)
1717 Z_PARAM_OPTIONAL
1718 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1719 Z_PARAM_BOOL(obj->unserializer.multi_seq)
1720 Z_PARAM_BOOL(obj->unserializer.call_magic)
1721 Z_PARAM_STR_OR_NULL(obj->unserializer.call_custom)
1722 ZEND_PARSE_PARAMETERS_END();
1723
1724 php_ion_unserializer_php_ctor(obj);
1725 }
1726 static ZEND_METHOD(ion_Unserializer_PHP, unserialize)
1727 {
1728 zend_object *obj = Z_OBJ_P(ZEND_THIS);
1729
1730 zval *data;
1731 ZEND_PARSE_PARAMETERS_START(1, 1)
1732 Z_PARAM_ZVAL(data)
1733 ZEND_PARSE_PARAMETERS_END();
1734
1735 php_ion_unserialize(&php_ion_obj(unserializer_php, obj)->unserializer, data, return_value);
1736 }
1737 static ZEND_FUNCTION(ion_unserialize)
1738 {
1739 zval *data;
1740 zend_object *zo_ser = NULL;
1741 ZEND_PARSE_PARAMETERS_START(1, 2)
1742 Z_PARAM_ZVAL(data)
1743 Z_PARAM_OPTIONAL
1744 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Unserializer)
1745 ZEND_PARSE_PARAMETERS_END();
1746
1747 if (!zo_ser || zo_ser->ce == ce_Unserializer_PHP) {
1748 // default, fast path
1749 php_ion_unserializer *ser = zo_ser ? &php_ion_obj(unserializer_php, zo_ser)->unserializer : NULL;
1750 php_ion_unserialize(ser, data, return_value);
1751 } else {
1752 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1753 }
1754 }
1755
1756 PHP_RINIT_FUNCTION(ion)
1757 {
1758 #if defined(ZTS) && defined(COMPILE_DL_ION)
1759 ZEND_TSRMLS_CACHE_UPDATE();
1760 #endif
1761
1762 php_ion_globals_symbols_init();
1763 php_ion_globals_serializer_init();
1764 php_ion_globals_unserializer_init();
1765 return SUCCESS;
1766 }
1767
1768 PHP_RSHUTDOWN_FUNCTION(ion)
1769 {
1770 php_ion_globals_unserializer_dtor();
1771 php_ion_globals_serializer_dtor();
1772 php_ion_globals_symbols_dtor();
1773 return SUCCESS;
1774 }
1775
1776 #define ZEND_ARG_VARIADIC_OBJ_TYPE_MASK(pass_by_ref, name, classname, type_mask, default_value) \
1777 { #name, ZEND_TYPE_INIT_CLASS_CONST_MASK(#classname, type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), default_value },
1778 #include "ion_arginfo.h"
1779
1780 PHP_MINIT_FUNCTION(ion)
1781 {
1782 // true globals
1783 if (SUCCESS != g_sym_init()) {
1784 return FAILURE;
1785 }
1786
1787 // Catalog
1788 php_ion_register(catalog, Catalog, zend_ce_countable);
1789
1790 // Decimal
1791 php_ion_register(decimal, Decimal);
1792 php_ion_register(decimal_ctx, Decimal_Context);
1793 ce_Decimal_Context_Rounding = register_class_ion_Decimal_Context_Rounding();
1794
1795 // LOB
1796 ce_LOB = register_class_ion_LOB();
1797
1798 // Reader
1799 ce_Reader = register_class_ion_Reader(spl_ce_RecursiveIterator);
1800 php_ion_register(reader_options, Reader_Options);
1801 php_ion_register(reader, Reader_Reader, ce_Reader);
1802 ce_Reader_Buffer = register_class_ion_Reader_Buffer(ce_Reader);
1803 ce_Reader_Buffer_Reader = register_class_ion_Reader_Buffer_Reader(ce_Reader_Reader, ce_Reader_Buffer);
1804 ce_Reader_Stream = register_class_ion_Reader_Stream(ce_Reader);
1805 ce_Reader_Stream_Reader = register_class_ion_Reader_Stream_Reader(ce_Reader_Reader, ce_Reader_Stream);
1806
1807 // Serializer
1808 ce_Serializer = register_class_ion_Serializer();
1809 php_ion_register(serializer_php, Serializer_PHP, ce_Serializer);
1810
1811 // Symbol
1812 php_ion_register(symbol, Symbol);
1813 oh_Symbol.compare = php_ion_symbol_zval_compare;
1814 php_ion_register(symbol_iloc, Symbol_ImportLocation);
1815 php_ion_register(symbol_table, Symbol_Table);
1816 ce_Symbol_Table->create_object = NULL;
1817 ce_Symbol_Table_Local = register_class_ion_Symbol_Table_Local(ce_Symbol_Table);
1818 ce_Symbol_Table_Local->create_object = create_ion_Symbol_Table;
1819 ce_Symbol_Table_Shared = register_class_ion_Symbol_Table_Shared(ce_Symbol_Table);
1820 ce_Symbol_Table_Shared->create_object = create_ion_Symbol_Table;
1821 ce_Symbol_Enum = register_class_ion_Symbol_Enum();
1822 ce_Symbol_Table_System = register_class_ion_Symbol_Table_System(ce_Symbol_Enum);
1823 ce_Symbol_Table_PHP = register_class_ion_Symbol_Table_PHP(ce_Symbol_Enum);
1824
1825 // Timestamp
1826 ce_Timestamp = register_class_ion_Timestamp(php_date_get_date_ce());
1827 ce_Timestamp_Precision = register_class_ion_Timestamp_Precision();
1828
1829 // Type
1830 ce_Type = register_class_ion_Type();
1831
1832 // Writer
1833 ce_Writer = register_class_ion_Writer();
1834 php_ion_register(writer_options, Writer_Options);
1835 php_ion_register(writer, Writer_Writer, ce_Writer);
1836 ce_Writer_Buffer = register_class_ion_Writer_Buffer(ce_Writer);
1837 ce_Writer_Buffer_Writer = register_class_ion_Writer_Buffer_Writer(ce_Writer_Writer, ce_Writer_Buffer);
1838 ce_Writer_Stream = register_class_ion_Writer_Stream(ce_Writer);
1839 ce_Writer_Stream_Writer = register_class_ion_Writer_Stream_Writer(ce_Writer_Writer, ce_Writer_Stream);
1840
1841 // Unserializer
1842 ce_Unserializer = register_class_ion_Unserializer();
1843 php_ion_register(unserializer_php, Unserializer_PHP, ce_Unserializer);
1844
1845 return SUCCESS;
1846 }
1847
1848 PHP_MSHUTDOWN_FUNCTION(ion)
1849 {
1850 if (g_sym_tab_php) {
1851 ion_symbol_table_close(g_sym_tab_php);
1852 }
1853 zend_hash_destroy(&g_sym_hash);
1854 return SUCCESS;
1855 }
1856
1857 PHP_MINFO_FUNCTION(ion)
1858 {
1859 php_info_print_table_start();
1860 php_info_print_table_header(2, "ion support", "enabled");
1861 php_info_print_table_end();
1862 }
1863
1864 PHP_GINIT_FUNCTION(ion)
1865 {
1866 memset(ion_globals, 0, sizeof(*ion_globals));
1867
1868 php_ion_decimal_ctx_init_max(&ion_globals->decimal.ctx, DEC_ROUND_HALF_EVEN);
1869 php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_max, &ion_globals->decimal.ctx, ZEND_LONG_MAX);
1870 php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_min, &ion_globals->decimal.ctx, ZEND_LONG_MIN);
1871 }
1872
1873 PHP_GSHUTDOWN_FUNCTION(ion)
1874 {
1875 }
1876
1877 static zend_module_dep ion_module_deps[] = {
1878 ZEND_MOD_REQUIRED("date")
1879 ZEND_MOD_REQUIRED("spl")
1880 ZEND_MOD_END
1881 };
1882
1883 zend_module_entry ion_module_entry = {
1884 STANDARD_MODULE_HEADER_EX,
1885 NULL,
1886 ion_module_deps,
1887 "ion", /* Extension name */
1888 ext_functions, /* zend_function_entry */
1889 PHP_MINIT(ion), /* PHP_MINIT - Module initialization */
1890 PHP_MSHUTDOWN(ion), /* PHP_MSHUTDOWN - Module shutdown */
1891 PHP_RINIT(ion), /* PHP_RINIT - Request initialization */
1892 PHP_RSHUTDOWN(ion), /* PHP_RSHUTDOWN - Request shutdown */
1893 PHP_MINFO(ion), /* PHP_MINFO - Module info */
1894 PHP_ION_VERSION, /* Version */
1895 ZEND_MODULE_GLOBALS(ion),
1896 PHP_GINIT(ion), /* PHP_GINIT */
1897 PHP_GSHUTDOWN(ion), /* PHP_GSHUTDOWN */
1898 NULL,
1899 STANDARD_MODULE_PROPERTIES_EX
1900 };
1901
1902 #ifdef COMPILE_DL_ION
1903 # ifdef ZTS
1904 ZEND_TSRMLS_CACHE_DEFINE()
1905 # endif
1906 ZEND_GET_MODULE(ion)
1907 #endif
PHP extension for Amazon ION