Changeset 11

Timestamp:

05/24/2006 09:52:48 AM (7 years ago)

Author:

moo

Message:

make it build on windows vc compiler

Location:

trunk

Files:

• Makefile.frag (modified) (2 diffs)
• config.m4 (modified) (6 diffs)
• config.w32 (added)
• coverage.c (modified) (4 diffs)
• lock.c (modified) (7 diffs)
• mmap.c (modified) (10 diffs)
• myshm.h (modified) (1 diff)
• processor/main.m4 (modified) (1 diff)
• processor/processor.m4 (modified) (6 diffs)
• processor/string.m4 (modified) (1 diff)
• processor/struct.m4 (modified) (3 diffs)
• stack.c (modified) (1 diff)
• utils.c (modified) (2 diffs)
• xcache.c (modified) (25 diffs)
• xcache.h (modified) (2 diffs)

trunk/Makefile.frag

@@ -8 +8 @@
 
 $(XCACHE_INCLUDES_I): $(XCACHE_INCLUDES_SRC) $(srcdir)/xcache.h
-    $(CC) -I. -I$(srcdir) $(COMMON_FLAGS) $(CFLAGS_CLEAN) $(EXTRA_CFLAGS)  -E $(XCACHE_INCLUDES_SRC) -o $(XCACHE_INCLUDES_I)
+    $(CC) -I. -I$(srcdir) $(COMMON_FLAGS) $(CFLAGS_CLEAN) $(EXTRA_CFLAGS) -E $(XCACHE_INCLUDES_SRC) -o $(XCACHE_INCLUDES_I)
 
 $(XCACHE_STRUCT_OUT): $(XCACHE_INCLUDES_I) $(srcdir)/mkstructinfo.awk
@@ -14 +14 @@
 
 $(XCACHE_PROC_OUT): $(XCACHE_PROC_SRC) $(XCACHE_STRUCT_OUT) $(XCACHE_PROC_SOURCES)
-    m4 -D srcdir="$(srcdir)/" -D builddir="$(builddir)" $(XCACHE_ENABLE_TEST) -E $(XCACHE_PROC_SRC) > $(XCACHE_PROC_OUT).tmp && mv -f $(XCACHE_PROC_OUT).tmp $(XCACHE_PROC_OUT)
+    $(M4) -D srcdir="$(srcdir)" -D builddir="$(builddir)" $(XCACHE_ENABLE_TEST) -E $(XCACHE_PROC_SRC) > $(XCACHE_PROC_OUT).tmp
+    mv -f $(XCACHE_PROC_OUT).tmp $(XCACHE_PROC_OUT)
 
 $(XCACHE_PROC_H): $(XCACHE_PROC_OUT)
-    grep -F 'export: ' $(XCACHE_PROC_OUT) | sed -r 's/.*export:(.*):export.*/\1/g' | $(XCACHE_INDENT) > $(XCACHE_PROC_H).tmp && mv -f $(XCACHE_PROC_H).tmp $(XCACHE_PROC_H)
+    $(GREP) -F 'export: ' $(XCACHE_PROC_OUT) | $(SED) -r 's/.*export:(.*):export.*/\1/g' | $(XCACHE_INDENT) > $(XCACHE_PROC_H).tmp
+    mv -f $(XCACHE_PROC_H).tmp $(XCACHE_PROC_H)
 
 $(XCACHE_PROC_C): $(XCACHE_PROC_OUT) $(XCACHE_PROC_H)
-    cat $(XCACHE_PROC_OUT) | $(XCACHE_INDENT) > $(XCACHE_PROC_C).tmp && mv -f $(XCACHE_PROC_C).tmp $(XCACHE_PROC_C)
+    $(XCACHE_INDENT) < $(XCACHE_PROC_OUT) > $(XCACHE_PROC_C).tmp
+    mv -f $(XCACHE_PROC_C).tmp $(XCACHE_PROC_C)
 
 $(builddir)/processor.lo: $(XCACHE_PROC_C) $(XCACHE_PROC_H) $(srcdir)/processor.c

trunk/config.m4

