git.m6w6.name Git - m6w6/ext-pq/blob - src/php_pq_misc.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: pq                                                         |
   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) 2013, 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/date/php_date.h>
  19 #include <ext/standard/php_string.h>
  20
  21 #include <Zend/zend_interfaces.h>
  22
  23 #include <libpq/libpq-fs.h>
  24
  25 #include "php_pq.h"
  26 #include "php_pqexc.h"
  27 #include "php_pq_misc.h"
  28
  29 char *php_pq_rtrim(char *e)
  30 {
  31         size_t l = strlen(e);
  32
  33         while (l-- > 0 && e[l] == '\n') {
  34                 e[l] = '\0';
  35         }
  36         return e;
  37 }
  38
  39 const char *php_pq_strmode(long mode)
  40 {
  41         switch (mode & (INV_READ|INV_WRITE)) {
  42         case INV_READ|INV_WRITE:
  43                 return "rw";
  44         case INV_READ:
  45                 return "r";
  46         case INV_WRITE:
  47                 return "w";
  48         default:
  49                 return "-";
  50         }
  51 }
  52
  53 int php_pq_compare_index(const void *lptr, const void *rptr TSRMLS_DC)
  54 {
  55         const Bucket *l = *(const Bucket **) lptr;
  56         const Bucket *r = *(const Bucket **) rptr;
  57
  58         if (l->h < r->h) {
  59                 return -1;
  60         }
  61         if (l->h > r->h) {
  62                 return 1;
  63         }
  64         return 0;
  65 }
  66
  67 zend_class_entry *php_pqdt_class_entry;
  68
  69 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_to_string, 0, 0, 0)
  70 ZEND_END_ARG_INFO();
  71 static PHP_METHOD(pqdt, __toString)
  72 {
  73         zval *rv = NULL;
  74
  75         zend_call_method_with_1_params(&getThis(), php_pqdt_class_entry, NULL, "format", &rv,
  76                         zend_read_property(php_pqdt_class_entry, getThis(), ZEND_STRL("format"), 0 TSRMLS_CC));
  77         if (rv) {
  78                 RETVAL_ZVAL(rv, 1, 1);
  79         }
  80 }
  81
  82 ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_create_from_format, 0, 0, 2)
  83         ZEND_ARG_INFO(0, format)
  84         ZEND_ARG_INFO(0, datetime)
  85         ZEND_ARG_INFO(0, timezone)
  86 ZEND_END_ARG_INFO();
  87 static PHP_METHOD(pqdt, createFromFormat)
  88 {
  89         zend_error_handling zeh;
  90         char *fmt_str, *dt_str;
  91         int fmt_len, dt_len;
  92         zval *ztz = NULL;
  93         ZEND_RESULT_CODE rv;
  94
  95         zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh TSRMLS_CC);
  96         rv = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|O", &fmt_str, &fmt_len, &dt_str, &dt_len, &ztz, php_date_get_timezone_ce());
  97         zend_restore_error_handling(&zeh TSRMLS_CC);
  98
  99         if (SUCCESS == rv) {
 100                 php_pqdt_from_string(return_value, fmt_str, dt_str, dt_len, "Y-m-d H:i:s.uO", ztz TSRMLS_CC);
 101         }
 102 }
 103
 104 static zend_function_entry php_pqdt_methods[] = {
 105         PHP_ME(pqdt, createFromFormat, ai_pqdt_create_from_format, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 106         PHP_ME(pqdt, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 107         PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
 108         {0}
 109 };
 110
 111 zval *php_pqdt_from_string(zval *zv, char *input_fmt, char *dt_str, size_t dt_len, char *output_fmt, zval *ztimezone TSRMLS_DC)
 112 {
 113         php_date_obj *dobj;
 114
 115         if (!zv) {
 116                 MAKE_STD_ZVAL(zv);
 117         }
 118
 119         php_date_instantiate(php_pqdt_class_entry, zv TSRMLS_CC);
 120         dobj = zend_object_store_get_object(zv TSRMLS_CC);
 121         if (!php_date_initialize(dobj, dt_str, dt_len, input_fmt, ztimezone, 1 TSRMLS_CC)) {
 122                 zval_dtor(zv);
 123                 ZVAL_NULL(zv);
 124         } else if (output_fmt) {
 125                 zend_update_property_string(php_pqdt_class_entry, zv, ZEND_STRL("format"), output_fmt TSRMLS_CC);
 126         }
 127
 128         return zv;
 129 }
 130
 131 void php_pqdt_to_string(zval *zdt, const char *format, char **str_buf, size_t *str_len TSRMLS_DC)
 132 {
 133         zval rv;
 134
 135         INIT_PZVAL(&rv);
 136         ZVAL_NULL(&rv);
 137
 138         if (Z_OBJ_HT_P(zdt)->cast_object
 139         &&      SUCCESS == Z_OBJ_HT_P(zdt)->cast_object(zdt, &rv, IS_STRING TSRMLS_CC)
 140         ) {
 141                 *str_len = Z_STRLEN(rv);
 142                 *str_buf = Z_STRVAL(rv);
 143         } else if (instanceof_function(Z_OBJCE_P(zdt), php_date_get_date_ce() TSRMLS_CC)) {
 144                 zval *rv = NULL, *zfmt;
 145
 146                 MAKE_STD_ZVAL(zfmt);
 147                 ZVAL_STRING(zfmt, format, 1);
 148                 zend_call_method_with_1_params(&zdt, Z_OBJCE_P(zdt), NULL, "format", &rv, zfmt);
 149                 zval_ptr_dtor(&zfmt);
 150
 151                 if (rv) {
 152                         if (Z_TYPE_P(rv) == IS_STRING) {
 153                                 *str_len = Z_STRLEN_P(rv);
 154                                 *str_buf = estrndup(Z_STRVAL_P(rv), *str_len);
 155                         }
 156                         zval_ptr_dtor(&rv);
 157                 }
 158         }
 159 }
 160
 161 zend_class_entry *php_pqconv_class_entry;
 162
 163 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_types, 0, 0, 0)
 164 ZEND_END_ARG_INFO();
 165
 166 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_from_string, 0, 0, 2)
 167         ZEND_ARG_INFO(0, data)
 168         ZEND_ARG_INFO(0, type)
 169 ZEND_END_ARG_INFO();
 170
 171 ZEND_BEGIN_ARG_INFO_EX(ai_pqconv_convert_to_string, 0, 0, 2)
 172         ZEND_ARG_INFO(0, data)
 173         ZEND_ARG_INFO(0, type)
 174 ZEND_END_ARG_INFO();
 175
 176 zend_function_entry php_pqconv_methods[] = {
 177         PHP_ABSTRACT_ME(pqconv, convertTypes, ai_pqconv_convert_types)
 178         PHP_ABSTRACT_ME(pqconv, convertFromString, ai_pqconv_convert_from_string)
 179         PHP_ABSTRACT_ME(pqconv, convertToString, ai_pqconv_convert_to_string)
 180         {0}
 181 };
 182
 183
 184 PHP_MINIT_FUNCTION(pq_misc)
 185 {
 186         zend_class_entry **json, ce = {0};
 187
 188         INIT_NS_CLASS_ENTRY(ce, "pq", "Converter", php_pqconv_methods);
 189         php_pqconv_class_entry = zend_register_internal_interface(&ce TSRMLS_CC);
 190
 191         memset(&ce, 0, sizeof(ce));
 192         INIT_NS_CLASS_ENTRY(ce ,"pq", "DateTime", php_pqdt_methods);
 193         php_pqdt_class_entry = zend_register_internal_class_ex(&ce, php_date_get_date_ce(), "DateTime" TSRMLS_CC);
 194
 195         zend_declare_property_stringl(php_pqdt_class_entry, ZEND_STRL("format"), ZEND_STRL("Y-m-d H:i:s.uO"), ZEND_ACC_PUBLIC TSRMLS_CC);
 196
 197         /* stop reading this file right here! */
 198         if (SUCCESS == zend_hash_find(CG(class_table), ZEND_STRS("jsonserializable"), (void *) &json)) {
 199                 zend_class_implements(php_pqdt_class_entry TSRMLS_CC, 1, *json);
 200         }
 201
 202         return SUCCESS;
 203 }
 204
 205 typedef struct _HashTableList {
 206         HashTable ht;
 207         struct _HashTableList *parent;
 208 } HashTableList;
 209
 210 typedef struct _ArrayParserState {
 211         const char *ptr, *end;
 212         HashTableList *list;
 213         php_pqres_t *res;
 214 #ifdef ZTS
 215         void ***ts;
 216 #endif
 217         Oid typ;
 218         unsigned quotes:1;
 219         unsigned escaped:1;
 220 } ArrayParserState;
 221
 222 static char caa(ArrayParserState *a, const char *any, unsigned advance)
 223 {
 224         const char *p = any;
 225         TSRMLS_FETCH_FROM_CTX(a->ts);
 226
 227         do {
 228                 if (*p == *a->ptr) {
 229                         a->ptr += advance;
 230                         return *p;
 231                 }
 232         } while (*++p);
 233
 234         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse array: expected one of '%s', got '%c'", any, *a->ptr); \
 235         return 0;
 236 }
 237
 238 static ZEND_RESULT_CODE add_element(ArrayParserState *a, const char *start)
 239 {
 240         zval *zelem;
 241         size_t el_len = a->ptr - start;
 242         char *el_str = estrndup(start, el_len);
 243         TSRMLS_FETCH_FROM_CTX(a->ts);
 244
 245         if (a->quotes) {
 246                 int tmp_len = el_len;
 247
 248                 php_stripslashes(el_str, &tmp_len TSRMLS_CC);
 249                 el_len = tmp_len;
 250         } else if ((a->ptr - start == 4) && !strncmp(start, "NULL", 4)) {
 251                 efree(el_str);
 252                 el_str = NULL;
 253                 el_len = 0;
 254         }
 255
 256         if (!el_str) {
 257                 MAKE_STD_ZVAL(zelem);
 258                 ZVAL_NULL(zelem);
 259         } else {
 260                 zelem = php_pqres_typed_zval(a->res, el_str, el_len, a->typ TSRMLS_CC);
 261
 262                 efree(el_str);
 263         }
 264
 265         return zend_hash_next_index_insert(&a->list->ht, &zelem, sizeof(zval *), NULL);
 266 }
 267
 268 static ZEND_RESULT_CODE parse_array(ArrayParserState *a);
 269
 270 static ZEND_RESULT_CODE parse_element(ArrayParserState *a)
 271 {
 272         const char *el;
 273         TSRMLS_FETCH_FROM_CTX(a->ts);
 274
 275         switch (*a->ptr) {
 276         case '{':
 277                 return parse_array(a);
 278
 279         case '"':
 280                 a->quotes = 1;
 281                 ++a->ptr;
 282                 break;
 283         }
 284
 285         for (el = a->ptr; a->ptr < a->end; ++a->ptr) {
 286                 switch (*a->ptr) {
 287                 case '"':
 288                         if (a->escaped) {
 289                                 a->escaped = 0;
 290                         } else if (a->quotes) {
 291                                 if (SUCCESS != add_element(a, el)) {
 292                                         return FAILURE;
 293                                 }
 294                                 a->quotes = 0;
 295                                 ++a->ptr;
 296                                 return SUCCESS;
 297                         } else {
 298                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, unexpected quote: '%.*s'", (int) (a->ptr - el), el);
 299                                 return FAILURE;
 300                         }
 301                         break;
 302
 303                 case ',':
 304                 case '}':
 305                         if (!a->quotes) {
 306                                 return add_element(a, el);
 307                         }
 308                         break;
 309
 310                 case '\\':
 311                         a->escaped = !a->escaped;
 312                         break;
 313
 314                 default:
 315                         a->escaped = 0;
 316                         break;
 317                 }
 318         }
 319
 320         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse element, reached end of input");
 321         return FAILURE;
 322 }
 323
 324 static ZEND_RESULT_CODE parse_elements(ArrayParserState *a)
 325 {
 326         TSRMLS_FETCH_FROM_CTX(a->ts);
 327
 328         while (SUCCESS == parse_element(a)) {
 329                 switch (caa(a, ",}", 0)) {
 330                 case 0:
 331                         return FAILURE;
 332
 333                 case '}':
 334                         return SUCCESS;
 335
 336                 default:
 337                         if (!*++a->ptr) {
 338                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse elements, reached end of input");
 339                                 return FAILURE;
 340                         }
 341                         break;
 342                 }
 343         }
 344
 345         return FAILURE;
 346 }
 347
 348 static ZEND_RESULT_CODE parse_array(ArrayParserState *a)
 349 {
 350         HashTableList *list;
 351
 352         if (!caa(a, "{", 1)) {
 353                 return FAILURE;
 354         }
 355
 356         list = ecalloc(1, sizeof(*list));
 357         ZEND_INIT_SYMTABLE(&list->ht);
 358
 359         if (a->list) {
 360                 zval *zcur;
 361
 362                 MAKE_STD_ZVAL(zcur);
 363                 Z_TYPE_P(zcur) = IS_ARRAY;
 364                 Z_ARRVAL_P(zcur) = &list->ht;
 365
 366                 zend_hash_next_index_insert(&a->list->ht, &zcur, sizeof(zval *), NULL);
 367
 368                 list->parent = a->list;
 369         }
 370         a->list = list;
 371
 372         if (SUCCESS != parse_elements(a)) {
 373                 return FAILURE;
 374         }
 375
 376         if (!caa(a, "}", 1)) {
 377                 return FAILURE;
 378         }
 379
 380         if (a->list->parent) {
 381                 a->list = a->list->parent;
 382         }
 383
 384         return SUCCESS;
 385 }
 386
 387 HashTable *php_pq_parse_array(php_pqres_t *res, const char *val_str, size_t val_len, Oid typ TSRMLS_DC)
 388 {
 389         HashTable *ht = NULL;
 390         ArrayParserState a = {0};
 391         TSRMLS_SET_CTX(a.ts);
 392
 393         a.typ = typ;
 394         a.ptr = val_str;
 395         a.end = val_str + val_len;
 396         a.res = res;
 397
 398         if (SUCCESS != parse_array(&a)) {
 399                 while (a.list) {
 400                         HashTableList *l = a.list->parent;
 401
 402                         zend_hash_destroy(&a.list->ht);
 403                         efree(a.list);
 404                         a.list = l;
 405                 }
 406                 return ht;
 407         }
 408
 409         if (*a.ptr) {
 410                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Trailing input: '%s'", a.ptr);
 411         }
 412
 413         do {
 414                 ht = &a.list->ht;
 415         } while ((a.list = a.list->parent));
 416
 417         return ht;
 418 }
 419
 420
 421 /*
 422  * Local variables:
 423  * tab-width: 4
 424  * c-basic-offset: 4
 425  * End:
 426  * vim600: noet sw=4 ts=4 fdm=marker
 427  * vim<600: noet sw=4 ts=4
 428  */