Changeset 44 for trunk/fastxsl.c

Show
Ignore:
Timestamp:
11/06/07 00:30:37 (11 years ago)
Author:
jesus
Message:

take fster branch up to [43] into trunk

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk

    • Property svn:ignore set to
      configure
      config.log
      config.guess
      run-tests.php
      config.h
      config.sub
      ltmain.sh
      Makefile.fragments
      Makefile.objects
      .libs
      modules
      Makefile.global
      Makefile
      mkinstalldirs
      config.nice
      include
      configure.in
      config.status
      build
      config.h.in
      libtool
      autom4te.cache
      acinclude.m4
      missing
      aclocal.m4
      install-sh
  • trunk/fastxsl.c

    r32 r44  
    3232#include <libxml/xpathInternals.h> 
    3333#include <libxml/xpath.h> 
     34#include <libxml/uri.h> 
    3435#include <libxslt/xslt.h> 
    3536#include <libxslt/xsltInternals.h> 
     
    4748#include <fcntl.h> 
    4849 
     50 
    4951#include "fl_hash.h" 
    5052#include "php.h" 
     
    5557ZEND_DECLARE_MODULE_GLOBALS(fastxsl) 
    5658 
    57 static int inshm = 0; 
    58  
    5959static int le_fastxsl_stylesheet; 
    6060#define le_fastxsl_stylesheet_name "FastXSL Stylesheet" 
     
    6969static void _SS_Wrapper_Dtor(php_ss_wrapper *wrapper); 
    7070static void _XD_Wrapper_Dtor(php_xd_wrapper *wrapper); 
     71 
     72extern void HACK_xsltDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs); 
    7173 
    7274static php_ss_wrapper * 
     
    117119{ 
    118120        TSRMLS_FETCH(); 
    119 #ifdef DEBUGMM 
    120         if(!inshm) assert(0); 
    121 #endif 
    122121        FASTXSL_G(tmp_allocated_size) -= mm_sizeof(FASTXSL_G(cache)->mm, ptr); 
    123122        mm_free(FASTXSL_G(cache)->mm, ptr); 
     
    129128        void *ptr; 
    130129        TSRMLS_FETCH(); 
    131 #ifdef DEBUGMM 
    132         if(!inshm) assert(0); 
    133 #endif 
    134130        ptr = mm_malloc(FASTXSL_G(cache)->mm, size); 
    135131        if (!ptr) { 
     
    150146        void *ptr; 
    151147 
    152 #ifdef DEBUGMM 
    153         if(!inshm) assert(0); 
    154 #endif 
    155148        ptr = ShmCache_Malloc(nmemb * size); 
    156149        memset(ptr, 0, nmemb * size); 
     
    165158        TSRMLS_FETCH(); 
    166159 
    167 #ifdef DEBUGMM 
    168         if(!inshm) assert(0); 
    169 #endif 
    170160        oldsize = mm_sizeof(FASTXSL_G(cache)->mm, ptr); 
    171161        newptr = mm_realloc(FASTXSL_G(cache)->mm, ptr, size); 
     
    188178        int   string_length; 
    189179 
    190 #ifdef DEBUGMM 
    191         if(!inshm) assert(0); 
    192 #endif 
    193180        string_length = strlen(string); 
    194181        newstring = ShmCache_Malloc(string_length + 1); 
     
    291278        if (wrapper->data_type == FASTXSL_STYLESHEET) { 
    292279                if (wrapper->data.ss) { 
    293                         //xmlCleanupParserr(); 
    294280                        ShmCache_UseAllocationFunctions(); 
    295 inshm = 1; 
    296281                        xsltFreeStylesheet(wrapper->data.ss); 
    297 inshm = 0; 
    298                         //xmlCleanupParserr(); 
    299282                        Xml_UseAllocationFunctions(); 
    300283                } 
     
    308291        if (wrapper->data_type == FASTXSL_XPATHOBJ) { 
    309292                if (wrapper->data.ss) { 
    310                         //xmlCleanupParserr(); 
    311293                        ShmCache_UseAllocationFunctions(); 
    312 inshm = 1; 
    313294                        xmlXPathFreeObject(wrapper->data.op); 
    314 inshm = 0; 
    315                         //xmlCleanupParserr(); 
    316295                        Xml_UseAllocationFunctions(); 
    317296                } 
     
    356335        xsltTransformContextPtr tctxt; 
    357336        xmlChar *base = NULL, *URI; 
    358         int lockfd; 
    359337        char *ss_filename; 
    360338        int ss_filename_len; 
    361339        struct stat sb; 
    362340        php_ss_wrapper *ss_wrapper; 
    363 #ifdef F_SETLK 
    364         struct flock lock; 
    365  
    366         lock.l_start = 0; 
    367         lock.l_whence = SEEK_SET; 
    368         lock.l_len = 0; 
    369 #endif 
     341 
    370342        xmlXPathStringFunction(ctxt, 1); 
    371343        if (ctxt->value->type != XPATH_STRING) { 
     
    393365        strcpy(ss_filename, (char *)URI); 
    394366 
    395         lockfd = open(ss_filename, O_RDONLY); 
    396         if(lockfd < 0) { 
    397                 /* FIXME non-existent file */ 
    398                 goto error; 
    399         } 
    400         if (!FASTXSL_G(nostat)) { 
    401                 if (fstat(lockfd, &sb) == -1) { 
    402                         ShmCache_UseAllocationFunctions(); 
    403 inshm = 1; 
    404                         ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    405 inshm = 0; 
    406                         Xml_UseAllocationFunctions(); 
    407                         close(lockfd); 
    408                         goto error; 
    409                 } 
    410         } else { 
    411                 sb.st_mtime = 0; 
    412         } 
    413 #ifdef F_SETLK 
    414         lock.l_type = F_WRLCK; 
    415         fcntl(lockfd, F_SETLKW, &lock); 
    416 #else 
    417         flock(lockfd, LOCK_EX); 
    418 #endif 
     367        sb.st_mtime = 0; 
     368 
    419369        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
    420370        ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     371        if(ss_wrapper) ss_wrapper->hits++; 
    421372        mm_unlock(FASTXSL_G(cache)->mm); 
     373 
    422374        if (!ss_wrapper) { 
    423                 ss_wrapper = SS_Wrapper_Alloc(FASTXSL_SHARED_ALLOC TSRMLS_CC); 
    424                 if(ss_wrapper) { 
    425                         int rv; 
    426                         ss_wrapper->alloc_type = FASTXSL_SHMALLOC; 
    427                         ss_wrapper->data_type = FASTXSL_XPATHOBJ; 
    428                         ShmCache_UseAllocationFunctions(); 
    429 inshm = 1; 
    430                         FASTXSL_G(tmp_allocated_size) = 0; 
    431                         valuePush(ctxt, xmlXPathObjectCopy(ctxt->value)); 
    432                         HACK_xsltDocumentFunction(ctxt, nargs); 
    433                         ss_wrapper->data.op = xmlXPathObjectCopy(ctxt->value); 
    434                         valuePop(ctxt); 
    435                         ss_wrapper->allocsize = FASTXSL_G(tmp_allocated_size); 
    436 inshm = 0; 
    437                         Xml_UseAllocationFunctions(); 
    438                         ss_wrapper->mtime = sb.st_mtime; 
    439                         mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
    440                         rv = fl_hash_add(FASTXSL_G(cache)->table, ss_filename, ss_filename_len, ss_wrapper); 
    441                         mm_unlock(FASTXSL_G(cache)->mm); 
    442                         if(rv == 0) { 
    443                                 /* we failed */ 
    444                                 php_ss_wrapper *fallback; 
     375                int lockfd; 
     376                lockfd = open(ss_filename, O_RDONLY); 
     377                if(lockfd < 0) goto error; 
     378 
     379                /* It would be really bad if we longjmp'd out with the lock */ 
     380                zend_set_timeout(0); 
     381                /* Lock, but we may not be the only one... */ 
     382                ACQUIRE(lockfd); 
     383                /* We have the lock, lets see if someone beat us here */ 
     384                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
     385                ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     386                if(ss_wrapper) ss_wrapper->hits++; 
     387                mm_unlock(FASTXSL_G(cache)->mm); 
     388 
     389                if(ss_wrapper) { 
     390                        /* Someone beat us */ 
     391                } 
     392                else { 
     393                        ss_wrapper = SS_Wrapper_Alloc(FASTXSL_SHARED_ALLOC TSRMLS_CC); 
     394                        if(ss_wrapper) { 
     395                                int rv; 
     396                                if (!FASTXSL_G(nostat)) { 
     397                                        if (fstat(lockfd, &sb) == -1) { 
     398                                                ShmCache_UseAllocationFunctions(); 
     399                                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     400                                                Xml_UseAllocationFunctions(); 
     401                                                RELEASE(lockfd); 
     402                                                close(lockfd); 
     403                                                goto error; 
     404                                        } 
     405                                } 
     406                                ss_wrapper->alloc_type = FASTXSL_SHMALLOC; 
     407                                ss_wrapper->data_type = FASTXSL_XPATHOBJ; 
     408                                ShmCache_UseAllocationFunctions(); 
     409                                FASTXSL_G(tmp_allocated_size) = 0; 
     410                                valuePush(ctxt, xmlXPathObjectCopy(ctxt->value)); 
     411                                HACK_xsltDocumentFunction(ctxt, nargs); 
     412                                ss_wrapper->data.op = xmlXPathObjectCopy(ctxt->value); 
     413                                valuePop(ctxt); 
     414                                ss_wrapper->allocsize = FASTXSL_G(tmp_allocated_size); 
     415                                Xml_UseAllocationFunctions(); 
     416                                ss_wrapper->mtime = sb.st_mtime; 
    445417                                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
    446                                 fallback = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     418                                rv = fl_hash_add(FASTXSL_G(cache)->table, ss_filename, ss_filename_len, ss_wrapper); 
    447419                                mm_unlock(FASTXSL_G(cache)->mm); 
    448                                 if(fallback && fallback->data_type == FASTXSL_XPATHOBJ) { 
    449                                         ShmCache_UseAllocationFunctions(); 
    450 inshm = 1; 
    451                                         ShmCache_XPathObject_Free(ss_wrapper); 
    452 inshm = 0; 
    453                                         Xml_UseAllocationFunctions(); 
    454                                         ss_wrapper = fallback; 
     420                                if(rv == 0) { 
     421                                        /* we failed */ 
     422                                        php_ss_wrapper *fallback; 
     423                                        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     424                                        fallback = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     425                                        mm_unlock(FASTXSL_G(cache)->mm); 
     426                                        if(fallback && fallback->data_type == FASTXSL_XPATHOBJ) { 
     427                                                ShmCache_UseAllocationFunctions(); 
     428                                                ShmCache_XPathObject_Free(ss_wrapper); 
     429                                                Xml_UseAllocationFunctions(); 
     430                                                ss_wrapper = fallback; 
     431                                        } else { 
     432                                        } 
    455433                                } else { 
    456434                                } 
    457                         } else { 
    458435                        } 
    459436                } 
     437                RELEASE(lockfd); 
     438                close(lockfd); 
    460439                if (!ss_wrapper) { 
    461 #ifdef F_SETLK 
    462                         lock.l_type = F_UNLCK; 
    463                         fcntl(lockfd, F_SETLK, &lock); 
    464 #else 
    465                         flock(lockfd, LOCK_UN); 
    466 #endif 
    467                         close(lockfd); 
    468                         //xmlCleanupParserr(); 
    469440                        Xml_UseAllocationFunctions(); 
    470441                        goto error; 
    471442                } 
    472         } else { 
     443        } 
     444        else { 
    473445                if (!FASTXSL_G(nostat)) { 
     446                        int lockfd; 
     447                        lockfd = open(ss_filename, O_RDONLY); 
     448                        if(lockfd < 0) goto error; 
     449 
     450                        if (fstat(lockfd, &sb) == -1) { 
     451                                ShmCache_UseAllocationFunctions(); 
     452                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     453                                Xml_UseAllocationFunctions(); 
     454                                close(lockfd); 
     455                                goto error; 
     456                        } 
    474457                        if (ss_wrapper->mtime != sb.st_mtime) { 
     458                                /* It would be really bad if we longjmp'd out with the lock */ 
     459                                zend_set_timeout(0); 
     460                                ACQUIRE(lockfd); 
    475461                                ShmCache_UseAllocationFunctions(); 
    476 inshm = 1; 
    477462                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    478 inshm = 0; 
    479463                                Xml_UseAllocationFunctions(); 
    480464                                ss_wrapper = SS_Wrapper_Alloc(FASTXSL_SHARED_ALLOC TSRMLS_CC); 
     
    484468                                        ss_wrapper->data_type = FASTXSL_STYLESHEET; 
    485469                                        ShmCache_UseAllocationFunctions(); 
    486 inshm = 1; 
    487470                                        FASTXSL_G(tmp_allocated_size) = 0; 
    488471                                        valuePush(ctxt, xmlXPathObjectCopy(ctxt->value)); 
     
    491474                                        valuePop(ctxt); 
    492475                                        ss_wrapper->allocsize = FASTXSL_G(tmp_allocated_size); 
    493 inshm = 0; 
    494476                                        Xml_UseAllocationFunctions(); 
    495477                                        ss_wrapper->mtime = sb.st_mtime; 
     
    505487                                                if(fallback && fallback->data_type == FASTXSL_XPATHOBJ) { 
    506488                                                        ShmCache_UseAllocationFunctions(); 
    507 inshm = 1; 
    508489                                                        ShmCache_XPathObject_Free(ss_wrapper); 
    509 inshm = 0; 
    510490                                                        Xml_UseAllocationFunctions(); 
    511491                                                        ss_wrapper = fallback; 
     
    515495                                        } 
    516496                                } 
    517                                 //xmlCleanupParserr(); 
     497                                RELEASE(lockfd); 
     498                                close(lockfd); 
    518499                                if (!ss_wrapper) { 
    519 #ifdef F_SETLK 
    520                                         lock.l_type = F_UNLCK; 
    521                                         fcntl(lockfd, F_SETLK, &lock); 
    522 #else 
    523                                         flock(lockfd, LOCK_UN); 
    524 #endif 
    525                                         close(lockfd); 
    526500                                        goto error; 
    527501                                } 
     
    529503                } 
    530504        } 
    531         ss_wrapper->hits++; 
    532         //xmlCleanupParserr(); 
    533505        Xml_UseAllocationFunctions(); 
    534 #ifdef F_SETLK 
    535         lock.l_type = F_UNLCK; 
    536         fcntl(lockfd, F_SETLK, &lock); 
    537 #else 
    538         flock(lockfd, LOCK_UN); 
    539 #endif 
    540         close(lockfd); 
    541506 
    542507        valuePop(ctxt); 
     
    566531         
    567532        if(fl_hash_add(FASTXSL_G(cache)->prmtable, filename, filename_len, wrapper) == 0) { 
    568                 /* we failed, not much we can do here, and no race */ 
     533                /* we failed */ 
     534                php_ss_wrapper *fallback; 
     535                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     536                fallback = fl_hash_find(FASTXSL_G(cache)->table, filename, filename_len); 
     537                mm_unlock(FASTXSL_G(cache)->mm); 
     538                if(fallback) { 
     539                        ShmCache_Stylesheet_Free(wrapper); 
     540                        wrapper = fallback; 
     541                } 
    569542        } 
    570543 
     
    670643 
    671644        add_assoc_long(return_value, "apparent_allocated", allocated_bytes); 
    672         add_assoc_long(return_value, "allocated",  
    673           (FASTXSL_G(memalloc)?FASTXSL_G(memalloc):mm_maxsize()) - mm_available(FASTXSL_G(cache)->mm)); 
    674         add_assoc_long(return_value, "shm_size", (long) FASTXSL_G(memalloc)?FASTXSL_G(memalloc):mm_maxsize()); 
     645        add_assoc_long(return_value, "real_allocated", mm_maxsize() - mm_available(FASTXSL_G(cache)->mm)); 
     646        add_assoc_long(return_value, "shm_maxsize", (long) mm_maxsize()); 
    675647        mm_unlock(FASTXSL_G(cache)->mm); 
    676648} 
    677  
    678 #endif 
    679 /* }}} */ 
    680649 
    681650/* {{{ proto array fastxsl_version(void) 
     
    689658} 
    690659 
     660PHP_FUNCTION(fastxsl_xmlMemoryDump) 
     661{ 
     662  chdir("/tmp"); 
     663  xmlMemDisplay(stderr); 
     664} 
     665#endif 
    691666/* }}} */ 
    692667 
     
    731706        wrapper->alloc_type = FASTXSL_PRMALLOC; 
    732707        Xml_UseAllocationFunctions(); 
    733         wrapper->xd = xmlParseDoc((xmlChar *) text); 
     708        wrapper->xd = xmlParseDoc((unsigned char *)text); 
    734709        if (!wrapper->xd) { 
    735710                _XD_Wrapper_Dtor(wrapper); 
     
    773748        HashPosition   pos; 
    774749        char          *key; 
    775         uint           key_length; 
     750        unsigned int   key_length; 
    776751        unsigned long  ival; 
    777752        int            index = 0; 
     
    829804        zval             *z_parameters; 
    830805        struct stat       sb; 
    831         int lockfd; 
    832 #ifdef F_SETLK 
    833         struct flock lock; 
    834  
    835         lock.l_start = 0; 
    836         lock.l_whence = SEEK_SET; 
    837         lock.l_len = 0; 
    838 #endif 
    839  
    840806         
    841807        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|z", &ss_filename, &ss_filename_len, 
     
    855821        result_wrapper = XD_Wrapper_Alloc(); 
    856822        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
    857         lockfd = open(ss_filename, O_RDONLY); 
    858         if(lockfd < 0) { 
    859                 /* FIXME non-existent file */ 
    860                 RETURN_FALSE; 
    861         } 
    862         if (!FASTXSL_G(nostat)) { 
    863                 if (fstat(lockfd, &sb) == -1) { 
    864                         ShmCache_UseAllocationFunctions(); 
    865 inshm = 1; 
    866                         ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    867 inshm = 0; 
    868                         Xml_UseAllocationFunctions(); 
    869                         _XD_Wrapper_Dtor(result_wrapper); 
    870                         free(parameters); 
    871                         close(lockfd); 
    872                         RETURN_FALSE; 
    873                 } 
    874         } else { 
    875                 sb.st_mtime = 0; 
    876         } 
    877 #ifdef F_SETLK 
    878         lock.l_type = F_WRLCK; 
    879         fcntl(lockfd, F_SETLKW, &lock); 
    880 #else 
    881         flock(lockfd, LOCK_EX); 
    882 #endif 
     823 
     824        sb.st_mtime = 0; 
     825 
    883826        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
    884827        ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     828        if(ss_wrapper) ss_wrapper->hits++; 
    885829        mm_unlock(FASTXSL_G(cache)->mm); 
     830 
    886831        if (!ss_wrapper) { 
    887                 ShmCache_UseAllocationFunctions(); 
    888 inshm = 1; 
    889                 ss_wrapper = ShmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime); 
    890 inshm = 0; 
    891                 if (!ss_wrapper) { 
    892 #ifdef F_SETLK 
    893                         lock.l_type = F_UNLCK; 
    894                         fcntl(lockfd, F_SETLK, &lock); 
    895 #else 
    896                         flock(lockfd, LOCK_UN); 
    897 #endif 
    898                         close(lockfd); 
    899                         //xmlCleanupParserr(); 
    900                         Xml_UseAllocationFunctions(); 
    901                         _XD_Wrapper_Dtor(result_wrapper); 
    902                         free(parameters); 
    903                         RETURN_FALSE; 
    904                 } 
     832                int lockfd; 
     833                lockfd = open(ss_filename, O_RDONLY); 
     834                if(lockfd < 0) RETURN_FALSE; 
     835 
     836                /* It would be really bad if we longjmp'd out with the lock */ 
     837                zend_set_timeout(0); 
     838                /* Create a wait queue -- no herds */ 
     839                ACQUIRE(lockfd); 
     840 
     841                /* One last check */ 
     842                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
     843                ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     844                if(ss_wrapper) ss_wrapper->hits++; 
     845                mm_unlock(FASTXSL_G(cache)->mm); 
     846 
     847                if(ss_wrapper) { 
     848                        /* Someone beat us to it */ 
     849                } 
     850                else { 
     851                        if (fstat(lockfd, &sb) != -1) { 
     852                                ShmCache_UseAllocationFunctions(); 
     853                                ss_wrapper = ShmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime); 
     854                                Xml_UseAllocationFunctions(); 
     855                        } 
     856                        if (!ss_wrapper) { 
     857                                RELEASE(lockfd); 
     858                                close(lockfd); 
     859                                goto error; 
     860                        } 
     861                } 
     862                RELEASE(lockfd); 
     863                close(lockfd); 
    905864        } else { 
    906865                if (!FASTXSL_G(nostat)) { 
     866                        int lockfd; 
     867                        lockfd = open(ss_filename, O_RDONLY); 
     868                        if(lockfd < 0) RETURN_FALSE; 
     869                         
     870                        if (fstat(lockfd, &sb) == -1) { 
     871                                ShmCache_UseAllocationFunctions(); 
     872                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     873                                Xml_UseAllocationFunctions(); 
     874                                close(lockfd); 
     875                                goto error; 
     876                        } 
     877 
     878                        /* It would be really bad if we longjmp'd out with the lock */ 
     879                        zend_set_timeout(0); 
     880                        ACQUIRE(lockfd); 
    907881                        if (ss_wrapper->mtime != sb.st_mtime) { 
    908                                 //xmlCleanupParserr(); 
    909882                                ShmCache_UseAllocationFunctions(); 
    910 inshm = 1; 
    911883                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    912884                                ss_wrapper = ShmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime TSRMLS_CC); 
    913 inshm = 0; 
    914                                 //xmlCleanupParserr(); 
    915885                                Xml_UseAllocationFunctions(); 
    916886                                if (!ss_wrapper) { 
    917 #ifdef F_SETLK 
    918                                         lock.l_type = F_UNLCK; 
    919                                         fcntl(lockfd, F_SETLK, &lock); 
    920 #else 
    921                                         flock(lockfd, LOCK_UN); 
    922 #endif 
     887                                        RELEASE(lockfd); 
    923888                                        close(lockfd); 
    924                                         _XD_Wrapper_Dtor(result_wrapper); 
    925                                         free(parameters); 
    926                                         RETURN_FALSE; 
     889                                        goto error; 
    927890                                } 
    928891                        } 
    929                 } 
    930         } 
    931         ss_wrapper->hits++; 
    932         //xmlCleanupParserr(); 
    933         Xml_UseAllocationFunctions(); 
    934 #ifdef F_SETLK 
    935         lock.l_type = F_UNLCK; 
    936         fcntl(lockfd, F_SETLK, &lock); 
    937 #else 
    938         flock(lockfd, LOCK_UN); 
    939 #endif 
    940         close(lockfd); 
     892                        RELEASE(lockfd); 
     893                        close(lockfd); 
     894                } 
     895        } 
    941896 
    942897        ctxt = xsltNewTransformContext(ss_wrapper->data.ss, xd_wrapper->xd); 
     
    965920         
    966921        ZEND_REGISTER_RESOURCE(return_value, result_wrapper, le_fastxsl_document); 
     922        return; 
     923 
     924        error: 
     925                Xml_UseAllocationFunctions(); 
     926                if (parameters) free(parameters); 
     927                _XD_Wrapper_Dtor(result_wrapper); 
     928                RETURN_FALSE; 
    967929} 
    968930#endif 
     
    12571219        PHP_FE(fastxsl_xml_parsefile,                NULL) 
    12581220        PHP_FE(fastxsl_xml_parsestring,              NULL) 
     1221        PHP_FE(fastxsl_version,                      NULL) 
    12591222#ifdef FASTXSL_MM 
    12601223        PHP_FE(fastxsl_shmcache_transform,           NULL) 
    12611224        PHP_FE(fastxsl_shmcache_tostring,            NULL) 
    12621225        PHP_FE(fastxsl_shmcache_getstatistics,       NULL) 
    1263 #endif 
    1264         PHP_FE(fastxsl_version,                      NULL) 
     1226        PHP_FE(fastxsl_xmlMemoryDump,                NULL) 
     1227#endif 
    12651228        PHP_FE(fastxsl_prmcache_transform,           NULL) 
    12661229        PHP_FE(fastxsl_nocache_transform,            NULL) 
     
    13051268                        Xml_UseAllocationFunctions(); 
    13061269                } 
    1307                 inshm = 1; 
    13081270                xsltFreeStylesheet(wrapper->data.ss); 
    1309                 inshm = 0; 
    13101271                if(wrapper->alloc_type == FASTXSL_SHMALLOC) { 
    13111272                        //xmlCleanupParserr(); 
     
    13141275        } 
    13151276        if(wrapper->persistant) { 
    1316 #ifdef FASTXSL_MM 
    13171277                mm_free(FASTXSL_G(cache)->mm, wrapper); 
    1318 #endif 
    13191278        } else { 
    13201279                free(wrapper); 
     
    13391298                        Xml_UseAllocationFunctions(); 
    13401299                } 
    1341 inshm = 1; 
    13421300                xmlFreeDoc(wrapper->xd); 
    1343 inshm = 0; 
    13441301                Xml_UseAllocationFunctions(); 
    13451302        } 
     
    15611518        STD_PHP_INI_ENTRY("fastxsl.shmpath", "/tmp/fastxsl_mem", PHP_INI_SYSTEM, OnUpdateString, shmpath, zend_fastxsl_globals, fastxsl_globals) 
    15621519        STD_PHP_INI_BOOLEAN("fastxsl.nostat", "0", PHP_INI_ALL, OnUpdateLong, nostat, zend_fastxsl_globals, fastxsl_globals)  
    1563         STD_PHP_INI_BOOLEAN("fastxsl.replace_document_function", "0", PHP_INI_ALL, OnUpdateLong, replace_document_function, zend_fastxsl_globals, fastxsl_globals)  
     1520        STD_PHP_INI_BOOLEAN("fastxsl.replace_document_function", "0", PHP_INI_ALL, OnUpdateLong, replace_document_function, zend_fastxsl_globals, fastxsl_globals) 
    15641521        STD_PHP_INI_BOOLEAN("fastxsl.memalloc", "0", PHP_INI_SYSTEM, OnUpdateLong, memalloc, zend_fastxsl_globals, fastxsl_globals)  
    15651522        STD_PHP_INI_BOOLEAN("fastxsl.register_functions", "0", PHP_INI_ALL, OnUpdateLong, register_functions, zend_fastxsl_globals, fastxsl_globals)  
     
    16071564        //xmlCleanupParserr(); 
    16081565        ShmCache_UseAllocationFunctions(); 
    1609 inshm = 1; 
    16101566        xsltRegisterAllExtras(); 
    16111567#if HAVE_DOMEXSLT 
     
    16251581                                           fastxsl_ext_function); 
    16261582        } 
     1583        xsltRegisterExtModuleFunction ((const xmlChar *) "cached_document", 
     1584                                   (const xmlChar *) "http://php.net/fastxsl/cached_document", 
     1585                                   fastxsl_CachedDocumentFunction); 
    16271586        //xmlCleanupParserr(); 
    1628 inshm = 0; 
    16291587        Xml_UseAllocationFunctions(); 
    16301588        return SUCCESS;