@@ -1 @@
-dnl
-dnl $Id:$
 dnl vim:ts=2:sw=2:expandtab
 
 AC_DEFUN([XCACHE_OPTION], [
-  PHP_ARG_ENABLE(xcache-$1, for XCACHE $1,
-  [  --enable-xcache-$2    XCACHE: $4], no, no)
-  if test "$PHP_$3" = "yes"; then
+  PHP_ARG_ENABLE(xcache-$1, for XCache $1,
+  [  --enable-xcache-$2    XCache: $4], no, no)
+  if test "$PHP_$3" != "no"; then
     xcache_sources="$xcache_sources $1.c"
     HAVE_$3=1
-    AC_DEFINE([HAVE_$3], 1, [Define for XCACHE: $4])
+    AC_DEFINE([HAVE_$3], 1, [Define for XCache: $4])
   else
     HAVE_$3=
@@ -15 +13 @@
 ])dnl
 
-PHP_ARG_ENABLE(xcache, for XCACHE support,
-[  --enable-xcache         Include XCACHE support.])
+PHP_ARG_ENABLE(xcache, for XCache support,
+[  --enable-xcache         Include XCache support.])
 
 if test "$PHP_XCACHE" != "no"; then
@@ -39 +37 @@
   PHP_ADD_MAKEFILE_FRAGMENT()
 
-  PHP_ARG_ENABLE(xcache-test, for XCACHE self test,
-  [  --enable-xcache-test            XCACHE: Enable self test - FOR DEVELOPERS ONLY!!], no, no)
-  if test "$PHP_XCACHE_TEST" = "yes"; then
+  PHP_ARG_ENABLE(xcache-test, for XCache self test,
+  [  --enable-xcache-test            XCache: Enable self test - FOR DEVELOPERS ONLY!!], no, no)
+  if test "$PHP_XCACHE_TEST" != "no"; then
     XCACHE_ENABLE_TEST=-DXCACHE_ENABLE_TEST
-    AC_DEFINE([HAVE_XCACHE_TEST], 1, [Define to enable XCACHE self test])
+    AC_DEFINE([HAVE_XCACHE_TEST], 1, [Define to enable XCache self test])
   else
     XCACHE_ENABLE_TEST=
@@ -49 +47 @@
   PHP_SUBST([XCACHE_ENABLE_TEST])
 
-  AC_PATH_PROGS(INDENT, [indent cat])
+  AC_PATH_PROGS([AWK], [gawk awk])
+  AC_PATH_PROGS([M4], [m4])
+  AC_PATH_PROGS([GREP], [grep])
+  AC_PATH_PROGS([SED], [sed])
+
+  AC_PATH_PROGS([INDENT], [indent cat])
   case $INDENT in
   */indent[)]
@@ -64 +67 @@
   PHP_SUBST([XCACHE_PROC_SOURCES])
 
-  AC_MSG_CHECKING(if you have opcode_spec_def.h for xcache)
+  AC_MSG_CHECKING(if you have opcode_spec_def.h for XCache)
   if test -e "$ac_srcdir/opcode_spec_def.h" ; then
-    AC_DEFINE([HAVE_XCACHE_OPCODE_SPEC_DEF], 1, [Define if you have opcode_spec_def.h for xcache])
+    AC_DEFINE([HAVE_XCACHE_OPCODE_SPEC_DEF], 1, [Define if you have opcode_spec_def.h for XCache])
     AC_MSG_RESULT(yes)
   else
@@ -74 +77 @@
       AC_MSG_ERROR([cannot build with $1, $ac_srcdir/opcode_spec_def.h required])
     ])
-    if test "$HAVE_XCACHE_DISASSEMBLER" = "1" ; then
+    if test "$PHP_XCACHE_DISASSEMBLER" != "no" ; then
       ERROR(disassembler)
     fi

trunk/coverage.c

@@ -5 +5 @@
 #   include <sys/file.h>
 #endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
 #include "stack.h"
 #include "xcache_globals.h"
@@ -305 +309 @@
     zend_uint size;
     coverage_t cov;
