source: trunk/mod_coverager/xc_coverager.c @ 1026

Last change on this file since 1026 was 1026, checked in by moo, 2 years ago

refactor: split extension init to sub module. TODO: compatibility regression

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