LTP GCOV extension - code coverage report
Current view: directory - home/mike/build/php-5.2-gcov/lcov_data/ext/standard - var_unserializer.c
Test: PHP Code Coverage
Date: 2007-04-10 Instrumented lines: 362
Code covered: 0.0 % Executed lines: 0
Legend: not executed executed

       1                 : /* Generated by re2c 0.11.2 on Tue Mar 27 13:17:43 2007 */
       2                 : #line 1 "ext/standard/var_unserializer.re"
       3                 : /*
       4                 :   +----------------------------------------------------------------------+
       5                 :   | PHP Version 5                                                        |
       6                 :   +----------------------------------------------------------------------+
       7                 :   | Copyright (c) 1997-2006 The PHP Group                                |
       8                 :   +----------------------------------------------------------------------+
       9                 :   | This source file is subject to version 3.01 of the PHP license,      |
      10                 :   | that is bundled with this package in the file LICENSE, and is        |
      11                 :   | available through the world-wide-web at the following url:           |
      12                 :   | http://www.php.net/license/3_01.txt                                  |
      13                 :   | If you did not receive a copy of the PHP license and are unable to   |
      14                 :   | obtain it through the world-wide-web, please send a note to          |
      15                 :   | license@php.net so we can mail you a copy immediately.               |
      16                 :   +----------------------------------------------------------------------+
      17                 :   | Author: Sascha Schumann <sascha@schumann.cx>                         |
      18                 :   +----------------------------------------------------------------------+
      19                 : */
      20                 : 
      21                 : /* $Id: var_unserializer.c,v 1.70.2.4.2.5 2007/03/27 09:29:10 tony2001 Exp $ */
      22                 : 
      23                 : #include "php.h"
      24                 : #include "ext/standard/php_var.h"
      25                 : #include "php_incomplete_class.h"
      26                 : 
      27                 : /* {{{ reference-handling for unserializer: var_* */
      28                 : #define VAR_ENTRIES_MAX 1024
      29                 : 
      30                 : typedef struct {
      31                 :         zval *data[VAR_ENTRIES_MAX];
      32                 :         long used_slots;
      33                 :         void *next;
      34                 : } var_entries;
      35                 : 
      36                 : static inline void var_push(php_unserialize_data_t *var_hashx, zval **rval)
      37                 : {
      38                 :         var_entries *var_hash = var_hashx->first, *prev = NULL;
      39                 : 
      40                 :         while (var_hash && var_hash->used_slots == VAR_ENTRIES_MAX) {
      41                 :                 prev = var_hash;
      42                 :                 var_hash = var_hash->next;
      43                 :         }
      44                 : 
      45                 :         if (!var_hash) {
      46                 :                 var_hash = emalloc(sizeof(var_entries));
      47                 :                 var_hash->used_slots = 0;
      48                 :                 var_hash->next = 0;
      49                 : 
      50                 :                 if (!var_hashx->first)
      51                 :                         var_hashx->first = var_hash;
      52                 :                 else
      53                 :                         prev->next = var_hash;
      54                 :         }
      55                 : 
      56                 :         var_hash->data[var_hash->used_slots++] = *rval;
      57                 : }
      58                 : 
      59                 : static inline void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
      60                 : {
      61                 :         var_entries *var_hash = var_hashx->first_dtor, *prev = NULL;
      62                 : 
      63                 :         while (var_hash && var_hash->used_slots == VAR_ENTRIES_MAX) {
      64                 :                 prev = var_hash;
      65                 :                 var_hash = var_hash->next;
      66                 :         }
      67                 : 
      68                 :         if (!var_hash) {
      69                 :                 var_hash = emalloc(sizeof(var_entries));
      70                 :                 var_hash->used_slots = 0;
      71                 :                 var_hash->next = 0;
      72                 : 
      73                 :                 if (!var_hashx->first_dtor)
      74                 :                         var_hashx->first_dtor = var_hash;
      75                 :                 else
      76                 :                         prev->next = var_hash;
      77                 :         }
      78                 : 
      79                 :         (*rval)->refcount++;
      80                 :         var_hash->data[var_hash->used_slots++] = *rval;
      81                 : }
      82                 : 
      83                 : PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **nzval)
      84                 : {
      85                 :         long i;
      86                 :         var_entries *var_hash = var_hashx->first;
      87                 :         
      88                 :         while (var_hash) {
      89                 :                 for (i = 0; i < var_hash->used_slots; i++) {
      90                 :                         if (var_hash->data[i] == ozval) {
      91                 :                                 var_hash->data[i] = *nzval;
      92                 :                                 /* do not break here */
      93                 :                         }
      94                 :                 }
      95                 :                 var_hash = var_hash->next;
      96                 :         }
      97                 : }
      98                 : 
      99                 : static int var_access(php_unserialize_data_t *var_hashx, long id, zval ***store)
     100                 : {
     101                 :         var_entries *var_hash = var_hashx->first;
     102                 :         
     103                 :         while (id >= VAR_ENTRIES_MAX && var_hash && var_hash->used_slots == VAR_ENTRIES_MAX) {
     104                 :                 var_hash = var_hash->next;
     105                 :                 id -= VAR_ENTRIES_MAX;
     106                 :         }
     107                 : 
     108                 :         if (!var_hash) return !SUCCESS;
     109                 : 
     110                 :         if (id < 0 || id >= var_hash->used_slots) return !SUCCESS;
     111                 : 
     112                 :         *store = &var_hash->data[id];
     113                 : 
     114                 :         return SUCCESS;
     115                 : }
     116                 : 
     117                 : PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
     118                 : {
     119                 :         void *next;
     120                 :         long i;
     121                 :         var_entries *var_hash = var_hashx->first;
     122                 :         
     123                 :         while (var_hash) {
     124                 :                 next = var_hash->next;
     125                 :                 efree(var_hash);
     126                 :                 var_hash = next;
     127                 :         }
     128                 : 
     129                 :         var_hash = var_hashx->first_dtor;
     130                 :         
     131                 :         while (var_hash) {
     132                 :                 for (i = 0; i < var_hash->used_slots; i++) {
     133                 :                         zval_ptr_dtor(&var_hash->data[i]);
     134                 :                 }
     135                 :                 next = var_hash->next;
     136                 :                 efree(var_hash);
     137                 :                 var_hash = next;
     138                 :         }
     139                 : }
     140                 : 
     141                 : /* }}} */
     142                 : 
     143                 : static char *unserialize_str(const unsigned char **p, size_t *len)
     144                 : {
     145                 :         size_t i, j;
     146                 :         char *str = safe_emalloc(*len, 1, 1);
     147                 :         unsigned char *end = *(unsigned char **)p+*len;
     148                 : 
     149                 :         if(end < *p) {
     150                 :                 efree(str);
     151                 :                 return NULL;
     152                 :         }
     153                 : 
     154                 :         for (i = 0; i < *len && *p < end; i++) {
     155                 :                 if (**p != '\\') {
     156                 :                         str[i] = (char)**p;
     157                 :                 } else {
     158                 :                         unsigned char ch = 0;
     159                 : 
     160                 :                         for (j = 0; j < 2; j++) {
     161                 :                                 (*p)++;
     162                 :                                 if (**p >= '0' && **p <= '9') {
     163                 :                                         ch = (ch << 4) + (**p -'0');
     164                 :                                 } else if (**p >= 'a' && **p <= 'f') {
     165                 :                                         ch = (ch << 4) + (**p -'a'+10);
     166                 :                                 } else if (**p >= 'A' && **p <= 'F') {
     167                 :                                         ch = (ch << 4) + (**p -'A'+10);
     168                 :                                 } else {
     169                 :                                         efree(str);
     170                 :                                         return NULL;
     171                 :                                 }
     172                 :                         }
     173                 :                         str[i] = (char)ch;
     174                 :                 }
     175                 :                 (*p)++;
     176                 :         }
     177                 :         str[i] = 0;
     178                 :         *len = i;
     179                 :         return str;
     180                 : }
     181                 : 
     182                 : #define YYFILL(n) do { } while (0)
     183                 : #define YYCTYPE unsigned char
     184                 : #define YYCURSOR cursor
     185                 : #define YYLIMIT limit
     186                 : #define YYMARKER marker
     187                 : 
     188                 : 
     189                 : #line 194 "ext/standard/var_unserializer.re"
     190                 : 
     191                 : 
     192                 : 
     193                 : 
     194                 : static inline long parse_iv2(const unsigned char *p, const unsigned char **q)
     195                 : {
     196                 :         char cursor;
     197                 :         long result = 0;
     198                 :         int neg = 0;
     199                 : 
     200                 :         switch (*p) {
     201                 :                 case '-':
     202                 :                         neg++;
     203                 :                         /* fall-through */
     204                 :                 case '+':
     205                 :                         p++;
     206                 :         }
     207                 :         
     208                 :         while (1) {
     209                 :                 cursor = (char)*p;
     210                 :                 if (cursor >= '0' && cursor <= '9') {
     211                 :                         result = result * 10 + cursor - '0';
     212                 :                 } else {
     213                 :                         break;
     214                 :                 }
     215                 :                 p++;
     216                 :         }
     217                 :         if (q) *q = p;
     218                 :         if (neg) return -result;
     219                 :         return result;
     220                 : }
     221                 : 
     222                 : static inline long parse_iv(const unsigned char *p)
     223                 : {
     224                 :         return parse_iv2(p, NULL);
     225                 : }
     226                 : 
     227                 : /* no need to check for length - re2c already did */
     228                 : static inline size_t parse_uiv(const unsigned char *p)
     229                 : {
     230                 :         unsigned char cursor;
     231                 :         size_t result = 0;
     232                 : 
     233                 :         if (*p == '+') {
     234                 :                 p++;
     235                 :         }
     236                 :         
     237                 :         while (1) {
     238                 :                 cursor = *p;
     239                 :                 if (cursor >= '0' && cursor <= '9') {
     240                 :                         result = result * 10 + (size_t)(cursor - (unsigned char)'0');
     241                 :                 } else {
     242                 :                         break;
     243                 :                 }
     244                 :                 p++;
     245                 :         }
     246                 :         return result;
     247                 : }
     248                 : 
     249                 : #define UNSERIALIZE_PARAMETER zval **rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC
     250                 : #define UNSERIALIZE_PASSTHRU rval, p, max, var_hash TSRMLS_CC
     251                 : 
     252                 : static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements)
     253                 : {
     254                 :         while (elements-- > 0) {
     255                 :                 zval *key, *data, **old_data;
     256                 : 
     257                 :                 ALLOC_INIT_ZVAL(key);
     258                 : 
     259                 :                 if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
     260                 :                         zval_dtor(key);
     261                 :                         FREE_ZVAL(key);
     262                 :                         return 0;
     263                 :                 }
     264                 : 
     265                 :                 if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {
     266                 :                         zval_dtor(key);
     267                 :                         FREE_ZVAL(key);
     268                 :                         return 0;
     269                 :                 }
     270                 : 
     271                 :                 ALLOC_INIT_ZVAL(data);
     272                 : 
     273                 :                 if (!php_var_unserialize(&data, p, max, var_hash TSRMLS_CC)) {
     274                 :                         zval_dtor(key);
     275                 :                         FREE_ZVAL(key);
     276                 :                         zval_dtor(data);
     277                 :                         FREE_ZVAL(data);
     278                 :                         return 0;
     279                 :                 }
     280                 : 
     281                 :                 switch (Z_TYPE_P(key)) {
     282                 :                         case IS_LONG:
     283                 :                                 if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {
     284                 :                                         var_push_dtor(var_hash, old_data);
     285                 :                                 }
     286                 :                                 zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);
     287                 :                                 break;
     288                 :                         case IS_STRING:
     289                 :                                 if (zend_hash_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
     290                 :                                         var_push_dtor(var_hash, old_data);
     291                 :                                 }
     292                 :                                 zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);
     293                 :                                 break;
     294                 :                 }
     295                 :                 
     296                 :                 zval_dtor(key);
     297                 :                 FREE_ZVAL(key);
     298                 : 
     299                 :                 if (elements && *(*p-1) != ';' &&  *(*p-1) != '}') {
     300                 :                         (*p)--;
     301                 :                         return 0;
     302                 :                 }
     303                 :         }
     304                 : 
     305                 :         return 1;
     306                 : }
     307                 : 
     308                 : static inline int finish_nested_data(UNSERIALIZE_PARAMETER)
     309                 : {
     310                 :         if (*((*p)++) == '}') 
     311                 :                 return 1;
     312                 : 
     313                 : #if SOMETHING_NEW_MIGHT_LEAD_TO_CRASH_ENABLE_IF_YOU_ARE_BRAVE
     314                 :         zval_ptr_dtor(rval);
     315                 : #endif
     316                 :         return 0;
     317                 : }
     318                 : 
     319                 : static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
     320                 : {
     321                 :         long datalen;
     322                 : 
     323                 :         if(ce->unserialize == NULL) {
     324                 :                 zend_error(E_WARNING, "Class %s has no unserializer", ce->name);
     325                 :                 return 0;
     326                 :         }
     327                 : 
     328                 :         datalen = parse_iv2((*p) + 2, p);
     329                 : 
     330                 :         (*p) += 2;
     331                 : 
     332                 :         if(datalen < 0 || (*p) + datalen >= max) {
     333                 :                 zend_error(E_WARNING, "Insufficient data for unserializing - %ld required, %d present", datalen, max - (*p));
     334                 :                 return 0;
     335                 :         }
     336                 : 
     337                 :         if(ce->unserialize(rval, ce, (const unsigned char*)*p, datalen, (zend_unserialize_data *)var_hash TSRMLS_CC) != SUCCESS) {
     338                 :                 return 0;
     339                 :         }
     340                 : 
     341                 :         (*p) += datalen;
     342                 : 
     343                 :         return finish_nested_data(UNSERIALIZE_PASSTHRU);
     344                 : }
     345                 : 
     346                 : static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
     347                 : {
     348                 :         long elements;
     349                 :         
     350                 :         elements = parse_iv2((*p) + 2, p);
     351                 : 
     352                 :         (*p) += 2;
     353                 :         
     354                 :         object_init_ex(*rval, ce);
     355                 :         return elements;
     356                 : }
     357                 : 
     358                 : static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
     359                 : {
     360                 :         zval *retval_ptr = NULL;
     361                 :         zval fname;
     362                 : 
     363                 :         if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_PP(rval), elements)) {
     364                 :                 return 0;
     365                 :         }
     366                 : 
     367                 :         if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
     368                 :             zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
     369                 :                 INIT_PZVAL(&fname);
     370                 :                 ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
     371                 :                 call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
     372                 :         }
     373                 : 
     374                 :         if (retval_ptr)
     375                 :                 zval_ptr_dtor(&retval_ptr);
     376                 : 
     377                 :         return finish_nested_data(UNSERIALIZE_PASSTHRU);
     378                 : 
     379                 : }
     380                 : 
     381                 : PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
     382                 : {
     383                 :         const unsigned char *cursor, *limit, *marker, *start;
     384                 :         zval **rval_ref;
     385                 : 
     386                 :         limit = cursor = *p;
     387                 :         
     388                 :         if (var_hash && cursor[0] != 'R') {
     389                 :                 var_push(var_hash, rval);
     390                 :         }
     391                 : 
     392                 :         start = cursor;
     393                 : 
     394                 :         
     395                 :         
     396                 : {
     397                 :         static const unsigned char yybm[] = {
     398                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     399                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     400                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     401                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     402                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     403                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     404                 :                 128, 128, 128, 128, 128, 128, 128, 128, 
     405                 :                 128, 128,   0,   0,   0,   0,   0,   0, 
     406                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     407                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     408                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     409                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     410                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     411                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     412                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     413                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     414                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     415                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     416                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     417                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     418                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     419                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     420                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     421                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     422                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     423                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     424                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     425                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     426                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     427                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     428                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     429                 :                   0,   0,   0,   0,   0,   0,   0,   0, 
     430                 :         };
     431                 : 
     432                 : #line 433 "ext/standard/var_unserializer.c"
     433                 :         {
     434                 :                 YYCTYPE yych;
     435                 : 
     436               0 :                 if((YYLIMIT - YYCURSOR) < 7) YYFILL(7);
     437               0 :                 yych = *YYCURSOR;
     438               0 :                 switch(yych) {
     439                 :                 case 'C':
     440               0 :                 case 'O':       goto yy13;
     441               0 :                 case 'N':       goto yy5;
     442               0 :                 case 'R':       goto yy2;
     443               0 :                 case 'S':       goto yy10;
     444               0 :                 case 'a':       goto yy11;
     445               0 :                 case 'b':       goto yy6;
     446               0 :                 case 'd':       goto yy8;
     447               0 :                 case 'i':       goto yy7;
     448               0 :                 case 'o':       goto yy12;
     449               0 :                 case 'r':       goto yy4;
     450               0 :                 case 's':       goto yy9;
     451               0 :                 case '}':       goto yy14;
     452               0 :                 default:        goto yy16;
     453                 :                 }
     454               0 : yy2:
     455               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     456               0 :                 if(yych == ':') goto yy95;
     457               0 : yy3:
     458                 : #line 694 "ext/standard/var_unserializer.re"
     459                 :                 { return 0; }
     460                 : #line 461 "ext/standard/var_unserializer.c"
     461               0 : yy4:
     462               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     463               0 :                 if(yych == ':') goto yy89;
     464               0 :                 goto yy3;
     465               0 : yy5:
     466               0 :                 yych = *++YYCURSOR;
     467               0 :                 if(yych == ';') goto yy87;
     468               0 :                 goto yy3;
     469               0 : yy6:
     470               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     471               0 :                 if(yych == ':') goto yy83;
     472               0 :                 goto yy3;
     473               0 : yy7:
     474               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     475               0 :                 if(yych == ':') goto yy77;
     476               0 :                 goto yy3;
     477               0 : yy8:
     478               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     479               0 :                 if(yych == ':') goto yy53;
     480               0 :                 goto yy3;
     481               0 : yy9:
     482               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     483               0 :                 if(yych == ':') goto yy46;
     484               0 :                 goto yy3;
     485               0 : yy10:
     486               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     487               0 :                 if(yych == ':') goto yy39;
     488               0 :                 goto yy3;
     489               0 : yy11:
     490               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     491               0 :                 if(yych == ':') goto yy32;
     492               0 :                 goto yy3;
     493               0 : yy12:
     494               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     495               0 :                 if(yych == ':') goto yy25;
     496               0 :                 goto yy3;
     497               0 : yy13:
     498               0 :                 yych = *(YYMARKER = ++YYCURSOR);
     499               0 :                 if(yych == ':') goto yy17;
     500               0 :                 goto yy3;
     501               0 : yy14:
     502               0 :                 ++YYCURSOR;
     503                 : #line 688 "ext/standard/var_unserializer.re"
     504                 :                 {
     505                 :         /* this is the case where we have less data than planned */
     506                 :         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unexpected end of serialized data");
     507                 :         return 0; /* not sure if it should be 0 or 1 here? */
     508                 : }
     509                 : #line 510 "ext/standard/var_unserializer.c"
     510               0 : yy16:
     511               0 :                 yych = *++YYCURSOR;
     512               0 :                 goto yy3;
     513               0 : yy17:
     514               0 :                 yych = *++YYCURSOR;
     515               0 :                 if(yybm[0+yych] & 128) {
     516               0 :                         goto yy20;
     517                 :                 }
     518               0 :                 if(yych == '+') goto yy19;
     519               0 : yy18:
     520               0 :                 YYCURSOR = YYMARKER;
     521               0 :                 goto yy3;
     522               0 : yy19:
     523               0 :                 yych = *++YYCURSOR;
     524               0 :                 if(yybm[0+yych] & 128) {
     525               0 :                         goto yy20;
     526                 :                 }
     527               0 :                 goto yy18;
     528               0 : yy20:
     529               0 :                 ++YYCURSOR;
     530               0 :                 if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
     531               0 :                 yych = *YYCURSOR;
     532               0 :                 if(yybm[0+yych] & 128) {
     533               0 :                         goto yy20;
     534                 :                 }
     535               0 :                 if(yych != ':') goto yy18;
     536               0 :                 yych = *++YYCURSOR;
     537               0 :                 if(yych != '"') goto yy18;
     538               0 :                 ++YYCURSOR;
     539                 : #line 576 "ext/standard/var_unserializer.re"
     540                 :                 {
     541                 :         size_t len, len2, len3, maxlen;
     542                 :         long elements;
     543                 :         char *class_name;
     544                 :         zend_class_entry *ce;
     545                 :         zend_class_entry **pce;
     546                 :         int incomplete_class = 0;
     547                 : 
     548                 :         int custom_object = 0;
     549                 : 
     550                 :         zval *user_func;
     551                 :         zval *retval_ptr;
     552                 :         zval **args[1];
     553                 :         zval *arg_func_name;
     554                 : 
     555                 :         if(*start == 'C') {
     556                 :                 custom_object = 1;
     557                 :         }
     558                 :         
     559                 :         INIT_PZVAL(*rval);
     560                 :         len2 = len = parse_uiv(start + 2);
     561                 :         maxlen = max - YYCURSOR;
     562                 :         if (maxlen < len || len == 0) {
     563                 :                 *p = start + 2;
     564                 :                 return 0;
     565                 :         }
     566                 : 
     567                 :         class_name = (char*)YYCURSOR;
     568                 : 
     569                 :         YYCURSOR += len;
     570                 : 
     571                 :         if (*(YYCURSOR) != '"') {
     572                 :                 *p = YYCURSOR;
     573                 :                 return 0;
     574                 :         }
     575                 :         if (*(YYCURSOR+1) != ':') {
     576                 :                 *p = YYCURSOR+1;
     577                 :                 return 0;
     578                 :         }
     579                 : 
     580                 :         len3 = strspn(class_name, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377");
     581                 :         if (len3 != len)
     582                 :         {
     583                 :                 *p = YYCURSOR + len3 - len;
     584                 :                 return 0;
     585                 :         }
     586                 : 
     587                 :         class_name = estrndup(class_name, len);
     588                 : 
     589                 :         do {
     590                 :                 /* Try to find class directly */
     591                 :                 if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
     592                 :                         ce = *pce;
     593                 :                         break;
     594                 :                 }
     595                 :                 
     596                 :                 /* Check for unserialize callback */
     597                 :                 if ((PG(unserialize_callback_func) == NULL) || (PG(unserialize_callback_func)[0] == '\0')) {
     598                 :                         incomplete_class = 1;
     599                 :                         ce = PHP_IC_ENTRY;
     600                 :                         break;
     601                 :                 }
     602                 :                 
     603                 :                 /* Call unserialize callback */
     604                 :                 MAKE_STD_ZVAL(user_func);
     605                 :                 ZVAL_STRING(user_func, PG(unserialize_callback_func), 1);
     606                 :                 args[0] = &arg_func_name;
     607                 :                 MAKE_STD_ZVAL(arg_func_name);
     608                 :                 ZVAL_STRING(arg_func_name, class_name, 1);
     609                 :                 if (call_user_function_ex(CG(function_table), NULL, user_func, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) != SUCCESS) {
     610                 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "defined (%s) but not found", user_func->value.str.val);
     611                 :                         incomplete_class = 1;
     612                 :                         ce = PHP_IC_ENTRY;
     613                 :                         zval_ptr_dtor(&user_func);
     614                 :                         zval_ptr_dtor(&arg_func_name);
     615                 :                         break;
     616                 :                 }
     617                 :                 if (retval_ptr) {
     618                 :                         zval_ptr_dtor(&retval_ptr);
     619                 :                 }
     620                 :                 
     621                 :                 /* The callback function may have defined the class */
     622                 :                 if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
     623                 :                         ce = *pce;
     624                 :                 } else {
     625                 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function %s() hasn't defined the class it was called for", user_func->value.str.val);
     626                 :                         incomplete_class = 1;
     627                 :                         ce = PHP_IC_ENTRY;
     628                 :                 }
     629                 : 
     630                 :                 zval_ptr_dtor(&user_func);
     631                 :                 zval_ptr_dtor(&arg_func_name);
     632                 :                 break;
     633                 :         } while (1);
     634                 : 
     635                 :         *p = YYCURSOR;
     636                 : 
     637                 :         if(custom_object) {
     638                 :                 efree(class_name);
     639                 :                 return object_custom(UNSERIALIZE_PASSTHRU, ce);
     640                 :         }
     641                 :         
     642                 :         elements = object_common1(UNSERIALIZE_PASSTHRU, ce);
     643                 : 
     644                 :         if (incomplete_class) {
     645                 :                 php_store_class_name(*rval, class_name, len2);
     646                 :         }
     647                 :         efree(class_name);
     648                 : 
     649                 :         return object_common2(UNSERIALIZE_PASSTHRU, elements);
     650                 : }
     651                 : #line 652 "ext/standard/var_unserializer.c"
     652               0 : yy25:
     653               0 :                 yych = *++YYCURSOR;
     654               0 :                 if(yych <= ',') {
     655               0 :                         if(yych != '+') goto yy18;
     656                 :                 } else {
     657               0 :                         if(yych <= '-') goto yy26;
     658               0 :                         if(yych <= '/') goto yy18;
     659               0 :                         if(yych <= '9') goto yy27;
     660               0 :                         goto yy18;
     661                 :                 }
     662               0 : yy26:
     663               0 :                 yych = *++YYCURSOR;
     664               0 :                 if(yych <= '/') goto yy18;
     665               0 :                 if(yych >= ':') goto yy18;
     666               0 : yy27:
     667               0 :                 ++YYCURSOR;
     668               0 :                 if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
     669               0 :                 yych = *YYCURSOR;
     670               0 :                 if(yych <= '/') goto yy18;
     671               0 :                 if(yych <= '9') goto yy27;
     672               0 :                 if(yych >= ';') goto yy18;
     673               0 :                 yych = *++YYCURSOR;
     674               0 :                 if(yych != '"') goto yy18;
     675               0 :                 ++YYCURSOR;
     676                 : #line 568 "ext/standard/var_unserializer.re"
     677                 :                 {
     678                 : 
     679                 :         INIT_PZVAL(*rval);
     680                 :         
     681                 :         return object_common2(UNSERIALIZE_PASSTHRU,
     682                 :                         object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
     683                 : }
     684                 : #line 685 "ext/standard/var_unserializer.c"
     685               0 : yy32:
     686               0 :                 yych = *++YYCURSOR;
     687               0 :                 if(yych == '+') goto yy33;
     688               0 :                 if(yych <= '/') goto yy18;
     689               0 :                 if(yych <= '9') goto yy34;
     690               0 :                 goto yy18;
     691               0 : yy33:
     692               0 :                 yych = *++YYCURSOR;
     693               0 :                 if(yych <= '/') goto yy18;
     694               0 :                 if(yych >= ':') goto yy18;
     695               0 : yy34:
     696               0 :                 ++YYCURSOR;
     697               0 :                 if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
     698               0 :                 yych = *YYCURSOR;
     699               0 :                 if(yych <= '/') goto yy18;
     700               0 :                 if(yych <= '9') goto yy34;
     701               0 :                 if(yych >= ';') goto yy18;
     702               0 :                 yych = *++YYCURSOR;
     703               0 :                 if(yych != '{') goto yy18;
     704               0 :                 ++YYCURSOR;
     705                 : #line 546 "ext/standard/var_unserializer.re"
     706                 :                 {
     707                 :         long elements = parse_iv(start + 2);
     708                 :         /* use iv() not uiv() in order to check data range */
     709                 :         *p = YYCURSOR;
     710                 : 
     711                 :         if (elements < 0) {
     712                 :                 return 0;
     713                 :         }
     714                 : 
     715                 :         INIT_PZVAL(*rval);
     716                 :         Z_TYPE_PP(rval) = IS_ARRAY;
     717                 :         ALLOC_HASHTABLE(Z_ARRVAL_PP(rval));
     718                 : 
     719                 :         zend_hash_init(Z_ARRVAL_PP(rval), elements + 1, NULL, ZVAL_PTR_DTOR, 0);
     720                 : 
     721                 :         if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_PP(rval), elements)) {
     722                 :                 return 0;
     723                 :         }
     724                 : 
     725                 :         return finish_nested_data(UNSERIALIZE_PASSTHRU);
     726                 : }
     727                 : #line 728 "ext/standard/var_unserializer.c"
     728               0 : yy39:
     729               0 :                 yych = *++YYCURSOR;
     730               0 :                 if(yych == '+') goto yy40;
     731               0 :                 if(yych <= '/') goto yy18;
     732               0 :                 if(yych <= '9') goto yy41;
     733               0 :                 goto yy18;
     734               0 : yy40:
     735               0 :                 yych = *++YYCURSOR;
     736               0 :                 if(yych <= '/') goto yy18;
     737               0 :                 if(yych >= ':') goto yy18;
     738               0 : yy41:
     739               0 :                 ++YYCURSOR;
     740               0 :                 if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
     741               0 :                 yych = *YYCURSOR;
     742               0 :                 if(yych <= '/') goto yy18;
     743               0 :                 if(yych <= '9') goto yy41;
     744               0 :                 if(yych >= ';') goto yy18;
     745               0 :                 yych = *++YYCURSOR;
     746               0 :                 if(yych != '"') goto yy18;
     747               0 :                 ++YYCURSOR;
     748                 : #line 517 "ext/standard/var_unserializer.re"
     749                 :                 {
     750                 :         size_t len, maxlen;
     751                 :         char *str;
     752                 : 
     753                 :         len = parse_uiv(start + 2);
     754                 :         maxlen = max - YYCURSOR;
     755                 :         if (maxlen < len) {
     756                 :                 *p = start + 2;
     757                 :                 return 0;
     758                 :         }
     759                 : 
     760                 :         if ((str = unserialize_str(&YYCURSOR, &len)) == NULL) {
     761                 :                 return 0;
     762                 :         }
     763                 : 
     764                 :         if (*(YYCURSOR) != '"') {
     765                 :                 efree(str);
     766                 :                 *p = YYCURSOR;
     767                 :                 return 0;
     768                 :         }
     769                 : 
     770                 :         YYCURSOR += 2;
     771                 :         *p = YYCURSOR;
     772                 : 
     773                 :         INIT_PZVAL(*rval);
     774                 :         ZVAL_STRINGL(*rval, str, len, 0);
     775                 :         return 1;
     776                 : }
     777                 : #line 778 "ext/standard/var_unserializer.c"
     778               0 : yy46:
     779               0 :                 yych = *++YYCURSOR;
     780               0 :                 if(yych == '+') goto yy47;
     781               0 :                 if(yych <= '/') goto yy18;
     782               0 :                 if(yych <= '9') goto yy48;
     783               0 :                 goto yy18;
     784               0 : yy47:
     785               0 :                 yych = *++YYCURSOR;
     786               0 :                 if(yych <= '/') goto yy18;
     787               0 :                 if(yych >= ':') goto yy18;
     788               0 : yy48:
     789               0 :                 ++YYCURSOR;
     790               0 :                 if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
     791               0 :                 yych = *YYCURSOR;
     792               0 :                 if(yych <= '/') goto yy18;
     793               0 :                 if(yych <= '9') goto yy48;
     794               0 :                 if(yych >= ';') goto yy18;
     795               0 :                 yych = *++YYCURSOR;
     796               0 :                 if(yych != '"') goto yy18;
     797               0 :                 ++YYCURSOR;
     798                 : #line 489 "ext/standard/var_unserializer.re"
     799                 :                 {
     800                 :         size_t len, maxlen;
     801                 :         char *str;
     802                 : 
     803                 :         len = parse_uiv(start + 2);
     804                 :         maxlen = max - YYCURSOR;
     805                 :         if (maxlen < len) {
     806                 :                 *p = start + 2;
     807                 :                 return 0;
     808                 :         }
     809                 : 
     810                 :         str = (char*)YYCURSOR;
     811                 : 
     812                 :         YYCURSOR += len;
     813                 : 
     814                 :         if (*(YYCURSOR) != '"') {
     815                 :                 *p = YYCURSOR;
     816                 :                 return 0;
     817                 :         }
     818                 : 
     819                 :         YYCURSOR += 2;
     820                 :         *p = YYCURSOR;
     821                 : 
     822                 :         INIT_PZVAL(*rval);
     823                 :         ZVAL_STRINGL(*rval, str, len, 1);
     824                 :         return 1;
     825                 : }
     826                 : #line 827 "ext/standard/var_unserializer.c"
     827               0 : yy53:
     828               0 :                 yych = *++YYCURSOR;
     829               0 :                 if(yych <= '/') {
     830               0 :                         if(yych <= ',') {
     831               0 :                                 if(yych == '+') goto yy57;
     832               0 :                                 goto yy18;
     833                 :                         } else {
     834               0 :                                 if(yych <= '-') goto yy55;
     835               0 :                                 if(yych <= '.') goto yy60;
     836               0 :                                 goto yy18;
     837                 :                         }
     838                 :                 } else {
     839               0 :                         if(yych <= 'I') {
     840               0 :                                 if(yych <= '9') goto yy58;
     841               0 :                                 if(yych <= 'H') goto yy18;
     842               0 :                                 goto yy56;
     843                 :                         } else {
     844               0 :                                 if(yych != 'N') goto yy18;
     845                 :                         }
     846                 :                 }
     847               0 :                 yych = *++YYCURSOR;
     848               0 :                 if(yych == 'A') goto yy76;
     849               0 :                 goto yy18;
     850               0 : yy55:
     851               0 :                 yych = *++YYCURSOR;
     852               0 :                 if(yych <= '/') {
     853               0 :                         if(yych == '.') goto yy60;
     854               0 :                         goto yy18;
     855                 :                 } else {
     856               0 :                         if(yych <= '9') goto yy58;
     857               0 :                         if(yych != 'I') goto yy18;
     858                 :                 }
     859               0 : yy56:
     860               0 :                 yych = *++YYCURSOR;
     861               0 :                 if(yych == 'N') goto yy72;
     862               0 :                 goto yy18;
     863               0 : yy57:
     864               0 :                 yych = *++YYCURSOR;
     865               0 :                 if(yych == '.') goto yy60;
     866               0 :                 if(yych <= '/') goto yy18;
     867               0 :                 if(yych >= ':') goto yy18;
     868               0 : yy58:
     869               0 :                 ++YYCURSOR;
     870               0 :                 if((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
     871               0 :                 yych = *YYCURSOR;
     872               0 :                 if(yych <= ':') {
     873               0 :                         if(yych <= '.') {
     874               0 :                                 if(yych <= '-') goto yy18;
     875               0 :                                 goto yy70;
     876                 :                         } else {
     877               0 :                                 if(yych <= '/') goto yy18;
     878               0 :                                 if(yych <= '9') goto yy58;
     879               0 :                                 goto yy18;
     880                 :                         }
     881                 :                 } else {
     882               0 :                         if(yych <= 'E') {
     883               0 :                                 if(yych <= ';') goto yy63;
     884               0 :                                 if(yych <= 'D') goto yy18;
     885               0 :                                 goto yy65;
     886                 :                         } else {
     887               0 :                                 if(yych == 'e') goto yy65;
     888               0 :                                 goto yy18;
     889                 :                         }
     890                 :                 }
     891               0 : yy60:
     892               0 :                 yych = *++YYCURSOR;
     893               0 :                 if(yych <= '/') goto yy18;
     894               0 :                 if(yych >= ':') goto yy18;
     895               0 : yy61:
     896               0 :                 ++YYCURSOR;
     897               0 :                 if((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
     898               0 :                 yych = *YYCURSOR;
     899               0 :                 if(yych <= ';') {
     900               0 :                         if(yych <= '/') goto yy18;
     901               0 :                         if(yych <= '9') goto yy61;
     902               0 :                         if(yych <= ':') goto yy18;
     903                 :                 } else {
     904               0 :                         if(yych <= 'E') {
     905               0 :                                 if(yych <= 'D') goto yy18;
     906               0 :                                 goto yy65;
     907                 :                         } else {
     908               0 :                                 if(yych == 'e') goto yy65;
     909               0 :                                 goto yy18;
     910                 :                         }
     911                 :                 }
     912               0 : yy63:
     913               0 :                 ++YYCURSOR;
     914                 : #line 482 "ext/standard/var_unserializer.re"
     915                 :                 {
     916                 :         *p = YYCURSOR;
     917                 :         INIT_PZVAL(*rval);
     918                 :         ZVAL_DOUBLE(*rval, zend_strtod((const char *)start + 2, NULL));
     919                 :         return 1;
     920                 : }
     921                 : #line 922 "ext/standard/var_unserializer.c"
     922               0 : yy65:
     923               0 :                 yych = *++YYCURSOR;
     924               0 :                 if(yych <= ',') {
     925               0 :                         if(yych != '+') goto yy18;
     926                 :                 } else {
     927               0 :                         if(yych <= '-') goto yy66;
     928               0 :                         if(yych <= '/') goto yy18;
     929               0 :                         if(yych <= '9') goto yy67;
     930               0 :                         goto yy18;
     931                 :                 }
     932               0 : yy66:
     933               0 :                 yych = *++YYCURSOR;
     934               0 :                 if(yych <= ',') {
     935               0 :                         if(yych == '+') goto yy69;
     936               0 :                         goto yy18;
     937                 :                 } else {
     938               0 :                         if(yych <= '-') goto yy69;
     939               0 :                         if(yych <= '/') goto yy18;
     940               0 :                         if(yych >= ':') goto yy18;
     941                 :                 }
     942               0 : yy67:
     943               0 :                 ++YYCURSOR;
     944               0 :                 if(YYLIMIT == YYCURSOR) YYFILL(1);
     945               0 :                 yych = *YYCURSOR;
     946               0 :                 if(yych <= '/') goto yy18;
     947               0 :                 if(yych <= '9') goto yy67;
     948               0 :                 if(yych == ';') goto yy63;
     949               0 :                 goto yy18;
     950               0 : yy69:
     951               0 :                 yych = *++YYCURSOR;
     952               0 :                 if(yych <= '/') goto yy18;
     953               0 :                 if(yych <= '9') goto yy67;
     954               0 :                 goto yy18;
     955               0 : yy70:
     956               0 :                 ++YYCURSOR;
     957               0 :                 if((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
     958               0 :                 yych = *YYCURSOR;
     959               0 :                 if(yych <= ';') {
     960               0 :                         if(yych <= '/') goto yy18;
     961               0 :                         if(yych <= '9') goto yy70;
     962               0 :                         if(yych <= ':') goto yy18;
     963               0 :                         goto yy63;
     964                 :                 } else {
     965               0 :                         if(yych <= 'E') {
     966               0 :                                 if(yych <= 'D') goto yy18;
     967               0 :                                 goto yy65;
     968                 :                         } else {
     969               0 :                                 if(yych == 'e') goto yy65;
     970               0 :                                 goto yy18;
     971                 :                         }
     972                 :                 }
     973               0 : yy72:
     974               0 :                 yych = *++YYCURSOR;
     975               0 :                 if(yych != 'F') goto yy18;
     976               0 : yy73:
     977               0 :                 yych = *++YYCURSOR;
     978               0 :                 if(yych != ';') goto yy18;
     979               0 :                 ++YYCURSOR;
     980                 : #line 467 "ext/standard/var_unserializer.re"
     981                 :                 {
     982                 :         *p = YYCURSOR;
     983                 :         INIT_PZVAL(*rval);
     984                 : 
     985                 :         if (!strncmp(start + 2, "NAN", 3)) {
     986                 :                 ZVAL_DOUBLE(*rval, php_get_nan());
     987                 :         } else if (!strncmp(start + 2, "INF", 3)) {
     988                 :                 ZVAL_DOUBLE(*rval, php_get_inf());
     989                 :         } else if (!strncmp(start + 2, "-INF", 4)) {
     990                 :                 ZVAL_DOUBLE(*rval, -php_get_inf());
     991                 :         }
     992                 : 
     993                 :         return 1;
     994                 : }
     995                 : #line 996 "ext/standard/var_unserializer.c"
     996               0 : yy76:
     997               0 :                 yych = *++YYCURSOR;
     998               0 :                 if(yych == 'N') goto yy73;
     999               0 :                 goto yy18;
    1000               0 : yy77:
    1001               0 :                 yych = *++YYCURSOR;
    1002               0 :                 if(yych <= ',') {
    1003               0 :                         if(yych != '+') goto yy18;
    1004                 :                 } else {
    1005               0 :                         if(yych <= '-') goto yy78;
    1006               0 :                         if(yych <= '/') goto yy18;
    1007               0 :                         if(yych <= '9') goto yy79;
    1008               0 :                         goto yy18;
    1009                 :                 }
    1010               0 : yy78:
    1011               0 :                 yych = *++YYCURSOR;
    1012               0 :                 if(yych <= '/') goto yy18;
    1013               0 :                 if(yych >= ':') goto yy18;
    1014               0 : yy79:
    1015               0 :                 ++YYCURSOR;
    1016               0 :                 if(YYLIMIT == YYCURSOR) YYFILL(1);
    1017               0 :                 yych = *YYCURSOR;
    1018               0 :                 if(yych <= '/') goto yy18;
    1019               0 :                 if(yych <= '9') goto yy79;
    1020               0 :                 if(yych != ';') goto yy18;
    1021               0 :                 ++YYCURSOR;
    1022                 : #line 460 "ext/standard/var_unserializer.re"
    1023                 :                 {
    1024                 :         *p = YYCURSOR;
    1025                 :         INIT_PZVAL(*rval);
    1026                 :         ZVAL_LONG(*rval, parse_iv(start + 2));
    1027                 :         return 1;
    1028                 : }
    1029                 : #line 1030 "ext/standard/var_unserializer.c"
    1030               0 : yy83:
    1031               0 :                 yych = *++YYCURSOR;
    1032               0 :                 if(yych <= '/') goto yy18;
    1033               0 :                 if(yych >= '2') goto yy18;
    1034               0 :                 yych = *++YYCURSOR;
    1035               0 :                 if(yych != ';') goto yy18;
    1036               0 :                 ++YYCURSOR;
    1037                 : #line 453 "ext/standard/var_unserializer.re"
    1038                 :                 {
    1039                 :         *p = YYCURSOR;
    1040                 :         INIT_PZVAL(*rval);
    1041                 :         ZVAL_BOOL(*rval, parse_iv(start + 2));
    1042                 :         return 1;
    1043                 : }
    1044                 : #line 1045 "ext/standard/var_unserializer.c"
    1045               0 : yy87:
    1046               0 :                 ++YYCURSOR;
    1047                 : #line 446 "ext/standard/var_unserializer.re"
    1048                 :                 {
    1049                 :         *p = YYCURSOR;
    1050                 :         INIT_PZVAL(*rval);
    1051                 :         ZVAL_NULL(*rval);
    1052                 :         return 1;
    1053                 : }
    1054                 : #line 1055 "ext/standard/var_unserializer.c"
    1055               0 : yy89:
    1056               0 :                 yych = *++YYCURSOR;
    1057               0 :                 if(yych <= ',') {
    1058               0 :                         if(yych != '+') goto yy18;
    1059                 :                 } else {
    1060               0 :                         if(yych <= '-') goto yy90;
    1061               0 :                         if(yych <= '/') goto yy18;
    1062               0 :                         if(yych <= '9') goto yy91;
    1063               0 :                         goto yy18;
    1064                 :                 }
    1065               0 : yy90:
    1066               0 :                 yych = *++YYCURSOR;
    1067               0 :                 if(yych <= '/') goto yy18;
    1068               0 :                 if(yych >= ':') goto yy18;
    1069               0 : yy91:
    1070               0 :                 ++YYCURSOR;
    1071               0 :                 if(YYLIMIT == YYCURSOR) YYFILL(1);
    1072               0 :                 yych = *YYCURSOR;
    1073               0 :                 if(yych <= '/') goto yy18;
    1074               0 :                 if(yych <= '9') goto yy91;
    1075               0 :                 if(yych != ';') goto yy18;
    1076               0 :                 ++YYCURSOR;
    1077                 : #line 423 "ext/standard/var_unserializer.re"
    1078                 :                 {
    1079                 :         long id;
    1080                 : 
    1081                 :         *p = YYCURSOR;
    1082                 :         if (!var_hash) return 0;
    1083                 : 
    1084                 :         id = parse_iv(start + 2) - 1;
    1085                 :         if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
    1086                 :                 return 0;
    1087                 :         }
    1088                 : 
    1089                 :         if (*rval == *rval_ref) return 0;
    1090                 : 
    1091                 :         if (*rval != NULL) {
    1092                 :                 zval_ptr_dtor(rval);
    1093                 :         }
    1094                 :         *rval = *rval_ref;
    1095                 :         (*rval)->refcount++;
    1096                 :         (*rval)->is_ref = 0;
    1097                 :         
    1098                 :         return 1;
    1099                 : }
    1100                 : #line 1101 "ext/standard/var_unserializer.c"
    1101               0 : yy95:
    1102               0 :                 yych = *++YYCURSOR;
    1103               0 :                 if(yych <= ',') {
    1104               0 :                         if(yych != '+') goto yy18;
    1105                 :                 } else {
    1106               0 :                         if(yych <= '-') goto yy96;
    1107               0 :                         if(yych <= '/') goto yy18;
    1108               0 :                         if(yych <= '9') goto yy97;
    1109               0 :                         goto yy18;
    1110                 :                 }
    1111               0 : yy96:
    1112               0 :                 yych = *++YYCURSOR;
    1113               0 :                 if(yych <= '/') goto yy18;
    1114               0 :                 if(yych >= ':') goto yy18;
    1115               0 : yy97:
    1116               0 :                 ++YYCURSOR;
    1117               0 :                 if(YYLIMIT == YYCURSOR) YYFILL(1);
    1118               0 :                 yych = *YYCURSOR;
    1119               0 :                 if(yych <= '/') goto yy18;
    1120               0 :                 if(yych <= '9') goto yy97;
    1121               0 :                 if(yych != ';') goto yy18;
    1122               0 :                 ++YYCURSOR;
    1123                 : #line 402 "ext/standard/var_unserializer.re"
    1124                 :                 {
    1125                 :         long id;
    1126                 : 
    1127                 :         *p = YYCURSOR;
    1128                 :         if (!var_hash) return 0;
    1129                 : 
    1130                 :         id = parse_iv(start + 2) - 1;
    1131                 :         if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
    1132                 :                 return 0;
    1133                 :         }
    1134                 : 
    1135                 :         if (*rval != NULL) {
    1136                 :                 zval_ptr_dtor(rval);
    1137                 :         }
    1138                 :         *rval = *rval_ref;
    1139                 :         (*rval)->refcount++;
    1140                 :         (*rval)->is_ref = 1;
    1141                 :         
    1142                 :         return 1;
    1143                 : }
    1144                 : #line 1145 "ext/standard/var_unserializer.c"
    1145                 :         }
    1146                 : }
    1147                 : #line 696 "ext/standard/var_unserializer.re"
    1148                 : 
    1149                 : 
    1150                 :         return 0;
    1151                 : }

Generated by: LTP GCOV extension version 1.5