PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - pack.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 384 505 76.0 %
Date: 2014-12-13 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Author: Chris Schneider <cschneid@relog.ch>                          |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : /* $Id$ */
      19             : 
      20             : #include "php.h"
      21             : 
      22             : #include <stdio.h>
      23             : #include <stdlib.h>
      24             : #include <errno.h>
      25             : #include <sys/types.h>
      26             : #include <sys/stat.h>
      27             : #include <fcntl.h>
      28             : #ifdef PHP_WIN32
      29             : #define O_RDONLY _O_RDONLY
      30             : #include "win32/param.h"
      31             : #elif defined(NETWARE)
      32             : #ifdef USE_WINSOCK
      33             : #include <novsock2.h>
      34             : #else
      35             : #include <sys/socket.h>
      36             : #endif
      37             : #include <sys/param.h>
      38             : #else
      39             : #include <sys/param.h>
      40             : #endif
      41             : #include "ext/standard/head.h"
      42             : #include "php_string.h"
      43             : #include "pack.h"
      44             : #if HAVE_PWD_H
      45             : #ifdef PHP_WIN32
      46             : #include "win32/pwd.h"
      47             : #else
      48             : #include <pwd.h>
      49             : #endif
      50             : #endif
      51             : #include "fsock.h"
      52             : #if HAVE_NETINET_IN_H
      53             : #include <netinet/in.h>
      54             : #endif
      55             : 
      56             : #define INC_OUTPUTPOS(a,b) \
      57             :         if ((a) < 0 || ((INT_MAX - outputpos)/((int)b)) < (a)) { \
      58             :                 efree(formatcodes);     \
      59             :                 efree(formatargs);      \
      60             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: integer overflow in format string", code); \
      61             :                 RETURN_FALSE; \
      62             :         } \
      63             :         outputpos += (a)*(b);
      64             : 
      65             : /* Whether machine is little endian */
      66             : char machine_little_endian;
      67             : 
      68             : /* Mapping of byte from char (8bit) to long for machine endian */
      69             : static int byte_map[1];
      70             : 
      71             : /* Mappings of bytes from int (machine dependent) to int for machine endian */
      72             : static int int_map[sizeof(int)];
      73             : 
      74             : /* Mappings of bytes from shorts (16bit) for all endian environments */
      75             : static int machine_endian_short_map[2];
      76             : static int big_endian_short_map[2];
      77             : static int little_endian_short_map[2];
      78             : 
      79             : /* Mappings of bytes from longs (32bit) for all endian environments */
      80             : static int machine_endian_long_map[4];
      81             : static int big_endian_long_map[4];
      82             : static int little_endian_long_map[4];
      83             : 
      84             : #if SIZEOF_ZEND_LONG > 4
      85             : /* Mappings of bytes from quads (64bit) for all endian environments */
      86             : static int machine_endian_longlong_map[8];
      87             : static int big_endian_longlong_map[8];
      88             : static int little_endian_longlong_map[8];
      89             : #endif
      90             : 
      91             : /* {{{ php_pack
      92             :  */
      93      504644 : static void php_pack(zval *val, size_t size, int *map, char *output)
      94             : {
      95             :         int i;
      96             :         char *v;
      97             : 
      98      504644 :         convert_to_long_ex(val);
      99      504644 :         v = (char *) &Z_LVAL_P(val);
     100             : 
     101     1041668 :         for (i = 0; i < size; i++) {
     102      537024 :                 *output++ = v[map[i]];
     103             :         }
     104      504644 : }
     105             : /* }}} */
     106             : 
     107             : /* pack() idea stolen from Perl (implemented formats behave the same as there except J and P)
     108             :  * Implemented formats are Z, A, a, h, H, c, C, s, S, i, I, l, L, n, N, q, Q, J, P, f, d, x, X, @.
     109             :  */
     110             : /* {{{ proto string pack(string format, mixed arg1 [, mixed arg2 [, mixed ...]])
     111             :    Takes one or more arguments and packs them into a binary string according to the format argument */
     112      153398 : PHP_FUNCTION(pack)
     113             : {
     114      153398 :         zval *argv = NULL;
     115             :         int num_args, i;
     116             :         int currentarg;
     117             :         char *format;
     118             :         int formatlen;
     119             :         char *formatcodes;
     120             :         int *formatargs;
     121      153398 :         int formatcount = 0;
     122      153398 :         int outputpos = 0, outputsize = 0;
     123             :         char *output;
     124             : 
     125      153398 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &argv, &num_args) == FAILURE) {
     126           0 :                 return;
     127             :         }
     128             : 
     129      306796 :         if (Z_ISREF(argv[0])) {
     130           0 :                 SEPARATE_ZVAL(&argv[0]);
     131             :         }
     132      306796 :         convert_to_string_ex(&argv[0]);
     133             : 
     134      153398 :         format = Z_STRVAL(argv[0]);
     135      153398 :         formatlen = Z_STRLEN(argv[0]);
     136             : 
     137             :         /* We have a maximum of <formatlen> format codes to deal with */
     138      153398 :         formatcodes = safe_emalloc(formatlen, sizeof(*formatcodes), 0);
     139      153398 :         formatargs = safe_emalloc(formatlen, sizeof(*formatargs), 0);
     140      153398 :         currentarg = 1;
     141             : 
     142             :         /* Preprocess format into formatcodes and formatargs */
     143      309099 :         for (i = 0; i < formatlen; formatcount++) {
     144      155701 :                 char code = format[i++];
     145      155701 :                 int arg = 1;
     146             : 
     147             :                 /* Handle format arguments if any */
     148      155701 :                 if (i < formatlen) {
     149      153767 :                         char c = format[i];
     150             : 
     151      153767 :                         if (c == '*') {
     152          40 :                                 arg = -1;
     153          40 :                                 i++;
     154             :                         }
     155      153727 :                         else if (c >= '0' && c <= '9') {
     156      152026 :                                 arg = atoi(&format[i]);
     157             :                   
     158      456590 :                                 while (format[i] >= '0' && format[i] <= '9' && i < formatlen) {
     159      152538 :                                         i++;
     160             :                                 }
     161             :                         }
     162             :                 }
     163             : 
     164             :                 /* Handle special arg '*' for all codes and check argv overflows */
     165      155701 :                 switch ((int) code) {
     166             :                         /* Never uses any args */
     167             :                         case 'x': 
     168             :                         case 'X':       
     169             :                         case '@':
     170           0 :                                 if (arg < 0) {
     171           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: '*' ignored", code);
     172           0 :                                         arg = 1;
     173             :                                 }
     174           0 :                                 break;
     175             : 
     176             :                         /* Always uses one arg */
     177             :                         case 'a': 
     178             :                         case 'A': 
     179             :                         case 'Z': 
     180             :                         case 'h': 
     181             :                         case 'H':
     182         795 :                                 if (currentarg >= num_args) {
     183           0 :                                         efree(formatcodes);
     184           0 :                                         efree(formatargs);
     185           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: not enough arguments", code);
     186           0 :                                         RETURN_FALSE;
     187             :                                 }
     188             : 
     189         795 :                                 if (arg < 0) {
     190          80 :                                         if (Z_ISREF(argv[currentarg])) {
     191           0 :                                                 SEPARATE_ZVAL(&argv[currentarg]);
     192             :                                         }
     193          80 :                                         convert_to_string_ex(&argv[currentarg]);
     194          40 :                                         arg = Z_STRLEN(argv[currentarg]);
     195          40 :                                         if (code == 'Z') {
     196             :                                                 /* add one because Z is always NUL-terminated:
     197             :                                                  * pack("Z*", "aa") === "aa\0"
     198             :                                                  * pack("Z2", "aa") === "a\0" */
     199           1 :                                                 arg++;
     200             :                                         }
     201             :                                 }
     202             : 
     203         795 :                                 currentarg++;
     204         795 :                                 break;
     205             : 
     206             :                         /* Use as many args as specified */
     207             :                         case 'q':
     208             :                         case 'Q':
     209             :                         case 'J':
     210             :                         case 'P':
     211             : #if SIZEOF_ZEND_LONG < 8
     212             :                                         efree(formatcodes);
     213             :                                         efree(formatargs);
     214             :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "64-bit format codes are not available for 32-bit versions of PHP");
     215             :                                         RETURN_FALSE;
     216             : #endif
     217             :                         case 'c': 
     218             :                         case 'C': 
     219             :                         case 's': 
     220             :                         case 'S': 
     221             :                         case 'i': 
     222             :                         case 'I':
     223             :                         case 'l': 
     224             :                         case 'L': 
     225             :                         case 'n': 
     226             :                         case 'N': 
     227             :                         case 'v': 
     228             :                         case 'V':
     229             :                         case 'f': 
     230             :                         case 'd': 
     231      154906 :                                 if (arg < 0) {
     232           0 :                                         arg = num_args - currentarg;
     233             :                                 }
     234             : 
     235      154906 :                                 currentarg += arg;
     236             : 
     237      154906 :                                 if (currentarg > num_args) {
     238           0 :                                         efree(formatcodes);
     239           0 :                                         efree(formatargs);
     240           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: too few arguments", code);
     241           0 :                                         RETURN_FALSE;
     242             :                                 }
     243      154906 :                                 break;
     244             : 
     245             :                         default:
     246           0 :                                 efree(formatcodes);
     247           0 :                                 efree(formatargs);
     248           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: unknown format code", code);
     249           0 :                                 RETURN_FALSE;
     250             :                 }
     251             : 
     252      155701 :                 formatcodes[formatcount] = code;
     253      155701 :                 formatargs[formatcount] = arg;
     254             :         }
     255             : 
     256      153398 :         if (currentarg < num_args) {
     257           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%d arguments unused", (num_args - currentarg));
     258             :         }
     259             : 
     260             :         /* Calculate output length and upper bound while processing*/
     261      309099 :         for (i = 0; i < formatcount; i++) {
     262      155701 :             int code = (int) formatcodes[i];
     263      155701 :                 int arg = formatargs[i];
     264             : 
     265      155701 :                 switch ((int) code) {
     266             :                         case 'h': 
     267             :                         case 'H': 
     268          43 :                                 INC_OUTPUTPOS((arg + (arg % 2)) / 2,1)  /* 4 bit per arg */
     269          43 :                                 break;
     270             : 
     271             :                         case 'a': 
     272             :                         case 'A':
     273             :                         case 'Z':
     274             :                         case 'c': 
     275             :                         case 'C':
     276             :                         case 'x':
     277      144815 :                                 INC_OUTPUTPOS(arg,1)            /* 8 bit per arg */
     278      144815 :                                 break;
     279             : 
     280             :                         case 's': 
     281             :                         case 'S': 
     282             :                         case 'n': 
     283             :                         case 'v':
     284          95 :                                 INC_OUTPUTPOS(arg,2)            /* 16 bit per arg */
     285          95 :                                 break;
     286             : 
     287             :                         case 'i': 
     288             :                         case 'I':
     289           3 :                                 INC_OUTPUTPOS(arg,sizeof(int))
     290           3 :                                 break;
     291             : 
     292             :                         case 'l': 
     293             :                         case 'L': 
     294             :                         case 'N': 
     295             :                         case 'V':
     296       10712 :                                 INC_OUTPUTPOS(arg,4)            /* 32 bit per arg */
     297       10712 :                                 break;
     298             : 
     299             : #if SIZEOF_ZEND_LONG > 4
     300             :                         case 'q':
     301             :                         case 'Q':
     302             :                         case 'J':
     303             :                         case 'P':
     304          20 :                                 INC_OUTPUTPOS(arg,8)            /* 32 bit per arg */
     305          20 :                                 break;
     306             : #endif
     307             : 
     308             :                         case 'f':
     309           0 :                                 INC_OUTPUTPOS(arg,sizeof(float))
     310           0 :                                 break;
     311             : 
     312             :                         case 'd':
     313          13 :                                 INC_OUTPUTPOS(arg,sizeof(double))
     314          13 :                                 break;
     315             : 
     316             :                         case 'X':
     317           0 :                                 outputpos -= arg;
     318             : 
     319           0 :                                 if (outputpos < 0) {
     320           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: outside of string", code);
     321           0 :                                         outputpos = 0;
     322             :                                 }
     323           0 :                                 break;
     324             : 
     325             :                         case '@':
     326           0 :                                 outputpos = arg;
     327             :                                 break;
     328             :                 }
     329             : 
     330      155701 :                 if (outputsize < outputpos) {
     331      155700 :                         outputsize = outputpos;
     332             :                 }
     333             :         }
     334             : 
     335      153398 :         output = emalloc(outputsize + 1);
     336      153398 :         outputpos = 0;
     337      153398 :         currentarg = 1;
     338             : 
     339             :         /* Do actual packing */
     340      309099 :         for (i = 0; i < formatcount; i++) {
     341      155701 :             int code = (int) formatcodes[i];
     342      155701 :                 int arg = formatargs[i];
     343             : 
     344      155701 :                 switch ((int) code) {
     345             :                         case 'a': 
     346             :                         case 'A': 
     347             :                         case 'Z': {
     348         752 :                                 int arg_cp = (code != 'Z') ? arg : MAX(0, arg - 1);
     349             : 
     350        1504 :                                 zend_string *str = zval_get_string(&argv[currentarg++]);
     351             : 
     352         752 :                                 memset(&output[outputpos], (code == 'a' || code == 'Z') ? '\0' : ' ', arg);
     353        1504 :                                 memcpy(&output[outputpos], str->val,
     354         752 :                                            (str->len < arg_cp) ? str->len : arg_cp);
     355             : 
     356         752 :                                 outputpos += arg;
     357             :                                 zend_string_release(str);
     358         752 :                                 break;
     359             :                         }
     360             : 
     361             :                         case 'h': 
     362             :                         case 'H': {
     363          43 :                                 int nibbleshift = (code == 'h') ? 0 : 4;
     364          43 :                                 int first = 1;
     365             : 
     366          86 :                                 zend_string *str = zval_get_string(&argv[currentarg++]);
     367          43 :                                 char *v = str->val; 
     368             : 
     369          43 :                                 outputpos--;
     370          43 :                                 if(arg > str->len) {
     371           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: not enough characters in string", code);
     372           0 :                                         arg = str->len;
     373             :                                 }
     374             : 
     375         674 :                                 while (arg-- > 0) {
     376         588 :                                         char n = *v++;
     377             : 
     378        1018 :                                         if (n >= '0' && n <= '9') {
     379         430 :                                                 n -= '0';
     380         158 :                                         } else if (n >= 'A' && n <= 'F') {
     381           0 :                                                 n -= ('A' - 10);
     382         316 :                                         } else if (n >= 'a' && n <= 'f') {
     383         158 :                                                 n -= ('a' - 10);
     384             :                                         } else {
     385           0 :                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: illegal hex digit %c", code, n);
     386           0 :                                                 n = 0;
     387             :                                         }
     388             : 
     389         588 :                                         if (first--) {
     390         296 :                                                 output[++outputpos] = 0;
     391             :                                         } else {
     392         292 :                                           first = 1;
     393             :                                         }
     394             : 
     395         588 :                                         output[outputpos] |= (n << nibbleshift);
     396         588 :                                         nibbleshift = (nibbleshift + 4) & 7;
     397             :                                 }
     398             : 
     399          43 :                                 outputpos++;
     400             :                                 zend_string_release(str);
     401          43 :                                 break;
     402             :                         }
     403             : 
     404             :                         case 'c': 
     405             :                         case 'C':
     406      781940 :                                 while (arg-- > 0) {
     407      493814 :                                         php_pack(&argv[currentarg++], 1, byte_map, &output[outputpos]);
     408      493814 :                                         outputpos++;
     409             :                                 }
     410      144063 :                                 break;
     411             : 
     412             :                         case 's': 
     413             :                         case 'S': 
     414             :                         case 'n': 
     415             :                         case 'v': {
     416          95 :                                 int *map = machine_endian_short_map;
     417             : 
     418          95 :                                 if (code == 'n') {
     419          93 :                                         map = big_endian_short_map;
     420           2 :                                 } else if (code == 'v') {
     421           0 :                                         map = little_endian_short_map;
     422             :                                 }
     423             : 
     424         285 :                                 while (arg-- > 0) {
     425          95 :                                         php_pack(&argv[currentarg++], 2, map, &output[outputpos]);
     426          95 :                                         outputpos += 2;
     427             :                                 }
     428          95 :                                 break;
     429             :                         }
     430             : 
     431             :                         case 'i': 
     432             :                         case 'I': 
     433           9 :                                 while (arg-- > 0) {
     434           3 :                                         php_pack(&argv[currentarg++], sizeof(int), int_map, &output[outputpos]);
     435           3 :                                         outputpos += sizeof(int);
     436             :                                 }
     437           3 :                                 break;
     438             : 
     439             :                         case 'l': 
     440             :                         case 'L': 
     441             :                         case 'N': 
     442             :                         case 'V': {
     443       10712 :                                 int *map = machine_endian_long_map;
     444             : 
     445       10712 :                                 if (code == 'N') {
     446        8261 :                                         map = big_endian_long_map;
     447        2451 :                                 } else if (code == 'V') {
     448        2449 :                                         map = little_endian_long_map;
     449             :                                 }
     450             : 
     451       32136 :                                 while (arg-- > 0) {
     452       10712 :                                         php_pack(&argv[currentarg++], 4, map, &output[outputpos]);
     453       10712 :                                         outputpos += 4;
     454             :                                 }
     455       10712 :                                 break;
     456             :                         }
     457             : 
     458             : #if SIZEOF_ZEND_LONG > 4
     459             :                         case 'q':
     460             :                         case 'Q':
     461             :                         case 'J':
     462             :                         case 'P': {
     463          20 :                                 int *map = machine_endian_longlong_map;
     464             : 
     465          20 :                                 if (code == 'J') {
     466           5 :                                         map = big_endian_longlong_map;
     467          15 :                                 } else if (code == 'P') {
     468           5 :                                         map = little_endian_longlong_map;
     469             :                                 }
     470             : 
     471          60 :                                 while (arg-- > 0) {
     472          20 :                                         php_pack(&argv[currentarg++], 8, map, &output[outputpos]);
     473          20 :                                         outputpos += 8;
     474             :                                 }
     475          20 :                                 break;
     476             :                         }
     477             : #endif
     478             : 
     479             :                         case 'f': {
     480           0 :                                 while (arg-- > 0) {
     481           0 :                                         float v = (float) zval_get_double(&argv[currentarg++]);
     482           0 :                                         memcpy(&output[outputpos], &v, sizeof(v));
     483           0 :                                         outputpos += sizeof(v);
     484             :                                 }
     485           0 :                                 break;
     486             :                         }
     487             : 
     488             :                         case 'd': {
     489          39 :                                 while (arg-- > 0) {
     490          26 :                                         double v = (double) zval_get_double(&argv[currentarg++]);
     491          13 :                                         memcpy(&output[outputpos], &v, sizeof(v));
     492          13 :                                         outputpos += sizeof(v);
     493             :                                 }
     494          13 :                                 break;
     495             :                         }
     496             : 
     497             :                         case 'x':
     498           0 :                                 memset(&output[outputpos], '\0', arg);
     499           0 :                                 outputpos += arg;
     500           0 :                                 break;
     501             : 
     502             :                         case 'X':
     503           0 :                                 outputpos -= arg;
     504             : 
     505           0 :                                 if (outputpos < 0) {
     506           0 :                                         outputpos = 0;
     507             :                                 }
     508           0 :                                 break;
     509             : 
     510             :                         case '@':
     511           0 :                                 if (arg > outputpos) {
     512           0 :                                         memset(&output[outputpos], '\0', arg - outputpos);
     513             :                                 }
     514           0 :                                 outputpos = arg;
     515             :                                 break;
     516             :                 }
     517             :         }
     518             : 
     519      153398 :         efree(formatcodes);
     520      153398 :         efree(formatargs);
     521      153398 :         output[outputpos] = '\0';
     522      306796 :         RETVAL_STRINGL(output, outputpos);
     523      153398 :         efree(output);
     524             : }
     525             : /* }}} */
     526             : 
     527             : /* {{{ php_unpack
     528             :  */
     529          43 : static zend_long php_unpack(char *data, size_t size, int issigned, int *map)
     530             : {
     531             :         zend_long result;
     532          43 :         char *cresult = (char *) &result;
     533             :         int i;
     534             : 
     535          43 :         result = issigned ? -1 : 0;
     536             : 
     537         287 :         for (i = 0; i < size; i++) {
     538         244 :                 cresult[map[i]] = *data++;
     539             :         }
     540             : 
     541          43 :         return result;
     542             : }
     543             : /* }}} */
     544             : 
     545             : /* unpack() is based on Perl's unpack(), but is modified a bit from there.
     546             :  * Rather than depending on error-prone ordered lists or syntactically
     547             :  * unpleasant pass-by-reference, we return an object with named parameters 
     548             :  * (like *_fetch_object()). Syntax is "f[repeat]name/...", where "f" is the
     549             :  * formatter char (like pack()), "[repeat]" is the optional repeater argument,
     550             :  * and "name" is the name of the variable to use.
     551             :  * Example: "c2chars/nints" will return an object with fields
     552             :  * chars1, chars2, and ints.
     553             :  * Numeric pack types will return numbers, a and A will return strings,
     554             :  * f and d will return doubles.
     555             :  * Implemented formats are Z, A, a, h, H, c, C, s, S, i, I, l, L, n, N, q, Q, J, P, f, d, x, X, @.
     556             :  */
     557             : /* {{{ proto array unpack(string format, string input)
     558             :    Unpack binary string into named array elements according to format argument */
     559        1049 : PHP_FUNCTION(unpack)
     560             : {
     561             :         char *format, *input;
     562             :         zend_string *formatarg, *inputarg;
     563             :         zend_long formatlen, inputpos, inputlen;
     564             :         int i;
     565             : 
     566        1049 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &formatarg, 
     567             :                 &inputarg) == FAILURE) {
     568           2 :                 return;
     569             :         }
     570             : 
     571        1047 :         format = formatarg->val;
     572        1047 :         formatlen = formatarg->len;
     573        1047 :         input = inputarg->val;
     574        1047 :         inputlen = inputarg->len;
     575        1047 :         inputpos = 0;
     576             : 
     577        1047 :         array_init(return_value);
     578             : 
     579        3144 :         while (formatlen-- > 0) {
     580        1054 :                 char type = *(format++);
     581             :                 char c;
     582        1054 :                 int arg = 1, argb;
     583             :                 char *name;
     584             :                 int namelen;
     585        1054 :                 int size=0;
     586             : 
     587             :                 /* Handle format arguments if any */
     588        1054 :                 if (formatlen > 0) {
     589        1014 :                         c = *format;
     590             : 
     591        1045 :                         if (c >= '0' && c <= '9') {
     592          31 :                                 arg = atoi(format);
     593             : 
     594          96 :                                 while (formatlen > 0 && *format >= '0' && *format <= '9') {
     595          34 :                                         format++;
     596          34 :                                         formatlen--;
     597             :                                 }
     598         983 :                         } else if (c == '*') {
     599         974 :                                 arg = -1;
     600         974 :                                 format++;
     601         974 :                                 formatlen--;
     602             :                         }
     603             :                 }
     604             : 
     605             :                 /* Get of new value in array */
     606        1054 :                 name = format;
     607        1054 :                 argb = arg;
     608             : 
     609        2121 :                 while (formatlen > 0 && *format != '/') {
     610          13 :                         formatlen--;
     611          13 :                         format++;
     612             :                 }
     613             : 
     614        1054 :                 namelen = format - name;
     615             : 
     616        1054 :                 if (namelen > 200)
     617           0 :                         namelen = 200;
     618             : 
     619        1054 :                 switch ((int) type) {
     620             :                         /* Never use any input */
     621             :                         case 'X': 
     622           4 :                                 size = -1;
     623           4 :                                 break;
     624             : 
     625             :                         case '@':
     626           0 :                                 size = 0;
     627           0 :                                 break;
     628             : 
     629             :                         case 'a': 
     630             :                         case 'A':
     631             :                         case 'Z':
     632          13 :                                 size = arg;
     633          13 :                                 arg = 1;
     634          13 :                                 break;
     635             : 
     636             :                         case 'h': 
     637             :                         case 'H': 
     638         983 :                                 size = (arg > 0) ? (arg + (arg % 2)) / 2 : arg;
     639         983 :                                 arg = 1;
     640         983 :                                 break;
     641             : 
     642             :                         /* Use 1 byte of input */
     643             :                         case 'c': 
     644             :                         case 'C':
     645             :                         case 'x':
     646           1 :                                 size = 1;
     647           1 :                                 break;
     648             : 
     649             :                         /* Use 2 bytes of input */
     650             :                         case 's': 
     651             :                         case 'S': 
     652             :                         case 'n': 
     653             :                         case 'v':
     654           1 :                                 size = 2;
     655           1 :                                 break;
     656             : 
     657             :                         /* Use sizeof(int) bytes of input */
     658             :                         case 'i': 
     659             :                         case 'I':
     660           1 :                                 size = sizeof(int);
     661           1 :                                 break;
     662             : 
     663             :                         /* Use 4 bytes of input */
     664             :                         case 'l': 
     665             :                         case 'L': 
     666             :                         case 'N': 
     667             :                         case 'V':
     668          16 :                                 size = 4;
     669          16 :                                 break;
     670             : 
     671             :                         /* Use 8 bytes of input */
     672             :                         case 'q':
     673             :                         case 'Q':
     674             :                         case 'J':
     675             :                         case 'P':
     676             : #if SIZEOF_ZEND_LONG > 4
     677          20 :                                 size = 8;
     678          20 :                                 break;
     679             : #else
     680             :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "64-bit format codes are not available for 32-bit versions of PHP");
     681             :                                 zval_dtor(return_value);
     682             :                                 RETURN_FALSE;
     683             : #endif
     684             : 
     685             :                         /* Use sizeof(float) bytes of input */
     686             :                         case 'f':
     687           0 :                                 size = sizeof(float);
     688           0 :                                 break;
     689             : 
     690             :                         /* Use sizeof(double) bytes of input */
     691             :                         case 'd':
     692          13 :                                 size = sizeof(double);
     693          13 :                                 break;
     694             : 
     695             :                         default:
     696           2 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid format type %c", type);
     697             :                                 zval_dtor(return_value);
     698           2 :                                 RETURN_FALSE;
     699             :                                 break;
     700             :                 }
     701             : 
     702             :                 /* Do actual unpacking */
     703        2115 :                 for (i = 0; i != arg; i++ ) {
     704             :                         /* Space for name + number, safe as namelen is ensured <= 200 */
     705             :                         char n[256];
     706             : 
     707        2119 :                         if (arg != 1 || namelen == 0) {
     708             :                                 /* Need to add element number to name */
     709        1053 :                                 snprintf(n, sizeof(n), "%.*s%d", namelen, name, i + 1);
     710             :                         } else {
     711             :                                 /* Truncate name to next format code or end of string */
     712          13 :                                 snprintf(n, sizeof(n), "%.*s", namelen, name);
     713             :                         }
     714             : 
     715        1066 :                         if (size != 0 && size != -1 && INT_MAX - size + 1 < inputpos) {
     716           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: integer overflow", type);
     717           0 :                                 inputpos = 0;
     718             :                         }
     719             : 
     720        1066 :                         if ((inputpos + size) <= inputlen) {
     721        1063 :                                 switch ((int) type) {
     722             :                                         case 'a': {
     723             :                                                 /* a will not strip any trailing whitespace or null padding */
     724           3 :                                                 size_t len = inputlen - inputpos;       /* Remaining string */
     725             : 
     726             :                                                 /* If size was given take minimum of len and size */
     727           3 :                                                 if ((size >= 0) && (len > size)) {
     728           1 :                                                         len = size;
     729             :                                                 }
     730             : 
     731           3 :                                                 size = len;
     732             : 
     733           3 :                                                 add_assoc_stringl(return_value, n, &input[inputpos], len);
     734           3 :                                                 break;
     735             :                                         }
     736             :                                         case 'A': {
     737             :                                                 /* A will strip any trailing whitespace */
     738           2 :                                                 char padn = '\0'; char pads = ' '; char padt = '\t'; char padc = '\r'; char padl = '\n';
     739           2 :                                                 size_t len = inputlen - inputpos;       /* Remaining string */
     740             : 
     741             :                                                 /* If size was given take minimum of len and size */
     742           2 :                                                 if ((size >= 0) && (len > size)) {
     743           1 :                                                         len = size;
     744             :                                                 }
     745             : 
     746           2 :                                                 size = len;
     747             : 
     748             :                                                 /* Remove trailing white space and nulls chars from unpacked data */
     749          10 :                                                 while (--len >= 0) {
     750          26 :                                                         if (input[inputpos + len] != padn
     751           6 :                                                                 && input[inputpos + len] != pads
     752           5 :                                                                 && input[inputpos + len] != padt
     753           4 :                                                                 && input[inputpos + len] != padc
     754           3 :                                                                 && input[inputpos + len] != padl
     755             :                                                         )
     756           2 :                                                                 break;
     757             :                                                 }
     758             : 
     759           2 :                                                 add_assoc_stringl(return_value, n, &input[inputpos], len + 1);
     760           2 :                                                 break;
     761             :                                         }
     762             :                                         /* New option added for Z to remain in-line with the Perl implementation */
     763             :                                         case 'Z': {
     764             :                                                 /* Z will strip everything after the first null character */
     765           6 :                                                 char pad = '\0';
     766             :                                                 size_t   s,
     767           6 :                                                          len = inputlen - inputpos;     /* Remaining string */
     768             : 
     769             :                                                 /* If size was given take minimum of len and size */
     770           6 :                                                 if ((size >= 0) && (len > size)) {
     771           3 :                                                         len = size;
     772             :                                                 }
     773             : 
     774           6 :                                                 size = len;
     775             : 
     776             :                                                 /* Remove everything after the first null */
     777          17 :                                                 for (s=0 ; s < len ; s++) {
     778          15 :                                                         if (input[inputpos + s] == pad)
     779           4 :                                                                 break;
     780             :                                                 }
     781           6 :                                                 len = s;
     782             : 
     783           6 :                                                 add_assoc_stringl(return_value, n, &input[inputpos], len);
     784           6 :                                                 break;
     785             :                                         }
     786             : 
     787             :                                         
     788             :                                         case 'h': 
     789             :                                         case 'H': {
     790         983 :                                                 size_t len = (inputlen - inputpos) * 2; /* Remaining */
     791         983 :                                                 int nibbleshift = (type == 'h') ? 0 : 4;
     792         983 :                                                 int first = 1;
     793             :                                                 char *buf;
     794             :                                                 size_t ipos, opos;
     795             : 
     796             :                                                 /* If size was given take minimum of len and size */
     797         983 :                                                 if (size >= 0 && len > (size * 2)) {
     798           0 :                                                         len = size * 2;
     799             :                                                 } 
     800             : 
     801         983 :                                                 if (argb > 0) {      
     802          13 :                                                         len -= argb % 2;
     803             :                                                 }
     804             : 
     805         983 :                                                 buf = emalloc(len + 1);
     806             : 
     807        3459 :                                                 for (ipos = opos = 0; opos < len; opos++) {
     808        2476 :                                                         char cc = (input[inputpos + ipos] >> nibbleshift) & 0xf;
     809             : 
     810        2476 :                                                         if (cc < 10) {
     811        1261 :                                                                 cc += '0';
     812             :                                                         } else {
     813        1215 :                                                                 cc += 'a' - 10;
     814             :                                                         }
     815             : 
     816        2476 :                                                         buf[opos] = cc;
     817        2476 :                                                         nibbleshift = (nibbleshift + 4) & 7;
     818             : 
     819        2476 :                                                         if (first-- == 0) {
     820        1237 :                                                                 ipos++;
     821        1237 :                                                                 first = 1;
     822             :                                                         }
     823             :                                                 }
     824             : 
     825         983 :                                                 buf[len] = '\0';
     826         983 :                                                 add_assoc_stringl(return_value, n, buf, len);
     827         983 :                                                 efree(buf);
     828         983 :                                                 break;
     829             :                                         }
     830             : 
     831             :                                         case 'c': 
     832             :                                         case 'C': {
     833           2 :                                                 int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0;
     834           2 :                                                 zend_long v = php_unpack(&input[inputpos], 1, issigned, byte_map);
     835           2 :                                                 add_assoc_long(return_value, n, v);
     836           2 :                                                 break;
     837             :                                         }
     838             : 
     839             :                                         case 's': 
     840             :                                         case 'S': 
     841             :                                         case 'n': 
     842             :                                         case 'v': {
     843             :                                                 zend_long v;
     844           1 :                                                 int issigned = 0;
     845           1 :                                                 int *map = machine_endian_short_map;
     846             : 
     847           1 :                                                 if (type == 's') {
     848           0 :                                                         issigned = input[inputpos + (machine_little_endian ? 1 : 0)] & 0x80;
     849           1 :                                                 } else if (type == 'n') {
     850           0 :                                                         map = big_endian_short_map;
     851           1 :                                                 } else if (type == 'v') {
     852           1 :                                                         map = little_endian_short_map;
     853             :                                                 }
     854             : 
     855           1 :                                                 v = php_unpack(&input[inputpos], 2, issigned, map);
     856           1 :                                                 add_assoc_long(return_value, n, v);
     857           1 :                                                 break;
     858             :                                         }
     859             : 
     860             :                                         case 'i': 
     861             :                                         case 'I': {
     862             :                                                 zend_long v;
     863           1 :                                                 int issigned = 0;
     864             : 
     865           1 :                                                 if (type == 'i') {
     866           0 :                                                         issigned = input[inputpos + (machine_little_endian ? (sizeof(int) - 1) : 0)] & 0x80;
     867             :                                                 }
     868             : 
     869           1 :                                                 v = php_unpack(&input[inputpos], sizeof(int), issigned, int_map);
     870           1 :                                                 add_assoc_long(return_value, n, v);
     871           1 :                                                 break;
     872             :                                         }
     873             : 
     874             :                                         case 'l': 
     875             :                                         case 'L': 
     876             :                                         case 'N': 
     877             :                                         case 'V': {
     878          19 :                                                 int issigned = 0;
     879          19 :                                                 int *map = machine_endian_long_map;
     880          19 :                                                 zend_long v = 0;
     881             : 
     882          20 :                                                 if (type == 'l' || type == 'L') {
     883           1 :                                                         issigned = input[inputpos + (machine_little_endian ? 3 : 0)] & 0x80;
     884          18 :                                                 } else if (type == 'N') {
     885           8 :                                                         issigned = input[inputpos] & 0x80;
     886           8 :                                                         map = big_endian_long_map;
     887          10 :                                                 } else if (type == 'V') {
     888          10 :                                                         issigned = input[inputpos + 3] & 0x80;
     889          10 :                                                         map = little_endian_long_map;
     890             :                                                 }
     891             : 
     892          19 :                                                 if (SIZEOF_ZEND_LONG > 4 && issigned) {
     893           2 :                                                         v = ~INT_MAX;
     894             :                                                 }
     895             : 
     896          19 :                                                 v |= php_unpack(&input[inputpos], 4, issigned, map);
     897             :                                                 if (SIZEOF_ZEND_LONG > 4) {
     898          19 :                                                         if (type == 'l') {
     899           1 :                                                                 v = (signed int) v; 
     900             :                                                         } else {
     901          18 :                                                                 v = (unsigned int) v;
     902             :                                                         }
     903             :                                                 }
     904          19 :                                                 add_assoc_long(return_value, n, v);
     905          19 :                                                 break;
     906             :                                         }
     907             : 
     908             : #if SIZEOF_ZEND_LONG > 4
     909             :                                         case 'q':
     910             :                                         case 'Q':
     911             :                                         case 'J':
     912             :                                         case 'P': {
     913          20 :                                                 int issigned = 0;
     914          20 :                                                 int *map = machine_endian_longlong_map;
     915          20 :                                                 zend_long v = 0;
     916             : 
     917          30 :                                                 if (type == 'q' || type == 'Q') {
     918          10 :                                                         issigned = input[inputpos + (machine_little_endian ? 7 : 0)] & 0x80;
     919          10 :                                                 } else if (type == 'J') {
     920           5 :                                                         issigned = input[inputpos] & 0x80;
     921           5 :                                                         map = big_endian_longlong_map;
     922           5 :                                                 } else if (type == 'P') {
     923           5 :                                                         issigned = input[inputpos + 7] & 0x80;
     924           5 :                                                         map = little_endian_longlong_map;
     925             :                                                 }
     926             : 
     927          20 :                                                 v = php_unpack(&input[inputpos], 8, issigned, map);
     928             : 
     929          20 :                                                 if (type == 'q') {
     930           5 :                                                         v = (zend_long) v;
     931             :                                                 } else {
     932          15 :                                                         v = (zend_ulong) v;
     933             :                                                 }
     934             : 
     935          20 :                                                 add_assoc_long(return_value, n, v);
     936          20 :                                                 break;
     937             :                                         }
     938             : #endif
     939             : 
     940             :                                         case 'f': {
     941             :                                                 float v;
     942             : 
     943           0 :                                                 memcpy(&v, &input[inputpos], sizeof(float));
     944           0 :                                                 add_assoc_double(return_value, n, (double)v);
     945           0 :                                                 break;
     946             :                                         }
     947             : 
     948             :                                         case 'd': {
     949             :                                                 double v;
     950             : 
     951          13 :                                                 memcpy(&v, &input[inputpos], sizeof(double));
     952          13 :                                                 add_assoc_double(return_value, n, v);
     953          13 :                                                 break;
     954             :                                         }
     955             : 
     956             :                                         case 'x':
     957             :                                                 /* Do nothing with input, just skip it */
     958           0 :                                                 break;
     959             : 
     960             :                                         case 'X':
     961          13 :                                                 if (inputpos < size) {
     962           0 :                                                         inputpos = -size;
     963           0 :                                                         i = arg - 1;            /* Break out of for loop */
     964             : 
     965           0 :                                                         if (arg >= 0) {
     966           0 :                                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: outside of string", type);
     967             :                                                         }
     968             :                                                 }
     969          13 :                                                 break;
     970             : 
     971             :                                         case '@':
     972           0 :                                                 if (arg <= inputlen) {
     973           0 :                                                         inputpos = arg;
     974             :                                                 } else {
     975           0 :                                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: outside of string", type);
     976             :                                                 }
     977             : 
     978           0 :                                                 i = arg - 1;    /* Done, break out of for loop */
     979             :                                                 break;
     980             :                                 }
     981             : 
     982        1063 :                                 inputpos += size;
     983        1063 :                                 if (inputpos < 0) {
     984         970 :                                         if (size != -1) { /* only print warning if not working with * */
     985           0 :                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: outside of string", type);
     986             :                                         }
     987         970 :                                         inputpos = 0;
     988             :                                 }
     989           3 :                         } else if (arg < 0) {
     990             :                                 /* Reached end of input for '*' repeater */
     991           1 :                                 break;
     992             :                         } else {
     993           2 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: not enough input, need %d, have %d", type, size, inputlen - inputpos);
     994             :                                 zval_dtor(return_value);
     995           2 :                                 RETURN_FALSE;
     996             :                         }
     997             :                 }
     998             : 
     999        1050 :                 if (formatlen > 0) {
    1000           7 :                         formatlen--;    /* Skip '/' separator, does no harm if inputlen == 0 */
    1001           7 :                         format++;
    1002             :                 }
    1003             :         }
    1004             : }
    1005             : /* }}} */
    1006             : 
    1007             : /* {{{ PHP_MINIT_FUNCTION
    1008             :  */
    1009       20622 : PHP_MINIT_FUNCTION(pack)
    1010             : {
    1011       20622 :         int machine_endian_check = 1;
    1012             :         int i;
    1013             : 
    1014       20622 :         machine_little_endian = ((char *)&machine_endian_check)[0];
    1015             : 
    1016       20622 :         if (machine_little_endian) {
    1017             :                 /* Where to get lo to hi bytes from */
    1018       20622 :                 byte_map[0] = 0;
    1019             : 
    1020      103110 :                 for (i = 0; i < (int)sizeof(int); i++) {
    1021       82488 :                         int_map[i] = i;
    1022             :                 }
    1023             : 
    1024       20622 :                 machine_endian_short_map[0] = 0;
    1025       20622 :                 machine_endian_short_map[1] = 1;
    1026       20622 :                 big_endian_short_map[0] = 1;
    1027       20622 :                 big_endian_short_map[1] = 0;
    1028       20622 :                 little_endian_short_map[0] = 0;
    1029       20622 :                 little_endian_short_map[1] = 1;
    1030             : 
    1031       20622 :                 machine_endian_long_map[0] = 0;
    1032       20622 :                 machine_endian_long_map[1] = 1;
    1033       20622 :                 machine_endian_long_map[2] = 2;
    1034       20622 :                 machine_endian_long_map[3] = 3;
    1035       20622 :                 big_endian_long_map[0] = 3;
    1036       20622 :                 big_endian_long_map[1] = 2;
    1037       20622 :                 big_endian_long_map[2] = 1;
    1038       20622 :                 big_endian_long_map[3] = 0;
    1039       20622 :                 little_endian_long_map[0] = 0;
    1040       20622 :                 little_endian_long_map[1] = 1;
    1041       20622 :                 little_endian_long_map[2] = 2;
    1042       20622 :                 little_endian_long_map[3] = 3;
    1043             : 
    1044             : #if SIZEOF_ZEND_LONG > 4
    1045       20622 :                 machine_endian_longlong_map[0] = 0;
    1046       20622 :                 machine_endian_longlong_map[1] = 1;
    1047       20622 :                 machine_endian_longlong_map[2] = 2;
    1048       20622 :                 machine_endian_longlong_map[3] = 3;
    1049       20622 :                 machine_endian_longlong_map[4] = 4;
    1050       20622 :                 machine_endian_longlong_map[5] = 5;
    1051       20622 :                 machine_endian_longlong_map[6] = 6;
    1052       20622 :                 machine_endian_longlong_map[7] = 7;
    1053       20622 :                 big_endian_longlong_map[0] = 7;
    1054       20622 :                 big_endian_longlong_map[1] = 6;
    1055       20622 :                 big_endian_longlong_map[2] = 5;
    1056       20622 :                 big_endian_longlong_map[3] = 4;
    1057       20622 :                 big_endian_longlong_map[4] = 3;
    1058       20622 :                 big_endian_longlong_map[5] = 2;
    1059       20622 :                 big_endian_longlong_map[6] = 1;
    1060       20622 :                 big_endian_longlong_map[7] = 0;
    1061       20622 :                 little_endian_longlong_map[0] = 0;
    1062       20622 :                 little_endian_longlong_map[1] = 1;
    1063       20622 :                 little_endian_longlong_map[2] = 2;
    1064       20622 :                 little_endian_longlong_map[3] = 3;
    1065       20622 :                 little_endian_longlong_map[4] = 4;
    1066       20622 :                 little_endian_longlong_map[5] = 5;
    1067       20622 :                 little_endian_longlong_map[6] = 6;
    1068       20622 :                 little_endian_longlong_map[7] = 7;
    1069             : #endif
    1070             :         }
    1071             :         else {
    1072             :                 zval val;
    1073           0 :                 int size = sizeof(Z_LVAL(val));
    1074           0 :                 Z_LVAL(val)=0; /*silence a warning*/
    1075             : 
    1076             :                 /* Where to get hi to lo bytes from */
    1077           0 :                 byte_map[0] = size - 1;
    1078             : 
    1079           0 :                 for (i = 0; i < (int)sizeof(int); i++) {
    1080           0 :                         int_map[i] = size - (sizeof(int) - i);
    1081             :                 }
    1082             : 
    1083           0 :                 machine_endian_short_map[0] = size - 2;
    1084           0 :                 machine_endian_short_map[1] = size - 1;
    1085           0 :                 big_endian_short_map[0] = size - 2;
    1086           0 :                 big_endian_short_map[1] = size - 1;
    1087           0 :                 little_endian_short_map[0] = size - 1;
    1088           0 :                 little_endian_short_map[1] = size - 2;
    1089             : 
    1090           0 :                 machine_endian_long_map[0] = size - 4;
    1091           0 :                 machine_endian_long_map[1] = size - 3;
    1092           0 :                 machine_endian_long_map[2] = size - 2;
    1093           0 :                 machine_endian_long_map[3] = size - 1;
    1094           0 :                 big_endian_long_map[0] = size - 4;
    1095           0 :                 big_endian_long_map[1] = size - 3;
    1096           0 :                 big_endian_long_map[2] = size - 2;
    1097           0 :                 big_endian_long_map[3] = size - 1;
    1098           0 :                 little_endian_long_map[0] = size - 1;
    1099           0 :                 little_endian_long_map[1] = size - 2;
    1100           0 :                 little_endian_long_map[2] = size - 3;
    1101           0 :                 little_endian_long_map[3] = size - 4;
    1102             : 
    1103             : #if SIZEOF_ZEND_LONG > 4
    1104           0 :                 machine_endian_longlong_map[0] = size - 8;
    1105           0 :                 machine_endian_longlong_map[1] = size - 7;
    1106           0 :                 machine_endian_longlong_map[2] = size - 6;
    1107           0 :                 machine_endian_longlong_map[3] = size - 5;
    1108           0 :                 machine_endian_longlong_map[4] = size - 4;
    1109           0 :                 machine_endian_longlong_map[5] = size - 3;
    1110           0 :                 machine_endian_longlong_map[6] = size - 2;
    1111           0 :                 machine_endian_longlong_map[7] = size - 1;
    1112           0 :                 big_endian_longlong_map[0] = size - 8;
    1113           0 :                 big_endian_longlong_map[1] = size - 7;
    1114           0 :                 big_endian_longlong_map[2] = size - 6;
    1115           0 :                 big_endian_longlong_map[3] = size - 5;
    1116           0 :                 big_endian_longlong_map[4] = size - 4;
    1117           0 :                 big_endian_longlong_map[5] = size - 3;
    1118           0 :                 big_endian_longlong_map[6] = size - 2;
    1119           0 :                 big_endian_longlong_map[7] = size - 1;
    1120           0 :                 little_endian_longlong_map[0] = size - 1;
    1121           0 :                 little_endian_longlong_map[1] = size - 2;
    1122           0 :                 little_endian_longlong_map[2] = size - 3;
    1123           0 :                 little_endian_longlong_map[3] = size - 4;
    1124           0 :                 little_endian_longlong_map[4] = size - 5;
    1125           0 :                 little_endian_longlong_map[5] = size - 6;
    1126           0 :                 little_endian_longlong_map[6] = size - 7;
    1127           0 :                 little_endian_longlong_map[7] = size - 8;
    1128             : #endif
    1129             :         }
    1130             : 
    1131       20622 :         return SUCCESS;
    1132             : }
    1133             : /* }}} */
    1134             : 
    1135             : /*
    1136             :  * Local variables:
    1137             :  * tab-width: 4
    1138             :  * c-basic-offset: 4
    1139             :  * End:
    1140             :  * vim600: noet sw=4 ts=4 fdm=marker
    1141             :  * vim<600: noet sw=4 ts=4
    1142             :  */

Generated by: LCOV version 1.10

Generated at Sat, 13 Dec 2014 06:16:23 +0000 (9 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.