source: trunk/mod_coverager/xc_coverager.c

Last change on this file was 1477, checked in by moo, 9 months ago

adds reflection info for APIs

  • Property svn:eol-style set to native
File size: 18.0 KB
RevLine 
[543]1#if 0
2#define XCACHE_DEBUG
3#endif
4
[1026]5#include "xc_coverager.h"
6
[1]7#include <stdio.h>
8#include "xcache.h"
9#include "ext/standard/flock_compat.h"
10#ifdef HAVE_SYS_FILE_H
11#   include <sys/file.h>
12#endif
[11]13#include <sys/types.h>
14#include <sys/stat.h>
15#include <fcntl.h>
16
[1026]17#include "xcache/xc_extension.h"
18#include "xcache/xc_ini.h"
19#include "xcache/xc_utils.h"
[1006]20#include "util/xc_stack.h"
21#include "util/xc_trace.h"
[1]22#include "xcache_globals.h"
[1006]23
[1026]24#include "ext/standard/info.h"
[1027]25#include "zend_compile.h"
[1026]26
[27]27typedef HashTable *coverager_t;
[1]28#define PCOV_HEADER_MAGIC 0x564f4350
29
[204]30static char *xc_coveragedump_dir = NULL;
[404]31static zend_compile_file_t *old_compile_file = NULL;
[1]32
33/* dumper */
34static void xc_destroy_coverage(void *pDest) /* {{{ */
35{
[27]36    coverager_t cov = *(coverager_t*) pDest;
[305]37    TRACE("destroy %p", cov);
[1]38    zend_hash_destroy(cov);
39    efree(cov);
40}
41/* }}} */
[1201]42static void xcache_mkdirs_ex(char *root, long rootlen, char *path, long pathlen TSRMLS_DC) /* {{{ */
[1]43{
44    char *fullpath;
45    struct stat st;
[485]46    ALLOCA_FLAG(use_heap)
[1]47
[305]48    TRACE("mkdirs %s %d %s %d", root, rootlen, path, pathlen);
[1151]49    fullpath = xc_do_alloca(rootlen + pathlen + 1, use_heap);
[1]50    memcpy(fullpath, root, rootlen);
51    memcpy(fullpath + rootlen, path, pathlen);
52    fullpath[rootlen + pathlen] = '\0';
53
54    if (stat(fullpath, &st) != 0) {
55        char *chr;
56
57        chr = strrchr(path, PHP_DIR_SEPARATOR);
58        if (chr && chr != path) {
59            *chr = '\0';
60            xcache_mkdirs_ex(root, rootlen, path, chr - path TSRMLS_CC);
61            *chr = PHP_DIR_SEPARATOR;
62        }
[305]63        TRACE("mkdir %s", fullpath);
[51]64#if PHP_MAJOR_VERSION > 5
[1]65        php_stream_mkdir(fullpath, 0700, REPORT_ERRORS, NULL);
[16]66#else
67        mkdir(fullpath, 0700);
68#endif
[1]69    }
[1151]70    xc_free_alloca(fullpath, use_heap);
[1]71}
72/* }}} */
[27]73static void xc_coverager_save_cov(char *srcfile, char *outfilename, coverager_t cov TSRMLS_DC) /* {{{ */
[1]74{
75    long *buf = NULL, *p;
76    long covlines, *phits;
77    int fd = -1;
[1201]78    size_t size;
[1]79    int newfile;
80    struct stat srcstat, outstat;
81    HashPosition pos;
82    char *contents = NULL;
83    long len;
84
85    if (stat(srcfile, &srcstat) != 0) {
86        return;
87    }
88
89    newfile = 0;
90    if (stat(outfilename, &outstat) != 0) {
91        newfile = 1;
92    }
93    else {
94        if (srcstat.st_mtime > outstat.st_mtime) {
95            newfile = 1;
96        }
97    }
98
99    fd = open(outfilename, O_RDWR | O_CREAT, 0600);
100    if (fd < 0) {
101        char *chr;
102        chr = strrchr(srcfile, PHP_DIR_SEPARATOR);
103        if (chr) {
104            *chr = '\0';
105            xcache_mkdirs_ex(xc_coveragedump_dir, strlen(xc_coveragedump_dir), srcfile, chr - srcfile TSRMLS_CC);
106            *chr = PHP_DIR_SEPARATOR;
107        }
108        fd = open(outfilename, O_RDWR | O_CREAT, 0600);
109        if (fd < 0) {
110            goto bailout;
111        }
112    }
113    if (flock(fd, LOCK_EX) != SUCCESS) {
114        goto bailout;
115    }
116
117    if (newfile) {
[305]118        TRACE("%s", "new file");
[1]119    }
120    else if (outstat.st_size) {
121        len = outstat.st_size;
122        contents = emalloc(len);
123        if (read(fd, (void *) contents, len) != len) {
124            goto bailout;
125        }
[305]126        TRACE("oldsize %d", (int) len);
[1]127        do {
128            p = (long *) contents;
129            len -= sizeof(long);
130            if (len < 0) {
131                break;
132            }
133            if (*p++ != PCOV_HEADER_MAGIC) {
[305]134                TRACE("wrong magic in file %s", outfilename);
[1]135                break;
136            }
137
138            p += 2; /* skip covliens */
139            len -= sizeof(long) * 2;
140            if (len < 0) {
141                break;
142            }
143
[1008]144            for (; len >= (int) sizeof(long) * 2; len -= sizeof(long) * 2, p += 2) {
[1]145                if (zend_hash_index_find(cov, p[0], (void**)&phits) == SUCCESS) {
[212]146                    if (p[1] == -1) {
[208]147                        /* OPTIMIZE: already marked */
[1]148                        continue;
149                    }
[212]150                    if (*phits != -1) {
151                        p[1] += *phits;
152                    }
[1]153                }
154                zend_hash_index_update(cov, p[0], &p[1], sizeof(p[1]), NULL);
155            }
156        } while (0);
157        efree(contents);
158        contents = NULL;
159    }
160
161
162    /* serialize */
163    size = (zend_hash_num_elements(cov) + 1) * sizeof(long) * 2 + sizeof(long);
164    p = buf = emalloc(size);
165    *p++ = PCOV_HEADER_MAGIC;
166    p += 2; /* for covlines */
167    covlines = 0;
168
169    zend_hash_internal_pointer_reset_ex(cov, &pos);
170    while (zend_hash_get_current_data_ex(cov, (void**)&phits, &pos) == SUCCESS) {
171        *p++ = pos->h;
[208]172        *p++ = *phits;
173        if (*phits > 0) {
[1]174            covlines ++;
175        }
176        zend_hash_move_forward_ex(cov, &pos);
177    }
178    p = buf + 1;
179    p[0] = 0;
180    p[1] = covlines;
181
[767]182    if (ftruncate(fd, 0) != 0) {
183        goto bailout;
184    }
[1]185    lseek(fd, 0, SEEK_SET);
[1207]186    if (write(fd, (char *) buf, size) != (ssize_t) size) {
[767]187        goto bailout;
188    }
[1]189
190bailout:
191    if (contents) efree(contents);
192    if (fd >= 0) close(fd);
193    if (buf) efree(buf);
194}
195/* }}} */
[204]196
197static void xc_coverager_initenv(TSRMLS_D) /* {{{ */
[1]198{
[204]199    if (!XG(coverages)) {
[1]200        XG(coverages) = emalloc(sizeof(HashTable));
201        zend_hash_init(XG(coverages), 0, NULL, xc_destroy_coverage, 0);
202    }
203}
204/* }}} */
[204]205static void xc_coverager_clean(TSRMLS_D) /* {{{ */
[1]206{
[204]207    if (XG(coverages)) {
[208]208        HashPosition pos;
209        coverager_t *pcov;
210
211        zend_hash_internal_pointer_reset_ex(XG(coverages), &pos);
212        while (zend_hash_get_current_data_ex(XG(coverages), (void **) &pcov, &pos) == SUCCESS) {
213            long *phits;
214            coverager_t cov;
215            HashPosition pos2;
216
217            cov = *pcov;
218
219            zend_hash_internal_pointer_reset_ex(cov, &pos2);
220            while (zend_hash_get_current_data_ex(cov, (void**)&phits, &pos2) == SUCCESS) {
221                long hits = *phits;
222
[212]223                if (hits != -1) {
224                    hits = -1;
[208]225                    zend_hash_index_update(cov, pos2->h, &hits, sizeof(hits), NULL);
226                }
227                zend_hash_move_forward_ex(cov, &pos2);
228            }
229
230            zend_hash_move_forward_ex(XG(coverages), &pos);
231        }
232    }
233}
234/* }}} */
235static void xc_coverager_cleanup(TSRMLS_D) /* {{{ */
236{
237    if (XG(coverages)) {
[204]238        zend_hash_destroy(XG(coverages));
239        efree(XG(coverages));
240        XG(coverages) = NULL;
241    }
242}
243/* }}} */
244
[1118]245static void xc_coverager_start(TSRMLS_D) /* {{{ */
[204]246{
[1118]247    XG(coverager_started) = 1;
[204]248}
249/* }}} */
[1118]250static void xc_coverager_stop(TSRMLS_D) /* {{{ */
[204]251{
[1118]252    XG(coverager_started) = 0;
[204]253}
254/* }}} */
255
[1026]256static PHP_RINIT_FUNCTION(xcache_coverager) /* {{{ */
[204]257{
[206]258    if (XG(coverager)) {
[1117]259        if (XG(coverager_autostart)) {
[1118]260            xc_coverager_start(TSRMLS_C);
[1117]261        }
[548]262#ifdef ZEND_COMPILE_EXTENDED_INFO
263        CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
264#else
[204]265        CG(extended_info) = 1;
[548]266#endif
[204]267    }
268    else {
[1118]269        XG(coverager_started) = 0;
[204]270    }
[1026]271    return SUCCESS;
[204]272}
273/* }}} */
274static void xc_coverager_autodump(TSRMLS_D) /* {{{ */
275{
[27]276    coverager_t *pcov;
[1]277    zstr s;
278    char *outfilename;
[1201]279    size_t dumpdir_len, outfilelen, alloc_len = 0;
[90]280    uint size;
[204]281    HashPosition pos;
[1]282
[204]283    if (XG(coverages) && xc_coveragedump_dir) { 
[1]284        dumpdir_len = strlen(xc_coveragedump_dir);
285        alloc_len = dumpdir_len + 1 + 128;
286        outfilename = emalloc(alloc_len);
287        strcpy(outfilename, xc_coveragedump_dir);
288
[204]289        zend_hash_internal_pointer_reset_ex(XG(coverages), &pos);
290        while (zend_hash_get_current_data_ex(XG(coverages), (void **) &pcov, &pos) == SUCCESS) {
291            zend_hash_get_current_key_ex(XG(coverages), &s, &size, NULL, 0, &pos);
[1]292            outfilelen = dumpdir_len + size + 5;
293            if (alloc_len < outfilelen) {
294                alloc_len = outfilelen + 128;
295                outfilename = erealloc(outfilename, alloc_len);
296            }
297            strcpy(outfilename + dumpdir_len, ZSTR_S(s));
298            strcpy(outfilename + dumpdir_len + size - 1, ".pcov");
299
[305]300            TRACE("outfilename %s", outfilename);
[27]301            xc_coverager_save_cov(ZSTR_S(s), outfilename, *pcov TSRMLS_CC);
[204]302            zend_hash_move_forward_ex(XG(coverages), &pos);
[1]303        }
[176]304        efree(outfilename);
[1]305    }
[204]306}
307/* }}} */
308static void xc_coverager_dump(zval *return_value TSRMLS_DC) /* {{{ */
309{
310    coverager_t *pcov;
311    HashPosition pos;
[1]312
[204]313    if (XG(coverages)) {
314        array_init(return_value);
315
316        zend_hash_internal_pointer_reset_ex(XG(coverages), &pos);
317        while (zend_hash_get_current_data_ex(XG(coverages), (void **) &pcov, &pos) == SUCCESS) {
318            zval *lines;
319            long *phits;
320            coverager_t cov;
321            HashPosition pos2;
322            zstr filename;
323            uint size;
324
325            cov = *pcov;
326            zend_hash_get_current_key_ex(XG(coverages), &filename, &size, NULL, 0, &pos);
327
328            MAKE_STD_ZVAL(lines);
329            array_init(lines);
330            zend_hash_internal_pointer_reset_ex(cov, &pos2);
331            while (zend_hash_get_current_data_ex(cov, (void**)&phits, &pos2) == SUCCESS) {
332                long hits = *phits;
333                add_index_long(lines, pos2->h, hits >= 0 ? hits : 0);
334                zend_hash_move_forward_ex(cov, &pos2);
335            }
[1201]336            add_assoc_zval_ex(return_value, ZSTR_S(filename), (uint) strlen(ZSTR_S(filename)) + 1, lines);
[204]337
338            zend_hash_move_forward_ex(XG(coverages), &pos);
339        }
340    }
341    else {
342        RETVAL_NULL();
343    }
[1]344}
345/* }}} */
[1026]346static PHP_RSHUTDOWN_FUNCTION(xcache_coverager) /* {{{ */
[204]347{
[206]348    if (XG(coverager)) {
[204]349        xc_coverager_autodump(TSRMLS_C);
[208]350        xc_coverager_cleanup(TSRMLS_C);
[204]351    }
[1026]352    return SUCCESS;
[204]353}
354/* }}} */
[1]355
356/* helper func to store hits into coverages */
[872]357static coverager_t xc_coverager_get(const char *filename TSRMLS_DC) /* {{{ */
[1]358{
[1201]359    uint len = (uint) strlen(filename) + 1;
[27]360    coverager_t cov, *pcov;
[1]361
[872]362    if (zend_u_hash_find(XG(coverages), IS_STRING, filename, len, (void **) &pcov) == SUCCESS) {
[305]363        TRACE("got coverage %s %p", filename, *pcov);
[1]364        return *pcov;
365    }
366    else {
367        cov = emalloc(sizeof(HashTable));
368        zend_hash_init(cov, 0, NULL, NULL, 0);
[872]369        zend_u_hash_add(XG(coverages), IS_STRING, filename, len, (void **) &cov, sizeof(cov), NULL);
[305]370        TRACE("new coverage %s %p", filename, cov);
[1]371        return cov;
372    }
373}
374/* }}} */
[27]375static void xc_coverager_add_hits(HashTable *cov, long line, long hits TSRMLS_DC) /* {{{ */
[1]376{
377    long *poldhits;
378
379    if (line == 0) {
380        return;
381    }
382    if (zend_hash_index_find(cov, line, (void**)&poldhits) == SUCCESS) {
[212]383        if (hits == -1) {
384            /* OPTIMIZE: -1 == init-ing, but it's already initized */
[1]385            return;
386        }
[212]387        if (*poldhits != -1) {
388            hits += *poldhits;
389        }
[1]390    }
391    zend_hash_index_update(cov, line, &hits, sizeof(hits), NULL);
392}
393/* }}} */
394
[27]395static int xc_coverager_get_op_array_size_no_tail(zend_op_array *op_array) /* {{{ */
[1]396{
[716]397    zend_uint last = op_array->last;
[228]398    do {
399next_op:
[716]400        if (last == 0) {
[228]401            break;
402        }
[716]403        switch (op_array->opcodes[last - 1].opcode) {
[228]404#ifdef ZEND_HANDLE_EXCEPTION
405            case ZEND_HANDLE_EXCEPTION:
[1]406#endif
[228]407            case ZEND_RETURN:
408            case ZEND_EXT_STMT:
[716]409                --last;
[228]410                goto next_op;
411        }
412    } while (0);
[716]413    return last;
[1]414}
415/* }}} */
416
417/* prefill */
[27]418static int xc_coverager_init_op_array(zend_op_array *op_array TSRMLS_DC) /* {{{ */
[1]419{
420    zend_uint size;
[27]421    coverager_t cov;
[11]422    zend_uint i;
[1]423
424    if (op_array->type != ZEND_USER_FUNCTION) {
425        return 0;
426    }
427
[27]428    size = xc_coverager_get_op_array_size_no_tail(op_array);
429    cov = xc_coverager_get(op_array->filename TSRMLS_CC);
[11]430    for (i = 0; i < size; i ++) {
[1]431        switch (op_array->opcodes[i].opcode) {
432            case ZEND_EXT_STMT:
433#if 0
434            case ZEND_EXT_FCALL_BEGIN:
435            case ZEND_EXT_FCALL_END:
436#endif
[212]437                xc_coverager_add_hits(cov, op_array->opcodes[i].lineno, -1 TSRMLS_CC);
[1]438                break;
439        }
440    }
441    return 0;
442}
443/* }}} */
[27]444static void xc_coverager_init_compile_result(zend_op_array *op_array TSRMLS_DC) /* {{{ */
[1]445{
446    xc_compile_result_t cr;
447
448    xc_compile_result_init_cur(&cr, op_array TSRMLS_CC);
[27]449    xc_apply_op_array(&cr, (apply_func_t) xc_coverager_init_op_array TSRMLS_CC);
[1]450    xc_compile_result_free(&cr);
451}
452/* }}} */
453static zend_op_array *xc_compile_file_for_coverage(zend_file_handle *h, int type TSRMLS_DC) /* {{{ */
454{
455    zend_op_array *op_array;
456
[402]457    op_array = old_compile_file(h, type TSRMLS_CC);
[204]458    if (op_array) {
[206]459        if (XG(coverager)) {
[204]460            xc_coverager_initenv(TSRMLS_C);
461            xc_coverager_init_compile_result(op_array TSRMLS_CC);
462        }
[1]463    }
464    return op_array;
465}
466/* }}} */
467
468/* hits */
[1026]469static void xc_coverager_handle_ext_stmt(zend_op_array *op_array, zend_uchar op) /* {{{ */
[1]470{
[11]471    TSRMLS_FETCH();
472
[1118]473    if (XG(coverages) && XG(coverager_started)) {
[27]474        int size = xc_coverager_get_op_array_size_no_tail(op_array);
[1201]475        int oplineno = (int) ((*EG(opline_ptr)) - op_array->opcodes);
[1]476        if (oplineno < size) {
[27]477            xc_coverager_add_hits(xc_coverager_get(op_array->filename TSRMLS_CC), (*EG(opline_ptr))->lineno, 1 TSRMLS_CC);
[1]478        }
479    }
480}
481/* }}} */
482
483/* user api */
[204]484/* {{{ proto array xcache_coverager_decode(string data)
485 * decode specified data which is saved by auto dumper to array
486 */
[1477]487#ifdef ZEND_BEGIN_ARG_INFO_EX
488ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_coverager_decode, 0, 0, 1)
489    ZEND_ARG_INFO(0, data)
490ZEND_END_ARG_INFO()
491#else
492static unsigned char arginfo_xcache_coverager_decode[] = { 1, BYREF_NONE };
493#endif
494
[204]495PHP_FUNCTION(xcache_coverager_decode)
[1]496{
497    char *str;
498    int len;
499    long *p;
500
501    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len) == FAILURE) {
502        return;
503    }
504
505    array_init(return_value);
506
507    p = (long*) str;
[1201]508    len -= (int) sizeof(long);
[1]509    if (len < 0) {
510        return;
511    }
512    if (*p++ != PCOV_HEADER_MAGIC) {
[305]513        TRACE("%s", "wrong magic in xcache_coverager_decode");
[1]514        return;
515    }
516
[1201]517    for (; len >= (int) sizeof(long) * 2; len -= (int) sizeof(long) * 2, p += 2) {
[462]518        add_index_long(return_value, p[0], p[1] < 0 ? 0 : p[1]);
[1]519    }
520}
521/* }}} */
[204]522/* {{{ proto void xcache_coverager_start([bool clean = true])
523 * starts coverager data collecting
524 */
[1477]525#ifdef ZEND_BEGIN_ARG_INFO_EX
526ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_coverager_start, 0, 0, 0)
527    ZEND_ARG_INFO(0, clean)
528ZEND_END_ARG_INFO()
529#else
530static unsigned char arginfo_xcache_coverager_start[] = { 1, BYREF_NONE };
531#endif
532
[204]533PHP_FUNCTION(xcache_coverager_start)
534{
535    zend_bool clean = 1;
[1]536
[204]537    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &clean) == FAILURE) {
538        return;
539    }
540
541    if (clean) {
542        xc_coverager_clean(TSRMLS_C);
543    }
544
[206]545    if (XG(coverager)) {
[1118]546        xc_coverager_start(TSRMLS_C);
[204]547    }
548    else {
[206]549        php_error(E_WARNING, "You can only start coverager after you set 'xcache.coverager' to 'On' in ini");
[204]550    }
551}
552/* }}} */
553/* {{{ proto void xcache_coverager_stop([bool clean = false])
554 * stop coverager data collecting
555 */
[1477]556#ifdef ZEND_BEGIN_ARG_INFO_EX
557ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_coverager_stop, 0, 0, 0)
558    ZEND_ARG_INFO(0, clean)
559ZEND_END_ARG_INFO()
560#else
561static unsigned char arginfo_xcache_coverager_stop[] = { 1, BYREF_NONE };
562#endif
563
[204]564PHP_FUNCTION(xcache_coverager_stop)
565{
566    zend_bool clean = 0;
567
568    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &clean) == FAILURE) {
569        return;
570    }
571
[1118]572    xc_coverager_stop(TSRMLS_C);
[204]573    if (clean) {
574        xc_coverager_clean(TSRMLS_C);
575    }
576}
577/* }}} */
578/* {{{ proto array xcache_coverager_get([bool clean = false])
579 * get coverager data collected
580 */
[1477]581#ifdef ZEND_BEGIN_ARG_INFO_EX
582ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_coverager_get, 0, 0, 0)
583    ZEND_ARG_INFO(0, clean)
584ZEND_END_ARG_INFO()
585#else
586static unsigned char arginfo_xcache_coverager_get[] = { 1, BYREF_NONE };
587#endif
[204]588PHP_FUNCTION(xcache_coverager_get)
589{
590    zend_bool clean = 0;
591    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &clean) == FAILURE) {
592        return;
593    }
594
595    xc_coverager_dump(return_value TSRMLS_CC);
596    if (clean) {
597        xc_coverager_clean(TSRMLS_C);
598    }
599}
600/* }}} */
[1026]601static zend_function_entry xcache_coverager_functions[] = /* {{{ */
602{
[1477]603    PHP_FE(xcache_coverager_decode,  arginfo_xcache_coverager_decode)
604    PHP_FE(xcache_coverager_start,   arginfo_xcache_coverager_start)
605    PHP_FE(xcache_coverager_stop,    arginfo_xcache_coverager_stop)
606    PHP_FE(xcache_coverager_get,     arginfo_xcache_coverager_get)
[1026]607    PHP_FE_END
608};
609/* }}} */
610
[1060]611static int xc_coverager_zend_startup(zend_extension *extension) /* {{{ */
[1026]612{
[1060]613    old_compile_file = zend_compile_file;
614    zend_compile_file = xc_compile_file_for_coverage;
615
[1026]616    return SUCCESS;
617}
618/* }}} */
[1060]619static void xc_coverager_zend_shutdown(zend_extension *extension) /* {{{ */
[1026]620{
621    /* empty */
622}
623/* }}} */
624static void xc_statement_handler(zend_op_array *op_array) /* {{{ */
625{
626    xc_coverager_handle_ext_stmt(op_array, ZEND_EXT_STMT);
627}
628/* }}} */
629static void xc_fcall_begin_handler(zend_op_array *op_array) /* {{{ */
630{
631#if 0
632    xc_coverager_handle_ext_stmt(op_array, ZEND_EXT_FCALL_BEGIN);
633#endif
634}
635/* }}} */
636static void xc_fcall_end_handler(zend_op_array *op_array) /* {{{ */
637{
638#if 0
639    xc_coverager_handle_ext_stmt(op_array, ZEND_EXT_FCALL_END);
640#endif
641}
642/* }}} */
643/* {{{ zend extension definition structure */
644static zend_extension xc_coverager_zend_extension_entry = {
645    XCACHE_NAME " Coverager",
646    XCACHE_VERSION,
647    XCACHE_AUTHOR,
648    XCACHE_URL,
649    XCACHE_COPYRIGHT,
[1060]650    xc_coverager_zend_startup,
651    xc_coverager_zend_shutdown,
[1026]652    NULL,           /* activate_func_t */
653    NULL,           /* deactivate_func_t */
654    NULL,           /* message_handler_func_t */
655    NULL,           /* statement_handler_func_t */
656    xc_statement_handler,
657    xc_fcall_begin_handler,
658    xc_fcall_end_handler,
659    NULL,           /* op_array_ctor_func_t */
660    NULL,           /* op_array_dtor_func_t */
661    STANDARD_ZEND_EXTENSION_PROPERTIES
662};
663/* }}} */
664/* {{{ PHP_INI */
665PHP_INI_BEGIN()
[1117]666    STD_PHP_INI_BOOLEAN("xcache.coverager",              "0", PHP_INI_SYSTEM|PHP_INI_PERDIR, OnUpdateBool, coverager,           zend_xcache_globals, xcache_globals)
667    STD_PHP_INI_BOOLEAN("xcache.coverager_autostart",    "1", PHP_INI_SYSTEM|PHP_INI_PERDIR, OnUpdateBool, coverager_autostart, zend_xcache_globals, xcache_globals)
[1026]668    PHP_INI_ENTRY1     ("xcache.coveragedump_directory",  "", PHP_INI_SYSTEM, xcache_OnUpdateDummy, NULL)
669PHP_INI_END()
670/* }}} */
671static PHP_MINFO_FUNCTION(xcache_coverager) /* {{{ */
672{
673    char *covdumpdir;
674
675    php_info_print_table_start();
[1043]676    php_info_print_table_row(2, "XCache Coverager Module", "enabled");
[1026]677    if (cfg_get_string("xcache.coveragedump_directory", &covdumpdir) != SUCCESS || !covdumpdir[0]) {
678        covdumpdir = NULL;
679    }
[1117]680    php_info_print_table_row(2, "Coverage Started", XG(coverager_started) && covdumpdir ? "On" : "Off");
[1026]681    php_info_print_table_end();
682
683    DISPLAY_INI_ENTRIES();
684}
685/* }}} */
686static PHP_MINIT_FUNCTION(xcache_coverager) /* {{{ */
687{
688    REGISTER_INI_ENTRIES();
689
690    if (cfg_get_string("xcache.coveragedump_directory", &xc_coveragedump_dir) == SUCCESS && xc_coveragedump_dir) {
[1201]691        size_t len;
[1026]692        xc_coveragedump_dir = pestrdup(xc_coveragedump_dir, 1);
693        len = strlen(xc_coveragedump_dir);
694        if (len) {
695            if (xc_coveragedump_dir[len - 1] == '/') {
696                xc_coveragedump_dir[len - 1] = '\0';
697            }
698        }
699        if (!strlen(xc_coveragedump_dir)) {
700            pefree(xc_coveragedump_dir, 1);
701            xc_coveragedump_dir = NULL;
702        }
703    }
704
[1047]705    return xcache_zend_extension_add(&xc_coverager_zend_extension_entry, 0);
[1026]706}
707/* }}} */
708static PHP_MSHUTDOWN_FUNCTION(xcache_coverager) /* {{{ */
709{
[1031]710    if (old_compile_file && zend_compile_file == xc_compile_file_for_coverage) {
[1026]711        zend_compile_file = old_compile_file;
[1034]712        old_compile_file = NULL;
[1026]713    }
714    if (xc_coveragedump_dir) {
715        pefree(xc_coveragedump_dir, 1);
716        xc_coveragedump_dir = NULL;
717    }
718    UNREGISTER_INI_ENTRIES();
[1045]719    return xcache_zend_extension_remove(&xc_coverager_zend_extension_entry);
[1026]720}
721/* }}} */
722
723static zend_module_entry xcache_coverager_module_entry = { /* {{{ */
724    STANDARD_MODULE_HEADER,
[1043]725    XCACHE_NAME " Coverager",
[1026]726    xcache_coverager_functions,
727    PHP_MINIT(xcache_coverager),
728    PHP_MSHUTDOWN(xcache_coverager),
729    PHP_RINIT(xcache_coverager),
730    PHP_RSHUTDOWN(xcache_coverager),
731    PHP_MINFO(xcache_coverager),
732    XCACHE_VERSION,
733#ifdef PHP_GINIT
734    NO_MODULE_GLOBALS,
735#endif
[1321]736#ifdef ZEND_ENGINE_2
[1026]737    NULL,
[1321]738#else
739    NULL,
740    NULL,
741#endif
[1026]742    STANDARD_MODULE_PROPERTIES_EX
743};
744/* }}} */
745int xc_coverager_startup_module() /* {{{ */
746{
747    return zend_startup_module(&xcache_coverager_module_entry);
748}
749/* }}} */
Note: See TracBrowser for help on using the repository browser.