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