-    int i;
+    zend_uint i;
 
     if (op_array->type != ZEND_USER_FUNCTION) {
@@ -312 +316 @@
 
     size = xc_coverage_get_op_array_size_no_tail(op_array);
-    cov = xc_coverage_get(op_array->filename);
-    for (i = 0; i < size; i++) {
+    cov = xc_coverage_get(op_array->filename TSRMLS_CC);
+    for (i = 0; i < size; i ++) {
         switch (op_array->opcodes[i].opcode) {
             case ZEND_EXT_STMT:
@@ -351 +355 @@
 void xc_coverage_handle_ext_stmt(zend_op_array *op_array, zend_uchar op) /* {{{ */
 {
+    TSRMLS_FETCH();
+
     if (XG(coveragedumper) && XG(coverages)) {
-        TSRMLS_FETCH();
         int size = xc_coverage_get_op_array_size_no_tail(op_array);
         int oplineno = (*EG(opline_ptr)) - op_array->opcodes;
         if (oplineno < size) {
-            xc_coverage_add_hits(xc_coverage_get(op_array->filename), (*EG(opline_ptr))->lineno, 1 TSRMLS_CC);
+            xc_coverage_add_hits(xc_coverage_get(op_array->filename TSRMLS_CC), (*EG(opline_ptr))->lineno, 1 TSRMLS_CC);
         }
     }

trunk/lock.c

@@ -6 +6 @@
 #ifndef ZEND_WIN32
 typedef int HANDLE;
+#   define CloseHandle(h) close(h)
 #endif
 #include "lock.h"
@@ -18 +19 @@
 #   include <fcntl.h>
 #   include <errno.h>
+#   define LCK_WR F_WRLCK
+#   define LCK_RD F_RDLCK
+#   define LCK_UN F_UNLCK
+#   define LCK_NB 0
 static inline int dolock(xc_lock_t *lck, int type) /* {{{ */
 { 
@@ -35 +40 @@
 }
 /* }}} */
-#define LCK_WR F_WRLCK
-#define LCK_RD F_RDLCK
-#define LCK_UN F_UNLCK
-#define LCK_NB 0
 #else
 
@@ -46 +47 @@
 #   include <sys/types.h>
 #   include <sys/stat.h>
-#   define errno GetLastError()
+#   ifndef errno
+#       define errno GetLastError()
+#   endif
+#   define getuid() 0
+#   define LCK_WR LOCKFILE_EXCLUSIVE_LOCK
+#   define LCK_RD 0
+#   define LCK_UN 0
+#   define LCK_NB LOCKFILE_FAIL_IMMEDIATELY
 static inline int dolock(xc_lock_t *lck, int type) /* {{{ */
 { 
@@ -52 +60 @@
 
     if (type == LCK_UN) {
-        return UnlockFileEx((HANDLE)fd, 0, 1, 0, &offset);
+        return UnlockFileEx((HANDLE)lck->fd, 0, 1, 0, &offset);
     }
     else {
-        return LockFileEx((HANDLE)fd, type, 0, 1, 0, &offset);
+        return LockFileEx((HANDLE)lck->fd, type, 0, 1, 0, &offset);
     }
 }
 /* }}} */
-#define LCK_WR LOCKFILE_EXCLUSIVE_LOCK
-#define LCK_RD 0
-#define LCK_UN 0
-#define LCK_NB LOCKFILE_FAIL_IMMEDIATELY
 #endif
 
@@ -68 +72 @@
 {
     HANDLE fd;
-    char myname[sizeof("/tmp/.xcache.lock") - 1 + 20];
+    char myname[sizeof("/tmp/.xcache.lock") - 1 + 100];
 
     if (pathname == NULL) {
         static int i = 0;
-        snprintf(myname, sizeof(myname) - 1, "/tmp/.xcache.%d.%d.lock", (int) getuid(), i ++);
+        snprintf(myname, sizeof(myname) - 1, "/tmp/.xcache.%d.%d.%d.lock", (int) getuid(), i ++, rand());
         pathname = myname;
     }
 
-    fd = open(pathname, O_RDWR|O_CREAT, 0666);
+    fd = (HANDLE) open(pathname, O_RDWR|O_CREAT, 0666);
 
     if (fd > 0) {
@@ -99 +103 @@
 void xc_fcntl_destroy(xc_lock_t *lck) /* {{{ */
 {   
-    close(lck->fd);
+    CloseHandle(lck->fd);
 #ifdef __CYGWIN__
     unlink(lck->pathname);

trunk/mmap.c

@@ -7 +7 @@
 #include <string.h>
 #include <stdlib.h>
+
 /* mmap */
-#include <unistd.h>
+#ifdef ZEND_WIN32
+#   define ftruncate chsize
+#   define getuid() 0
+#   define XcacheCreateFileMapping(size, perm, name) \
+        CreateFileMapping(INVALID_HANDLE_VALUE, NULL, perm, (sizeof(xc_shmsize_t) > 4) ? size >> 32 : 0, size & 0xffffffff, name)
+#   define XCACHE_MAP_FAILED NULL
+#   define munmap(p, s) UnmapViewOfFile(p)
+#else
+#   include <unistd.h>
+#   define XCACHE_MAP_FAILED MAP_FAILED
+#endif
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+
+#ifndef ZEND_WIN32
 #include <sys/mman.h>
+#endif
 
 #include "php.h"
@@ -27 +42 @@
     long  diff;
     xc_shmsize_t size;
+    char *name;
+#ifdef ZEND_WIN32
+    HANDLE hmap;
+    HANDLE hmap_ro;
+#endif
 };
 
+#undef NDEBUG
 #ifdef ALLOC_DEBUG
-#   undef NDEBUG
 #   define inline
 #else
@@ -38 +58 @@
 /* }}} */
 #define CHECK(x, e) do { if ((x) == NULL) { zend_error(E_ERROR, "XCache: " e); goto err; } } while (0)
+#define PTR_ADD(ptr, v) (((char *) (ptr)) + (v))
+#define PTR_SUB(ptr, v) (((char *) (ptr)) - (v))
 
 int xc_shm_can_readonly(xc_shm_t *shm) /* {{{ */
@@ -58 +80 @@
     if (shm->diff) {
         assert(xc_shm_is_readonly(p));
-        p = p - shm->diff;
+        p = PTR_SUB(p, -shm->diff);
     }
     assert(xc_shm_is_readwrite(p));
@@ -68 +90 @@
     assert(xc_shm_is_readwrite(p));
     if (shm->diff) {
-        p = p + shm->diff;
+        p = PTR_ADD(p, shm->diff);
         assert(xc_shm_is_readonly(p));
     }
@@ -90 +112 @@
         */
     }
+#ifdef ZEND_WIN32
+    if (shm->hmap) {
+        CloseHandle(shm->hmap);
+    }
+    if (shm->hmap_ro) {
+        CloseHandle(shm->hmap_ro);
+    }
+#endif
+
+    if (shm->name) {
+#ifdef __CYGWIN__
+        unlink(shm->name);
+#endif
+        free(shm->name);
+    }
     /*
     shm->size = NULL;
@@ -102 +139 @@
 {
     xc_shm_t *shm = NULL;
-    int fd;
+    int fd = -1;
     int ro_ok;
     volatile void *romem;
-    int created = 0;
+    char tmpname[sizeof("/tmp/xcache") - 1 + 100];
 
     CHECK(shm = calloc(1, sizeof(xc_shm_t)), "shm OOM");
     shm->size = size;
+
     if (path == NULL || !path[0]) {
-        path = "/tmp/xcache";
-    }
-    fd = open(path, O_RDWR, S_IRUSR | S_IWUSR);
+        static int inc = 0;
+        snprintf(tmpname, sizeof(tmpname) - 1, "/tmp/xcache.%d.%d.%d", (int) getuid(), inc ++, rand());
+        path = tmpname;
+    }
+
+    shm->name = strdup(path);
+
+#ifndef ZEND_WIN32
+#   define XCACHE_MMAP_PERMISSION (S_IRUSR | S_IWUSR)
+    fd = open(shm->name, O_RDWR, XCACHE_MMAP_PERMISSION);
     if (fd == -1) {
-        created = 1;
-        fd = open(path, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+        fd = open(shm->name, O_CREAT | O_RDWR, XCACHE_MMAP_PERMISSION);
         if (fd == -1) {
-            if (created) {
-                unlink(path);
-            }
             goto err;
         }
     }
     ftruncate(fd, size);
-
+#endif
+
+#ifdef ZEND_WIN32
+    shm->hmap = XcacheCreateFileMapping(size, PAGE_READWRITE, shm->name);
+    shm->ptr = (LPSTR) MapViewOfFile(shm->hmap, FILE_MAP_WRITE, 0, 0, 0);
+#else
     shm->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (shm->ptr == MAP_FAILED) {
+#endif
+
+    if (shm->ptr == XCACHE_MAP_FAILED) {
         shm->ptr = NULL;
-        close(fd);
-        if (created) {
-            unlink(path);
-        }
         goto err;
     }
@@ -137 +181 @@
     ro_ok = 0;
     if (readonly_protection) {
+#ifdef ZEND_WIN32
+        shm->hmap_ro = XcacheCreateFileMapping(size, PAGE_READONLY, shm->name);
+        shm->ptr_ro = (LPSTR) MapViewOfFile(shm->hmap_ro, FILE_MAP_READ, 0, 0, 0);
+#else
         shm->ptr_ro = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
+#endif
         romem = shm->ptr_ro;
 
         /* {{{ check if ptr_ro works */
         do {
-            if (shm->ptr_ro == MAP_FAILED || shm->ptr_ro == shm->ptr) {
+            if (shm->ptr_ro == XCACHE_MAP_FAILED || shm->ptr_ro == shm->ptr) {
                 break;
             }
@@ -158 +207 @@
 
     if (ro_ok) {
-        shm->diff = shm->ptr_ro - shm->ptr;
+        shm->diff = PTR_SUB(shm->ptr_ro, (char *) shm->ptr);
         assert(abs(shm->diff) >= size);
     }
     else {
-        if (shm->ptr_ro != MAP_FAILED) {
+        if (shm->ptr_ro != XCACHE_MAP_FAILED) {
             munmap(shm->ptr_ro, size);
         }
@@ -171 +220 @@
 
     close(fd);
-    if (created) {
-        unlink(path);
-    }
+#ifndef __CYGWIN__
+    unlink(shm->name);
+#endif
 
     return shm;
 
 err:
+    if (fd != -1) {
+        close(fd);
+    }
     if (shm) {
         xc_shm_destroy(shm);

trunk/myshm.h

@@ -1 +1 @@
 typedef struct _xc_shm_t xc_shm_t;
-typedef unsigned int xc_shmsize_t;
+typedef size_t xc_shmsize_t;
 
 int xc_shm_can_readonly(xc_shm_t *shm);

trunk/processor/main.m4

@@ -15 +15 @@
 dnl }}}
 dnl {{{ ALLOC(1:dst, 2:type, 3:count=1, 4:clean=false, 5:forcetype=$2)
-dnl don't use typeof(dst) as we need the compiler warning
 define(`ALLOC', `
     pushdef(`COUNT', `ifelse(`$3', `', `1', `$3')')

trunk/processor/processor.m4

@@ -365 +365 @@
     DISPATCH(int, op_type)
 
+#ifdef IS_CV
+#   define XCACHE_IS_CV IS_CV
+#else
+/* compatible with zend optimizer */
+#   define XCACHE_IS_CV 16
+#endif
     assert(src->op_type == IS_CONST ||
         src->op_type == IS_VAR ||
-#ifdef IS_CV
-        src->op_type == IS_CV ||
-#else
-        src->op_type == 16 || /* zend optimizer */
-#endif
+        src->op_type == XCACHE_IS_CV ||
         src->op_type == IS_TMP_VAR ||
         src->op_type == IS_UNUSED);
+#undef XCACHE_IS_CV
     dnl dirty dispatch
     DISABLECHECK(`
@@ -463 +466 @@
     do {
     dnl RESTORE is done above!
+    zend_uint ii;
     int i;
 
@@ -481 +485 @@
     /* useless */
     COPY(prototype)
-    STRUCT_ARRAY(num_args, zend_arg_info, arg_info)
+    STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info)
     DISPATCH(zend_uint, num_args)
     DISPATCH(zend_uint, required_num_args)
@@ -490 +494 @@
         IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
         IFDASM(`do {
+            zend_uint ii;
             int i;
             zval *zv;
@@ -528 +533 @@
         processor->active_opcodes_src = src->opcodes;
     ')')
-    STRUCT_ARRAY(last, zend_op, opcodes)
+    STRUCT_ARRAY_I(last, zend_op, opcodes)
     popdef(`AFTER_ALLOC')
     DISPATCH(zend_uint, last)
@@ -546 +551 @@
     DISPATCH(zend_uint, T)
 
-    STRUCT_ARRAY(last_brk_cont, zend_brk_cont_element, brk_cont_array)
+    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array)
     DISPATCH(zend_uint, last_brk_cont)
     DISPATCH(zend_uint, current_brk_cont)

trunk/processor/string.m4

@@ -36 +36 @@
         ')
         IFCALC(`xc_calc_string_n(processor, ISTYPE, (void *) $2, `$3' IFASSERT(`, __LINE__'));')
-        IFSTORE(`$1 = (typeof($1)) xc_store_string_n(processor, ISTYPE, (char *) $2, `$3' IFASSERT(`, __LINE__'));')
+        IFSTORE(`$1 = (STRTYPE *) xc_store_string_n(processor, ISTYPE, (char *) $2, `$3' IFASSERT(`, __LINE__'));')
         IFRESTORE(`
-            ALLOC(`$1', `typeof($1[0])', `sizeof(STRTYPE) * ($3)')
+            ALLOC(`$1', `STRTYPE', `sizeof(STRTYPE) * ($3)')
             memcpy($1, $2, sizeof(STRTYPE) * ($3));
         ')
-        FIXPOINTER_EX(`typeof($1[0])', `$1')
+        FIXPOINTER_EX(`STRTYPE', `$1')
         IFDASM(`
                 ifelse(STRTYPE,UChar, `

trunk/processor/struct.m4

@@ -39 +39 @@
             IFRESTORE(`assert(xc_is_shm(src));')
             IFCALCSTORE(`assert(!xc_is_shm(src));')
+            do {
         ')
 
         ifdef(`USEMEMCPY', `IFCOPY(`
             memcpy(dst, src, sizeof($1));
+            do {
         ')')
 
@@ -84 +86 @@
                 /* }}} */
         ')')
+        ifdef(`USEMEMCPY', `IFCOPY(`
+            } while (0);
+        ')')
         IFASSERT(`
+            } while (0);
             undefine(`ELEMENTS_DONE')
         ')
@@ -144 +150 @@
 ')
 dnl }}}
+dnl {{{ STRUCT_ARRAY_I(1:count, 2:type, 3:elm, 4:name=type)
+define(`STRUCT_ARRAY_I', `
+pushdef(`i', `ii')
+STRUCT_ARRAY(`$1', `$2', `$3', `$4')
+popdef(`i')
+')
+dnl }}}
 dnl {{{ STRUCT_ARRAY(1:count, 2:type, 3:elm, 4:name=type)
 define(`STRUCT_ARRAY', `

trunk/stack.c

@@ -51 +51 @@
 void xc_stack_reverse(S stack)
 {
-    typeof(stack->cnt) i, j;
+    int i, j;
     void *tmp;
 

trunk/utils.c

@@ -234 +234 @@
 {
     zend_op *opline;
-    int i;
+    zend_uint i;
 
     opline = op_array->opcodes;
@@ -282 +282 @@
 ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, zend_uchar type, void *key, uint len TSRMLS_DC) /* {{{ */
 {
+    zend_class_entry *cep = CestToCePtr(*cest);
     ZESW(void *stored_ce_ptr, );
-    zend_class_entry *cep = CestToCePtr(*cest);
 
     if (zend_u_hash_add(CG(class_table), type, key, len,

trunk/xcache.c

@@ -27 +27 @@
 #include "opcode_spec.h"
 
+#undef NDEBUG
 #ifdef DEBUG
-#   undef NDEBUG
 #   undef inline
 #   define inline
@@ -340 +340 @@
     for (i = 0, c = cache->hentry->size; i < c; i ++) {
         for (e = cache->entries[i]; e; e = e->next) {
-            xc_fillentry_dmz(e, 0, list);
+            xc_fillentry_dmz(e, 0, list TSRMLS_CC);
         }
     }
@@ -348 +348 @@
     array_init(list);
     for (e = cache->deletes; e; e = e->next) {
-        xc_fillentry_dmz(e, 1, list);
+        xc_fillentry_dmz(e, 1, list TSRMLS_CC);
     }
     add_assoc_zval(return_value, "deleted_list", list);
@@ -402 +402 @@
     int i;
     xc_cache_t *cache;
-    typeof(cache->deletes) p, *last;
+    typedef xc_entry_t *xc_delete_t;
+    xc_delete_t p, *last;
 
     for (i = 0; i < size; i ++) {
@@ -408 +409 @@
         ENTER_LOCK(cache) {
             if (cache->deletes) {
-                last = (typeof(last)) &cache->deletes;
+                last = (xc_delete_t *) &cache->deletes;
                 for (p = *last; p; p = p->next) {
                     if (t - p->dtime > 3600) {
@@ -433 +434 @@
 }
 /* }}} */
-static inline void xc_entry_unholds_real(xc_stack_t *holds, xc_cache_t **caches, int cachecount) /* {{{ */
+static inline void xc_entry_unholds_real(xc_stack_t *holds, xc_cache_t **caches, int cachecount TSRMLS_DC) /* {{{ */
 {
     int i;
@@ -457 +458 @@
 static void xc_entry_unholds(TSRMLS_D) /* {{{ */
 {
-    xc_entry_unholds_real(XG(php_holds), xc_php_caches, xc_php_hcache.size);
-    xc_entry_unholds_real(XG(var_holds), xc_var_caches, xc_var_hcache.size);
-}
-/* }}} */
-static int xc_stat(const char *filename, const char *include_path, struct stat *pbuf) /* {{{ */
+    xc_entry_unholds_real(XG(php_holds), xc_php_caches, xc_php_hcache.size TSRMLS_CC);
+    xc_entry_unholds_real(XG(var_holds), xc_var_caches, xc_var_hcache.size TSRMLS_CC);
+}
+/* }}} */
+static int xc_stat(const char *filename, const char *include_path, struct stat *pbuf TSRMLS_DC) /* {{{ */
 {
     char filepath[1024];
@@ -472 +473 @@
     memcpy(paths, include_path, size);
 
-    for (path = strtok_r(paths, tokens, &tokbuf); path; path = strtok_r(NULL, tokens, &tokbuf)) {
+    for (path = php_strtok_r(paths, tokens, &tokbuf); path; path = php_strtok_r(NULL, tokens, &tokbuf)) {
         if (strlen(path) + strlen(filename) + 1 > 1024) {
             continue;
@@ -536 +537 @@
         }
         else {
-            if (xc_stat(filename, PG(include_path), pbuf) != 0) {   
+            if (xc_stat(filename, PG(include_path), pbuf TSRMLS_CC) != 0) {   
                 return 0;
             }
@@ -825 +826 @@
 static int xc_init_constant(int module_number TSRMLS_DC) /* {{{ */
 {
-    struct {
+    typedef struct {
         const char *prefix;
         int (*getsize)();
         const char *(*get)(zend_uchar i);
-    } nameinfos[] = {
+    } xc_meminfo_t;
+    xc_meminfo_t nameinfos[] = {
         { "",        xc_get_op_type_count,   xc_get_op_type   },
         { "",        xc_get_data_type_count, xc_get_data_type },
@@ -836 +838 @@
         { NULL, NULL, NULL }
     };
-    typeof(nameinfos[0])* p;
+    xc_meminfo_t* p;
     int i;
     char const_name[96];
@@ -861 +863 @@
 }
 /* }}} */
-static xc_shm_t *xc_cache_destroy(xc_cache_t **caches, xc_hash_t *hcache TSRMLS_DC) /* {{{ */
+static xc_shm_t *xc_cache_destroy(xc_cache_t **caches, xc_hash_t *hcache) /* {{{ */
 {
     int i;
@@ -891 +893 @@
 }
 /* }}} */
-static xc_cache_t **xc_cache_init(xc_shm_t *shm, char *ptr, xc_hash_t *hcache, xc_hash_t *hentry, xc_shmsize_t shmsize TSRMLS_DC) /* {{{ */
+static xc_cache_t **xc_cache_init(xc_shm_t *shm, char *ptr, xc_hash_t *hcache, xc_hash_t *hentry, xc_shmsize_t shmsize) /* {{{ */
 {
     xc_cache_t **caches = NULL, *cache;
     xc_mem_t *mem;
     int i;
+
     xc_memsize_t memsize = shmsize / hcache->size;
 
@@ -948 +951 @@
 static int xc_init(int module_number TSRMLS_DC) /* {{{ */
 {
-    xc_php_caches = xc_var_caches = NULL;
     xc_shm_t *shm;
     char *ptr;
+
+    xc_php_caches = xc_var_caches = NULL;
 
     if (xc_php_size || xc_var_size) {
@@ -1057 +1061 @@
 /* }}} */
 
-#define NEED_INITIZED() do { \
-    if (!xc_initized) { \
-        php_error_docref(NULL TSRMLS_CC, E_WARNING, "XCache is not initized"); \
-        RETURN_FALSE; \
-    } \
-} while (0)
-
 /* user functions */
 /* {{{ xcache_op */
@@ -1069 +1066 @@
 static void xcache_op(xcache_op_type optype, INTERNAL_FUNCTION_PARAMETERS)
 {
-    NEED_INITIZED();
     long type;
     int size;
     xc_cache_t **caches, *cache;
     long id = 0;
+
+    if (!xc_initized) {
+        php_error_docref(NULL TSRMLS_CC, E_WARNING, "XCache is not initized");
+        RETURN_FALSE;
+    }
 
     if (optype == XC_OP_COUNT) {
@@ -1239 +1240 @@
             }
             else {
-                xc_entry_remove_dmz(stored_xce);
+                xc_entry_remove_dmz(stored_xce TSRMLS_CC);
             }
         }
@@ -1266 +1267 @@
         stored_xce = xc_entry_find_dmz(&xce TSRMLS_CC);
         if (stored_xce) {
-            xc_entry_remove_dmz(stored_xce);
+            xc_entry_remove_dmz(stored_xce TSRMLS_CC);
         }
         var.value = value;
         var.etime = ttl ? XG(request_time) + ttl : TIME_MAX;
-        RETVAL_BOOL(xc_entry_store_dmz(&xce) != NULL ? 1 : 0);
+        RETVAL_BOOL(xc_entry_store_dmz(&xce TSRMLS_CC) != NULL ? 1 : 0);
     } LEAVE_LOCK(xce.cache);
 }
@@ -1297 +1298 @@
             }
             else {
-                xc_entry_remove_dmz(stored_xce);
+                xc_entry_remove_dmz(stored_xce TSRMLS_CC);
             }
         }
@@ -1322 +1323 @@
         stored_xce = xc_entry_find_dmz(&xce TSRMLS_CC);
         if (stored_xce) {
-            xc_entry_remove_dmz(stored_xce);
+            xc_entry_remove_dmz(stored_xce TSRMLS_CC);
             RETVAL_TRUE;
         }
@@ -1359 +1360 @@
                 fprintf(stderr, "incdec: expired\n");
 #endif
-                xc_entry_remove_dmz(stored_xce);
+                xc_entry_remove_dmz(stored_xce TSRMLS_CC);
                 stored_xce = NULL;
             }
@@ -1399 +1400 @@
             xce.ctime = stored_xce->ctime;
             xce.hits  = stored_xce->hits;
-            xc_entry_remove_dmz(stored_xce);
-        }
-        xc_entry_store_dmz(&xce);
+            xc_entry_remove_dmz(stored_xce TSRMLS_CC);
+        }
+        xc_entry_store_dmz(&xce TSRMLS_CC);
 
     } LEAVE_LOCK(xce.cache);
@@ -1492 +1493 @@
     }
     if (spec >= 0 && spec < count) {
-        name = getter(spec);
+        name = getter((zend_uchar) spec);
         if (name) {
             /* RETURN_STRING */
@@ -1540 +1541 @@
     }
     if (spec <= xc_get_opcode_spec_count()) {
-        opspec = xc_get_opcode_spec(spec);
+        opspec = xc_get_opcode_spec((zend_uchar) spec);
         if (opspec) {
             array_init(return_value);
@@ -1886 +1887 @@
 #endif
 {
+    TSRMLS_FETCH();
+
     xc_request_shutdown(TSRMLS_C);
     return SUCCESS;

trunk/xcache.h

@@ -52 +52 @@
 #define BUCKET_KEY_TYPE(b) (UNISW(0, (b)->key.type))
 #ifdef IS_UNICODE
-#   define BUCKET_HEAD_SIZE(b) XtOffsetOf(typeof(b[0]), key)
-#else
-#   define BUCKET_HEAD_SIZE(b) XtOffsetOf(typeof(b[0]), arKey)
+#   define BUCKET_HEAD_SIZE(b) XtOffsetOf(Bucket, key)
+#else
+#   define BUCKET_HEAD_SIZE(b) XtOffsetOf(Bucket, arKey)
 #endif
 #define BUCKET_SIZE(b) (BUCKET_HEAD_SIZE(b) + BUCKET_KEY_SIZE(b))
@@ -117 +117 @@
 /* {{{ xc_cache_t */
 typedef struct _xc_entry_t xc_entry_t;
-typedef volatile struct {
+typedef struct {
     int cacheid;
     xc_hash_t  *hcache; /* hash to cacheid */
 
-    zend_bool  compiling;
+    time_t     compiling;
     zend_ulong misses;
     zend_ulong hits;