Changeset 26 for trunk/fastxsl.c

Show
Ignore:
Timestamp:
07/17/07 17:18:33 (7 years ago)
Author:
jesus
Message:

Implement a cached_document function that leverages the shared memory stylesheet
cache to store XPathObjects as if the "document" function was called.

This is used to accelerate translation dictionary load-times for
internaionalization efforts.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/fastxsl.c

    r25 r26  
    3636#include <libxslt/transform.h> 
    3737#include <libxslt/xsltutils.h> 
     38#include <libxslt/extensions.h> 
     39#include <libxslt/functions.h> 
    3840 
    3941#ifdef FASTXSL_MM 
     
    111113 
    112114#ifdef FASTXSL_MM 
    113 static void 
     115void 
    114116ShmCache_Free(void *ptr) 
    115117{ 
    116118        TSRMLS_FETCH(); 
     119#ifdef DEBUGMM 
    117120        if(!inshm) assert(0); 
     121#endif 
    118122        FASTXSL_G(tmp_allocated_size) -= mm_sizeof(FASTXSL_G(cache)->mm, ptr); 
    119123        mm_free(FASTXSL_G(cache)->mm, ptr); 
    120124} 
    121125 
    122 static void * 
     126void * 
    123127ShmCache_Malloc(size_t size) 
    124128{ 
    125129        void *ptr; 
    126130        TSRMLS_FETCH(); 
     131#ifdef DEBUGMM 
    127132        if(!inshm) assert(0); 
     133#endif 
    128134        ptr = mm_malloc(FASTXSL_G(cache)->mm, size); 
    129135        if (!ptr) { 
     
    139145} 
    140146 
    141 static void * 
     147void * 
    142148ShmCache_Calloc(size_t nmemb, size_t size)  
    143149{ 
    144150        void *ptr; 
    145151 
     152#ifdef DEBUGMM 
    146153        if(!inshm) assert(0); 
     154#endif 
    147155        ptr = ShmCache_Malloc(nmemb * size); 
    148156        memset(ptr, 0, nmemb * size); 
     
    150158} 
    151159 
    152 static void * 
     160void * 
    153161ShmCache_Realloc(void *ptr, size_t size) 
    154162{ 
     
    157165        TSRMLS_FETCH(); 
    158166 
     167#ifdef DEBUGMM 
    159168        if(!inshm) assert(0); 
     169#endif 
    160170        oldsize = mm_sizeof(FASTXSL_G(cache)->mm, ptr); 
    161171        newptr = mm_realloc(FASTXSL_G(cache)->mm, ptr, size); 
     
    172182} 
    173183 
    174 static char * 
     184char * 
    175185ShmCache_Strdup(const char *string) 
    176186{ 
     
    178188        int   string_length; 
    179189 
     190#ifdef DEBUGMM 
    180191        if(!inshm) assert(0); 
     192#endif 
    181193        string_length = strlen(string); 
    182194        newstring = ShmCache_Malloc(string_length + 1); 
     
    244256        FASTXSL_G(tmp_allocated_size) = 0; 
    245257        zend_set_timeout(0); 
    246         wrapper->ss = xsltParseStylesheetFile(filename); 
     258        wrapper->data.ss = xsltParseStylesheetFile((unsigned char *)filename); 
     259        wrapper->data_type = FASTXSL_STYLESHEET; 
    247260        Xml_UseAllocationFunctions(); 
    248         if (!wrapper->ss) { 
     261        if (!wrapper->data.ss) { 
    249262                _SS_Wrapper_Dtor(wrapper); 
    250263                return NULL; 
     
    262275                                        filename_len); 
    263276                mm_unlock(FASTXSL_G(cache)->mm); 
    264                 if(fallback) { 
     277                if(fallback && fallback->data_type == FASTXSL_STYLESHEET) { 
    265278                        ShmCache_Stylesheet_Free(wrapper); 
    266279                        wrapper = fallback; 
     
    276289ShmCache_Stylesheet_Free(php_ss_wrapper *wrapper TSRMLS_DC) 
    277290{ 
    278         if (wrapper->ss) { 
    279                 //xmlCleanupParserr(); 
    280                 ShmCache_UseAllocationFunctions(); 
     291        if (wrapper->data_type == FASTXSL_STYLESHEET) { 
     292                if (wrapper->data.ss) { 
     293                        //xmlCleanupParserr(); 
     294                        ShmCache_UseAllocationFunctions(); 
    281295inshm = 1; 
    282                 xsltFreeStylesheet(wrapper->ss); 
     296                       xsltFreeStylesheet(wrapper->data.ss); 
    283297inshm = 0; 
    284                 //xmlCleanupParserr(); 
    285                 Xml_UseAllocationFunctions(); 
    286         } 
    287         mm_free(FASTXSL_G(cache)->mm, wrapper); 
     298                        //xmlCleanupParserr(); 
     299                        Xml_UseAllocationFunctions(); 
     300                } 
     301                mm_free(FASTXSL_G(cache)->mm, wrapper); 
     302        } 
    288303} 
    289304 
    290305static void 
    291 ShmCache_Stylesheet_Delete(char *filename, size_t filename_len) 
     306ShmCache_XPathObject_Free(php_ss_wrapper *wrapper TSRMLS_DC) 
     307
     308        if (wrapper->data_type == FASTXSL_XPATHOBJ) { 
     309                if (wrapper->data.ss) { 
     310                        //xmlCleanupParserr(); 
     311                        ShmCache_UseAllocationFunctions(); 
     312inshm = 1; 
     313                        xmlXPathFreeObject(wrapper->data.op); 
     314inshm = 0; 
     315                        //xmlCleanupParserr(); 
     316                        Xml_UseAllocationFunctions(); 
     317                } 
     318                mm_free(FASTXSL_G(cache)->mm, wrapper); 
     319        } 
     320
     321 
     322static void 
     323ShmCache_Document_Delete(char *filename, size_t filename_len) 
    292324{ 
    293325        php_ss_wrapper *wrapper; 
     
    300332                fl_hash_delete(FASTXSL_G(cache)->table, filename, filename_len); 
    301333                mm_unlock(FASTXSL_G(cache)->mm); 
    302                 ShmCache_Stylesheet_Free(wrapper); 
    303         } 
    304 
     334                switch(wrapper->data_type) { 
     335                        case FASTXSL_STYLESHEET: 
     336                                ShmCache_Stylesheet_Free(wrapper); 
     337                                break; 
     338                        case FASTXSL_XPATHOBJ: 
     339                                ShmCache_XPathObject_Free(wrapper); 
     340                                break; 
     341                        default: 
     342                                break; 
     343                } 
     344        } 
     345
     346#endif 
     347 
     348#ifdef FASTXSL_MM 
     349/* {{{ proto void fastxsl_CachedDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs) 
     350   Emulate xsltDocumentFunction but leverage the MM shared cache for speed. */ 
     351static void 
     352fastxsl_CachedDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs) 
     353
     354        xmlXPathFunction func; 
     355        xmlXPathObjectPtr idoc, obj; 
     356        int lockfd; 
     357        int popped = 0; 
     358        char *ss_filename; 
     359        int ss_filename_len; 
     360        struct stat sb; 
     361        php_ss_wrapper *ss_wrapper; 
     362#ifdef F_SETLK 
     363        struct flock lock; 
     364 
     365        lock.l_start = 0; 
     366        lock.l_whence = SEEK_SET; 
     367        lock.l_len = 0; 
     368#endif 
     369        xmlXPathStringFunction(ctxt, 1); 
     370        if (ctxt->value->type != XPATH_STRING) { 
     371                xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL, 
     372                                                 "document() : invalid arg expecting a string\n"); 
     373                goto error; 
     374        } 
     375        obj = ctxt->value; 
     376        ss_filename_len = strlen((char *)obj->stringval); 
     377        ss_filename = alloca(ss_filename_len + 1); 
     378        strcpy(ss_filename, (char *)obj->stringval); 
     379 
     380        lockfd = open(ss_filename, O_RDONLY); 
     381        if(lockfd < 0) { 
     382                /* FIXME non-existent file */ 
     383                goto error; 
     384        } 
     385        if (!FASTXSL_G(nostat)) { 
     386                if (fstat(lockfd, &sb) == -1) { 
     387                        ShmCache_UseAllocationFunctions(); 
     388inshm = 1; 
     389                        ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     390inshm = 0; 
     391                        Xml_UseAllocationFunctions(); 
     392                        close(lockfd); 
     393                        goto error; 
     394                } 
     395        } else { 
     396                sb.st_mtime = 0; 
     397        } 
     398#ifdef F_SETLK 
     399        lock.l_type = F_WRLCK; 
     400        fcntl(lockfd, F_SETLKW, &lock); 
     401#else 
     402        flock(lockfd, LOCK_EX); 
     403#endif 
     404        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RW); 
     405        ss_wrapper = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     406        mm_unlock(FASTXSL_G(cache)->mm); 
     407        if (!ss_wrapper) { 
     408                ss_wrapper = SS_Wrapper_Alloc(FASTXSL_SHARED_ALLOC TSRMLS_CC); 
     409                if(ss_wrapper) { 
     410                        int rv; 
     411                        ss_wrapper->alloc_type = FASTXSL_SHMALLOC; 
     412                        ss_wrapper->data_type = FASTXSL_STYLESHEET; 
     413                        func = xmlXPathFunctionLookup(ctxt->context, (const xmlChar *)"document"); 
     414                        ShmCache_UseAllocationFunctions(); 
     415inshm = 1; 
     416                        FASTXSL_G(tmp_allocated_size) = 0; 
     417                        func(ctxt, nargs); 
     418                        ss_wrapper->data.op = ctxt->value; 
     419                        ss_wrapper->allocsize = FASTXSL_G(tmp_allocated_size); 
     420                        valuePop(ctxt); 
     421                        popped = 1; 
     422inshm = 0; 
     423                        Xml_UseAllocationFunctions(); 
     424                        ss_wrapper->mtime = sb.st_mtime; 
     425                        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     426                        rv = fl_hash_add(FASTXSL_G(cache)->table, ss_filename, ss_filename_len, ss_wrapper); 
     427                        mm_unlock(FASTXSL_G(cache)->mm); 
     428                        if(rv == 0) { 
     429                                /* we failed */ 
     430                                php_ss_wrapper *fallback; 
     431                                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     432                                fallback = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     433                                mm_unlock(FASTXSL_G(cache)->mm); 
     434                                if(fallback && fallback->data_type == FASTXSL_XPATHOBJ) { 
     435                                        ShmCache_UseAllocationFunctions(); 
     436inshm = 1; 
     437                                        ShmCache_XPathObject_Free(ss_wrapper); 
     438inshm = 0; 
     439                                        Xml_UseAllocationFunctions(); 
     440                                        ss_wrapper = fallback; 
     441                                } else { 
     442                                } 
     443                        } else { 
     444                        } 
     445                } 
     446                if (!ss_wrapper) { 
     447#ifdef F_SETLK 
     448                        lock.l_type = F_UNLCK; 
     449                        fcntl(lockfd, F_SETLK, &lock); 
     450#else 
     451                        flock(lockfd, LOCK_UN); 
     452#endif 
     453                        close(lockfd); 
     454                        //xmlCleanupParserr(); 
     455                        Xml_UseAllocationFunctions(); 
     456                        goto error; 
     457                } 
     458        } else { 
     459                if (!FASTXSL_G(nostat)) { 
     460                        if (ss_wrapper->mtime != sb.st_mtime) { 
     461                                ShmCache_UseAllocationFunctions(); 
     462inshm = 1; 
     463                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     464inshm = 0; 
     465                                Xml_UseAllocationFunctions(); 
     466                                ss_wrapper = SS_Wrapper_Alloc(FASTXSL_SHARED_ALLOC TSRMLS_CC); 
     467                                if(ss_wrapper) { 
     468                                        int rv; 
     469                                        ss_wrapper->alloc_type = FASTXSL_SHMALLOC; 
     470                                        ss_wrapper->data_type = FASTXSL_STYLESHEET; 
     471                                        func = xmlXPathFunctionLookup(ctxt->context, (const xmlChar *)"document"); 
     472                                        ShmCache_UseAllocationFunctions(); 
     473inshm = 1; 
     474                                        FASTXSL_G(tmp_allocated_size) = 0; 
     475                                        func(ctxt, nargs); 
     476                                        ss_wrapper->data.op = ctxt->value; 
     477                                        valuePop(ctxt); 
     478                                        popped = 1; 
     479inshm = 0; 
     480                                        Xml_UseAllocationFunctions(); 
     481                                        ss_wrapper->mtime = sb.st_mtime; 
     482                                        ss_wrapper->allocsize = FASTXSL_G(tmp_allocated_size); 
     483                                        mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     484                                        rv = fl_hash_add(FASTXSL_G(cache)->table, ss_filename, ss_filename_len, ss_wrapper); 
     485                                        mm_unlock(FASTXSL_G(cache)->mm); 
     486                                        if(rv == 0) { 
     487                                                /* we failed */ 
     488                                                php_ss_wrapper *fallback; 
     489                                                mm_lock(FASTXSL_G(cache)->mm, MM_LOCK_RD); 
     490                                                fallback = fl_hash_find(FASTXSL_G(cache)->table, ss_filename, ss_filename_len); 
     491                                                mm_unlock(FASTXSL_G(cache)->mm); 
     492                                                if(fallback && fallback->data_type == FASTXSL_XPATHOBJ) { 
     493                                                        ShmCache_UseAllocationFunctions(); 
     494inshm = 1; 
     495                                                        ShmCache_XPathObject_Free(ss_wrapper); 
     496inshm = 0; 
     497                                                        Xml_UseAllocationFunctions(); 
     498                                                        ss_wrapper = fallback; 
     499                                                } else { 
     500                                                } 
     501                                        } else { 
     502                                        } 
     503                                } 
     504                                //xmlCleanupParserr(); 
     505                                if (!ss_wrapper) { 
     506#ifdef F_SETLK 
     507                                        lock.l_type = F_UNLCK; 
     508                                        fcntl(lockfd, F_SETLK, &lock); 
     509#else 
     510                                        flock(lockfd, LOCK_UN); 
     511#endif 
     512                                        close(lockfd); 
     513                                        goto error; 
     514                                } 
     515                        } 
     516                } 
     517        } 
     518        ss_wrapper->hits++; 
     519        //xmlCleanupParserr(); 
     520        Xml_UseAllocationFunctions(); 
     521#ifdef F_SETLK 
     522        lock.l_type = F_UNLCK; 
     523        fcntl(lockfd, F_SETLK, &lock); 
     524#else 
     525        flock(lockfd, LOCK_UN); 
     526#endif 
     527        close(lockfd); 
     528 
     529        if(!popped) valuePop(ctxt); 
     530        valuePush(ctxt, xmlXPathObjectCopy(ss_wrapper->data.op)); 
     531        return; 
     532error: 
     533        ctxt->error = XPATH_INVALID_TYPE; 
     534        return; 
     535
     536/* }}} */ 
    305537#endif 
    306538 
     
    313545        wrapper->alloc_type = FASTXSL_PRMALLOC; 
    314546 
    315         wrapper->ss = xsltParseStylesheetFile((xmlChar *)filename); 
    316         if (!wrapper->ss) { 
     547        wrapper->data.ss = xsltParseStylesheetFile((xmlChar *)filename); 
     548        wrapper->data_type = FASTXSL_STYLESHEET; 
     549        if (!wrapper->data.ss) { 
    317550                return NULL; 
    318551        } 
     
    329562PrmCache_Stylesheet_Free(php_ss_wrapper *wrapper TSRMLS_DC) 
    330563{ 
    331         if (wrapper->ss) { 
    332                 xsltFreeStylesheet(wrapper->ss); 
    333         } 
    334         free(wrapper); 
     564        if (wrapper->data_type == FASTXSL_STYLESHEET) { 
     565                if (wrapper->data.ss) { 
     566                        xsltFreeStylesheet(wrapper->data.ss); 
     567                } 
     568                free(wrapper); 
     569        } 
    335570} 
    336571 
    337572static void 
    338 PrmCache_Stylesheet_Delete(char *filename, size_t filename_len TSRMLS_DC) 
     573PrmCache_XPathObject_Free(php_ss_wrapper *wrapper TSRMLS_DC) 
     574
     575        if (wrapper->data_type == FASTXSL_XPATHOBJ) { 
     576                if (wrapper->data.op) { 
     577                        xmlXPathFreeObject(wrapper->data.op); 
     578                } 
     579                free(wrapper); 
     580        } 
     581
     582 
     583static void 
     584PrmCache_Document_Delete(char *filename, size_t filename_len TSRMLS_DC) 
    339585{ 
    340586        php_ss_wrapper *wrapper; 
     
    343589        if (wrapper) { 
    344590                fl_hash_delete(FASTXSL_G(cache)->prmtable, filename, filename_len); 
    345                 PrmCache_Stylesheet_Free(wrapper TSRMLS_CC); 
     591                switch(wrapper->data_type) { 
     592                        case FASTXSL_STYLESHEET: 
     593                                PrmCache_Stylesheet_Free(wrapper TSRMLS_CC); 
     594                                break; 
     595                        case FASTXSL_XPATHOBJ: 
     596                                PrmCache_XPathObject_Free(wrapper TSRMLS_CC); 
     597                                break; 
     598                        default: 
     599                                break; 
     600                } 
    346601        } 
    347602} 
     
    439694        wrapper->alloc_type = FASTXSL_PRMALLOC; 
    440695        Xml_UseAllocationFunctions(); 
    441         wrapper->ss = xsltParseStylesheetFile((xmlChar*)filename); 
    442         if (!wrapper->ss) { 
     696        wrapper->data.ss = xsltParseStylesheetFile((xmlChar*)filename); 
     697        if (!wrapper->data.ss) { 
    443698                RETURN_FALSE; 
    444699        } 
     
    551806PHP_FUNCTION(fastxsl_shmcache_transform) 
    552807{ 
     808        xsltTransformContextPtr ctxt; 
    553809        char            **parameters = NULL; 
    554810        php_xd_wrapper   *xd_wrapper; 
     
    595851                        ShmCache_UseAllocationFunctions(); 
    596852inshm = 1; 
    597                         ShmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     853                        ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    598854inshm = 0; 
    599855                        Xml_UseAllocationFunctions(); 
     
    640896                                ShmCache_UseAllocationFunctions(); 
    641897inshm = 1; 
    642                                 ShmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     898                                ShmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    643899                                ss_wrapper = ShmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime TSRMLS_CC); 
    644900inshm = 0; 
     
    670926#endif 
    671927        close(lockfd); 
    672         result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
    673                         (const char **) parameters); 
    674  
     928 
     929        ctxt = xsltNewTransformContext(ss_wrapper->data.ss, xd_wrapper->xd); 
     930#ifdef FASTXSL_MM 
     931        xmlXPathRegisterFunc(ctxt->xpathCtxt, (const xmlChar *) "cached_document", 
     932                                fastxsl_CachedDocumentFunction); 
     933#endif 
     934        result_wrapper->xd = xsltApplyStylesheetUser(ss_wrapper->data.ss, xd_wrapper->xd,  
     935                        (const char **) parameters, NULL, NULL, ctxt); 
     936        xsltFreeTransformContext(ctxt); 
    675937         
    676938        if (parameters)  
     
    718980        if (!FASTXSL_G(nostat)) { 
    719981                if (stat(ss_filename, &sb) == -1) { 
    720                         PrmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     982                        PrmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    721983                        _XD_Wrapper_Dtor(result_wrapper); 
    722984                        free(parameters); 
     
    7381000                if (!FASTXSL_G(nostat)) { 
    7391001                        if (ss_wrapper->mtime != sb.st_mtime) { 
    740                                 PrmCache_Stylesheet_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
     1002                                PrmCache_Document_Delete(ss_filename, ss_filename_len TSRMLS_CC); 
    7411003                                ss_wrapper = PrmCache_Stylesheet_ParseAndStore(ss_filename, ss_filename_len, sb.st_mtime TSRMLS_CC); 
    7421004                                if (!ss_wrapper) { 
     
    7491011        } 
    7501012        ss_wrapper->hits++; 
    751         result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
     1013        result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->data.ss, xd_wrapper->xd,  
    7521014                        (const char **) parameters); 
    7531015        ////xmlCleanupParserr(); 
     
    7931055        result_wrapper = XD_Wrapper_Alloc(); 
    7941056        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
    795         result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
     1057        result_wrapper->xd = xsltApplyStylesheet(ss_wrapper->data.ss, xd_wrapper->xd,  
    7961058                        (const char **) parameters); 
    7971059        if (parameters)  
     
    8491111        result_wrapper->alloc_type = FASTXSL_PRMALLOC; 
    8501112 
    851         result_wrapper->xd = xsltProfileStylesheet(ss_wrapper->ss, xd_wrapper->xd,  
     1113        result_wrapper->xd = xsltProfileStylesheet(ss_wrapper->data.ss, xd_wrapper->xd,  
    8521114                        (const char **) parameters, dbgprof); 
    8531115        if (parameters)  
     
    8851147                        le_fastxsl_document); 
    8861148 
    887         xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->ss); 
     1149        xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->data.ss); 
    8881150 
    8891151        if (result) { 
     
    9231185        } 
    9241186        ss_wrapper->hits++; 
    925         xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->ss); 
     1187        xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->data.ss); 
    9261188        if (result) { 
    9271189                RETVAL_STRINGL((char *) result, length, 1); 
     
    9591221        } 
    9601222        ss_wrapper->hits++; 
    961         xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->ss); 
     1223        xsltSaveResultToString(&result, &length, xd_wrapper->xd, ss_wrapper->data.ss); 
    9621224         
    9631225        if (result) { 
     
    10151277_SS_Wrapper_Dtor(php_ss_wrapper *wrapper) 
    10161278{ 
    1017         if(wrapper->ss) { 
     1279        if(wrapper->data.ss) { 
    10181280                if(wrapper->alloc_type == FASTXSL_SHMALLOC) { 
    10191281                        //xmlCleanupParserr(); 
     
    10231285                } 
    10241286                inshm = 1; 
    1025                 xsltFreeStylesheet(wrapper->ss); 
     1287                xsltFreeStylesheet(wrapper->data.ss); 
    10261288                inshm = 0; 
    10271289                if(wrapper->alloc_type == FASTXSL_SHMALLOC) { 
     
    13411603                                           fastxsl_ext_function); 
    13421604        } 
     1605        xsltRegisterExtModuleFunction ((const xmlChar *) "cached_document", 
     1606                                   (const xmlChar *) "http://php.net/fastxsl/cached_document", 
     1607                                   fastxsl_CachedDocumentFunction); 
    13431608        //xmlCleanupParserr(); 
    13441609inshm = 0;