/*###################################################################################
#
#   Embperl - Copyright (c) 1997-2008 Gerald Richter / ecos gmbh  www.ecos.de
#   Embperl - Copyright (c) 2008-2015 Gerald Richter
#   Embperl - Copyright (c) 2015-2023 actevy.io
#
#   You may distribute under the terms of either the GNU General Public
#   License or the Artistic License, as specified in the Perl README file.
#   For use with Apache httpd and mod_perl, see also Apache copyright.
#
#   THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
#   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
#   WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#
###################################################################################*/
#include "ep.h"
#include "epmacro.h"
#include "ep_xs_typedefs.h"
#include "ep_xs_sv_convert.h"
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* Provider_New                                                             */
/*                                                                          */
/*! 
*   \_en
*   Creates a provider. 
*
*   @note   This function should not be called directly, but from another
*           ProviderXXX_New function
*   
*   @param  r               Embperl request record
*   @param  nSize           Size of provider struct
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*                               source      Sourcetext provider
*   @param  pParam          Parameter Hash
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neuen Provider.
*
*   @note   Diese Funktion sollte nicht direkt aufgerufen werden, sondern
*           von einer anderen ProviderXXX_New Funktion aus
*  
*   @param  r               Embperl request record
*   @param  nSize           Größer der provider struct
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pParam          Parameter Hash
*                               source      Quellentext provider
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int Provider_New            (/*in*/ req *              r,
                             /*in*/ size_t             nSize,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pParam)
    {
    epTHX_
    tProvider *     pNew = (tProvider *)cache_malloc (r, nSize) ;
     
    if (!pNew)
        return rcOutOfMemory ;
    memset (pNew, 0, nSize) ;
    pNew -> pCache             = pItem ;
    pNew -> pProviderClass     = pProviderClass ;
    pNew -> sOutputType        = pProviderClass -> sOutputType ;
    pItem -> pProvider = (tProvider *)pNew ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* Provider_AddDependOne                                                    */
/*                                                                          */
/*! 
*   \_en
*   Adds another dependency provider to a new provider. If only a string
*   is given for the dependend provider the fMatch functions of the
*   provider classes are called until a provider class is found.  
*
*   @note   This function should not be called directly, but from another
*           ProviderXXX_New function
*   
*   @param  r               Embperl request record
*   @param  nSize           Size of provider struct
*   @param  sSourceName     Name of the element in pParam that holds the source
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Fügt einen neuen Abhänigkeit für einen neuen Provider.
*   Wird nur eine Zeichenkette als Abhänigkeit übergeben, werden der Reihe
*   nach die fMatch Funktionen der Providerklassen aufgerufen, bis eine
*   passende Klasse gefunden wurde.
*
*   @note   Diese Funktion sollte nicht direkt aufgerufen werden, sondern
*           von einer anderen ProviderXXX_New Funktion aus
*  
*   @param  r               Embperl request record
*   @param  nSize           Größer der provider struct
*   @param  sSourceName     Name des Elements in pParam welches die Quelle enthält
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int Provider_AddDependOne   (/*in*/ req *              r,
                             /*in*/ tProvider *        pProvider,
                             /*in*/ const char *       sSourceName,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    epTHX_
    int          rc ;
    SV *         pSourceParam ;
     
    tCacheItem * pSubCache  ;
     
    pSourceParam = GetHashValueSV (r, pProviderParam, sSourceName) ;
    if (pSourceParam)
        {
        if ((rc = Cache_New (r, pSourceParam, -1, 0, &pSubCache)) != ok)
            {
            strcpy (r -> errdat2, sSourceName) ;
            return rc ;
            }
        }
    else if (pParam)
        {
        if ((rc = Cache_New (r, pParam, nParamIndex, 0, &pSubCache)) != ok)
            {
            strcpy (r -> errdat2, sSourceName) ;
            return rc ;
            }
        }
    else
        {
        strncpy (r -> errdat1, sSourceName, sizeof (r -> errdat1) - 1) ;
        strncpy (r -> errdat2, pItem -> sKey, sizeof (r -> errdat2) - 1) ;
         
        return rcMissingParam ;
        }
    if ((rc = Cache_AddDependency (r, pItem, pSubCache)) != ok)
        return rc ;
     
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* Provider_NewDependOne                                                    */
/*                                                                          */
/*! 
*   \_en
*   Creates a provider which depends on another provider. If only a string
*   is given for the dependend provider the fMatch functions of the
*   provider classes are called until a provider class is found.  
*
*   @note   This function should not be called directly, but from another
*           ProviderXXX_New function
*   
*   @param  r               Embperl request record
*   @param  nSize           Size of provider struct
*   @param  sSourceName     Name of the element in pParam that holds the source
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is a AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neuen Provider der von einem anderem Provider abhängt.
*   Wird nur eine Zeichenkette als Abhänigkeit übergeben, werden der Reihe
*   nach die fMatch Funktionen der Providerklassen aufgerufen, bis eine
*   passende Klasse gefunden wurde.
*
*   @note   Diese Funktion sollte nicht direkt aufgerufen werden, sondern
*           von einer anderen ProviderXXX_New Funktion aus
*  
*   @param  r               Embperl request record
*   @param  nSize           Größer der provider struct
*   @param  sSourceName     Name des Elements in pParam welches die Quelle enthält
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int Provider_NewDependOne   (/*in*/ req *              r,
                             /*in*/ size_t             nSize,
                             /*in*/ const char *       sSourceName,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    int          rc ;
     
    if ((rc = Provider_New (r, nSize, pItem, pProviderClass, pProviderParam)) != ok)
        return rc ;
    if ((rc = Provider_AddDependOne (r, pItem -> pProvider, sSourceName, pItem, pProviderClass, pProviderParam, pParam, nParamIndex)) != ok)
        return rc ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*!         Provider that reads input from file                             */
/*                                                                          */
typedef struct tProviderFile
    {
    tProvider           Provider ;
    const char *        sFilename ;         /**< Filename */
    } tProviderFile ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderFile_New                                                         */
/*                                                                          */
/*! 
*   \_en
*   Creates a new file provider and fills it with data from the hash pParam
*   The resulting provider is put into the cache structure
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               filename        filename
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neue Provider der daten aus Dateien ließt. Der ein Zeiger
*   auf den resultierenden Provider wird in die Cachestrutr eingefügt
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               filename        Dateiname
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderFile_New (/*in*/ req *              r,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    epTHX_
    int          rc ;
    tProviderFile * pNew  ;
    char *          sFilename ;
     
    if ((rc = Provider_New (r, sizeof(tProviderFile), pItem, pProviderClass, pProviderParam)) != ok)
        return rc ;
    pNew = (tProviderFile *)pItem -> pProvider ;
    sFilename = GetHashValueStr (aTHX_ pProviderParam, "filename",  r -> Component.Param.sInputfile) ;
    pNew -> sFilename = embperl_PathSearch(r, NULL, sFilename, -1) ;
    if (!pNew -> sFilename)
        {
        strncpy (r -> errdat1, sFilename, sizeof (r -> errdat1) - 1) ;
        strncpy (r -> errdat2, embperl_PathStr(r, sFilename), sizeof (r -> errdat2) - 1) ;
        return rcNotFound ;
        }
    pItem -> sExpiresFilename           = strdup (pNew -> sFilename) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderFile_AppendKey                                                   */
/*                                                                          */
/*! 
*   \_en
*   Append it's key to the keystring. If it depends on anything it must 
*   call Cache_AppendKey for any dependency.
*   The file provider appends the filename
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               filename        filename
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Hängt ein eigenen Schlüssel an den Schlüsselstring an. Wenn irgednwelche
*   Abhänigkeiten bestehen, muß Cache_AppendKey für alle Abhänigkeiten aufgerufen 
*   werden.
*   Der File Provider hängt den Dateinamen an.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               filename        Dateiname
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderFile_AppendKey (/*in*/ req *              r,
                                   /*in*/ tProviderClass *   pProviderClass,
                                   /*in*/ HV *               pProviderParam,
                                   /*in*/ SV *               pParam,
                                   /*in*/ IV                 nParamIndex,
                                   /*i/o*/ SV *              pKey)
    {
    epTHX_
    const char * sFilename  ;
    const char * sAbsFilename  ;
    sFilename = GetHashValueStr (aTHX_ pProviderParam, "filename",  r -> Component.Param.sInputfile) ;
    sAbsFilename = embperl_PathSearch(r, r -> pPool, (char *)sFilename, -1) ;
    if (!sAbsFilename)
        {
        strncpy (r -> errdat1, sFilename, sizeof (r -> errdat1) - 1) ;
        strncpy (r -> errdat2, embperl_PathStr(r, sFilename), sizeof (r -> errdat2) - 1) ;
        return rcNotFound ;
        }
     
    sv_catpvf (pKey, "*file:%s", sAbsFilename) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderFile_GetContentSV                                                */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The file provider reads the whole file into memory
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der File Provider ließt die komplette Datei.
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @param  bUseCache       Gesetzt wenn der Inhalt nicht neu berechnet werden soll
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderFile_GetContentSV (/*in*/ req *             r,
                             /*in*/ tProvider *     pProvider,
                             /*in*/ SV * *              pData,
                             /*in*/ bool                bUseCache)
    {
    epTHX_
    size_t nSize = pProvider -> pCache -> FileStat.st_size ;
    int rc = ok ;
     
    r -> Component.sSourcefile = (char *)((tProviderFile *)pProvider) -> sFilename ;
    embperl_SetCWDToFile (r, r -> Component.sSourcefile) ;
     
    if (!bUseCache)
        {
        rc  = ReadHTML(r, (char *)((tProviderFile *)pProvider) -> sFilename, &nSize, pData) ;
     
        if (rc == ok)
            {
            SvREFCNT_inc (*pData) ;
            r -> Component.pBuf = SvPVX (*pData) ;
            r -> Component.pEndPos = r -> Component.pBuf + nSize ;
            r -> Component.pCurrPos = r -> Component.pBuf ;
            }
        }
    return rc ;
    }
/* ------------------------------------------------------------------------ */
tProviderClass ProviderClassFile = 
    {   
    "text/*", 
    &ProviderFile_New, 
    &ProviderFile_AppendKey, 
    NULL,
    &ProviderFile_GetContentSV,
    NULL,
    NULL,
    NULL,
    } ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*!         Provider that reads input from memory                           */
/*                                                                          */
typedef struct tProviderMem
    {
    tProvider           Provider ;
    SV *                pSource ;           /**< Source */
    const char *        sName ;             /**< Name of memory provider */
    time_t              nLastModified ;     /**< Last modified */
    time_t              nLastModifiedWhileGet ;     /**< Last modified during last get */
    } tProviderMem ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderMem_New                                                          */
/*                                                                          */
/*! 
*   \_en
*   Creates a new file provider and fills it with data from the hash pParam
*   The resulting provider is put into the cache structure
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               name          name (used to compare mtime)
*                               source        source text
*                               mtime         last modification time
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neue Provider der daten aus Dateien ließt. Der ein Zeiger
*   auf den resultierenden Provider wird in die Cachestrutr eingefügt
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               name        Name (wird benutzt um mtime zu vergelichen)
*                               source      Quellentext
*                               mtime       Zeitpunkt der letzten Änderung
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderMem_New (/*in*/ req *              r,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    epTHX_
    int          rc ;
    tProviderMem * pNew  ;
     
    if ((rc = Provider_New (r, sizeof(tProviderMem), pItem, pProviderClass, pProviderParam)) != ok)
        return rc ;
    pNew = (tProviderMem *)pItem -> pProvider ;
    pNew -> sName                   = GetHashValueStrDupA (aTHX_ pProviderParam, "name",  r -> Component.Param.sInputfile) ;
    /*
    pNew -> nLastModified           = GetHashValueUInt       (pParam, "mtime", 0) ;
    pSrc = GetHashValueSV     (r, pParam, "source") ;
    if (!pSrc)
        pNew -> pSource = NULL ;
    else if (SvROK(pSrc))
        pNew -> pSource = SvREFCNT_inc (SvRV(pSrc)) ;
    else
        pNew -> pSource = SvREFCNT_inc (pSrc) ;
    */
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderMem_AppendKey                                                    */
/*                                                                          */
/*! 
*   \_en
*   Append it's key to the keystring. If it depends on anything it must 
*   call Cache_AppendKey for any dependency.
*   The file provider appends the filename
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               name          name (used to compare mtime)
*                               source        source text
*                               mtime         last modification time
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Hängt ein eigenen Schlüssel an den Schlüsselstring an. Wenn irgednwelche
*   Abhänigkeiten bestehen, muß Cache_AppendKey für alle Abhänigkeiten aufgerufen 
*   werden.
*   Der File Provider hängt den Dateinamen an.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               name        Name (wird benutzt um mtime zu vergelichen)
*                               source      Quellentext
*                               mtime       Zeitpunkt der letzten Änderung
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderMem_AppendKey (/*in*/ req *              r,
                                  /*in*/ tProviderClass *   pProviderClass,
                                  /*in*/ HV *               pProviderParam,
                                  /*in*/ SV *               pParam,
                                  /*in*/ IV                 nParamIndex,
                                  /*i/o*/ SV *              pKey)
    {
    epTHX_
    const char * sName = GetHashValueStr (aTHX_ pProviderParam, "name",  r -> Component.Param.sInputfile) ;
    sv_catpvf (pKey, "*memory:%s", sName) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderMem_UpdateParam                                                  */
/*                                                                          */
/*! 
*   \_en
*   Update the parameter of the provider
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider record
*   @param  pParam          Parameter Hash
*                               name        name 
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Aktualisiert die Parameter des Providers
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider record
*   @param  pParam          Parameter Hash
*                               name        name
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderMem_UpdateParam(/*in*/ req *              r,
                                   /*in*/ tProvider *        pProvider,
                                   /*in*/ HV *               pParam)
    {
    epTHX_
    SV           * pSrc ;
    if (((tProviderMem *)pProvider) -> pSource)
        SvREFCNT_dec (((tProviderMem *)pProvider) -> pSource) ;
    ((tProviderMem *)pProvider) -> nLastModified  = GetHashValueUInt (r, pParam, "mtime", r -> Component.Param.nMtime) ;
     
    pSrc = GetHashValueSV     (r, pParam, "source") ;
    if (!pSrc)
        ((tProviderMem *)pProvider) -> pSource = SvROK(r -> Component.Param.pInput)?SvREFCNT_inc (SvRV(r -> Component.Param.pInput)):NULL ;
    else if (SvROK(pSrc))
        ((tProviderMem *)pProvider) -> pSource = SvREFCNT_inc (SvRV(pSrc)) ;
    else
        ((tProviderMem *)pProvider) -> pSource = SvREFCNT_inc (pSrc) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderMem_GetContentSV                                                 */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The file provider reads the whole file into memory
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der File Provider ließt die komplette Datei.
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @param  bUseCache       Gesetzt wenn der Inhalt nicht neu berechnet werden soll
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderMem_GetContentSV (/*in*/ req *             r,
                             /*in*/ tProvider *     pProvider,
                             /*in*/ SV * *              pData,
                             /*in*/ bool                bUseCache)
    {
    epTHX_
    r -> Component.sSourcefile = ep_pstrcat(r -> pPool, "MEM:", (char *)((tProviderMem *)pProvider) -> sName, NULL) ;
         
    if (!bUseCache)
        {
        ((tProviderMem *)pProvider) -> nLastModifiedWhileGet = ((tProviderMem *)pProvider) -> nLastModified ; 
        if ((*pData = SvREFCNT_inc(((tProviderMem *)pProvider) -> pSource)))
            {
            SvREFCNT_inc (*pData) ;
            if (SvPOK(*pData))
                {
                r -> Component.pBuf = SvPVX (*pData) ;
                r -> Component.pEndPos = r -> Component.pBuf + SvCUR(*pData) ;
                r -> Component.pCurrPos = r -> Component.pBuf ;
                }
            else
                {
                r -> Component.pBuf = "" ;
                r -> Component.pEndPos = r -> Component.pBuf  ;
                r -> Component.pCurrPos = r -> Component.pBuf ;
                }    
            }
        }
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderMem_FreeContent                                          */
/*                                                                          */
/*! 
*   \_en
*   Free the cached data
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Gibt die gecachten Daten frei
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int ProviderMem_FreeContent(/*in*/ req *             r,
                                /*in*/ tCacheItem * pItem)
    {
    epTHX_
    tProviderMem * pProvider = (tProviderMem *)(pItem -> pProvider) ;
    if (pItem -> pSVData && pProvider -> pSource)
        {
        SvREFCNT_dec (pProvider -> pSource) ;
        pProvider ->  pSource = NULL ;
        }
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderMem_IsExpired                                                    */
/*                                                                          */
/*! 
*   \_en
*   Check if content of provider is expired
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider 
*   @return                 TRUE if expired
*   \endif                                                                       
*
*   \_de                                                                           
*   Prüft ob der Inhalt des Providers noch gültig ist.
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider 
*   @return                 WAHR wenn abgelaufen
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderMem_IsExpired  (/*in*/ req *              r,
                                   /*in*/ tProvider *        pProvider)
    {
    return ((tProviderMem *)pProvider) -> nLastModified == 0 || ((tProviderMem *)pProvider) -> nLastModified != ((tProviderMem *)pProvider) -> nLastModifiedWhileGet ; 
    }
/* ------------------------------------------------------------------------ */
tProviderClass ProviderClassMem = 
    {   
    "text/*", 
    &ProviderMem_New, 
    &ProviderMem_AppendKey, 
    &ProviderMem_UpdateParam, 
    &ProviderMem_GetContentSV,
    NULL,
    NULL,
    &ProviderMem_FreeContent,
    &ProviderMem_IsExpired, 
    } ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*!         Provider for Embperl parser                                     */
/*                                                                          */
typedef struct tProviderEpParse
    {
    tProvider           Provider ;
    tTokenTable *       pTokenTable ;
    } tProviderEpParse ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpParse_New                                                      */
/*                                                                          */
/*! 
*   \_en
*   Creates a new Embperl parser provider and fills it with data from the 
*   hash pParam. The resulting provider is put into the cache structure
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neue Provider für den Embperl Parser. Der ein Zeiger
*   auf den resultierenden Provider wird in die Cachestrutr eingefügt
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpParse_New (/*in*/ req *              r,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    epTHX_
    dSP ;
    int          rc ;
    int          num ;
    SV * pSyntaxSV ;
    SV * pSyntaxRV = NULL ;
    SV * pSyntaxPV ;
    tTokenTable * pSyntax ;
    const char * sSyntax = GetHashValueStr (aTHX_ pProviderParam, "syntax", r -> Component.Config.sSyntax) ;
    if ((rc = Provider_NewDependOne (r, sizeof(tProviderEpParse), "source", pItem, pProviderClass, pProviderParam, pParam, nParamIndex)) != ok)
        return rc ;
    pSyntaxPV = sv_2mortal(newSVpv ((char *)sSyntax, 0)) ;
    SPAGAIN ;
    PUSHMARK(sp);
    XPUSHs(pSyntaxPV);                
    PUTBACK;                        
    num = perl_call_pv ("Embperl::Syntax::GetSyntax", G_SCALAR /*| G_EVAL*/) ;
    tainted = 0 ;
    SPAGAIN;                        
    if (num == 1)
        pSyntaxRV = POPs ;
    PUTBACK;
    if (num != 1 || !SvROK (pSyntaxRV) || !(pSyntaxSV = SvRV(pSyntaxRV)) || SvTYPE((SV *)pSyntaxSV) != SVt_PVHV)
        {
        strncpy (r -> errdat1, sSyntax, sizeof (r -> errdat1) - 1) ;
        return rcUnknownSyntax ;
        }
     
    pSyntax = epxs_sv2_Embperl__Syntax(pSyntaxRV) ;
    ((tProviderEpParse *)pItem -> pProvider) -> pTokenTable = pSyntax ;
     
    pItem -> bCache = FALSE ; /* do not cache, because it's cached by the compiler */
     
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpParse_AppendKey                                                */
/*                                                                          */
/*! 
*   \_en
*   Append it's key to the keystring. If it depends on anything it must 
*   call Cache_AppendKey for any dependency.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               syntax      Syntax
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Hängt ein eigenen Schlüssel an den Schlüsselstring an. Wenn irgednwelche
*   Abhänigkeiten bestehen, muß Cache_AppendKey für alle Abhänigkeiten aufgerufen 
*   werden.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               syntax      Syntax
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpParse_AppendKey (/*in*/ req *              r,
                                      /*in*/ tProviderClass *   pProviderClass,
                                      /*in*/ HV *               pProviderParam,
                                      /*in*/ SV *               pParam,
                                      /*in*/ IV                 nParamIndex,
                                      /*i/o*/ SV *              pKey)
    {
    epTHX_
    int          rc ;
    const char * sSyntax = GetHashValueStr (aTHX_ pProviderParam, "syntax", r -> Component.Config.sSyntax) ;
     
    if ((rc = Cache_AppendKey (r, pProviderParam, "source", pParam, nParamIndex, pKey)) != ok)
        return rc;
    sv_catpvf (pKey, "*epparse:%s", sSyntax) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpParse_GetContentIndex                                          */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The Embperl parser provider parsers the source and generates a DomTree
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der Embperl Parser Provider parsest die Quelle und erzeugt einen DomTree
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @param  bUseCache       Gesetzt wenn der Inhalt nicht neu berechnet werden soll
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpParse_GetContentIndex (/*in*/ req *             r,
                                            /*in*/ tProvider *       pProvider,
                                            /*in*/ tIndex *          pData,
                                            /*in*/ bool              bUseCache)
    {
    epTHX_
    int    rc ;
    char * p ;
    STRLEN len ;
    SV *   pSource ;
    tCacheItem * pFileCache = Cache_GetDependency(r, pProvider -> pCache, 0) ;
    if ((rc = Cache_GetContentSV (r, pFileCache, &pSource, bUseCache)) != ok)
        return rc ;
         
    r -> Component.pTokenTable = ((tProviderEpParse *)pProvider) -> pTokenTable ;
    if (!bUseCache)
        {
        p   = SvPV (pSource, len) ;
        if ((rc =  embperl_Parse (r, p, len, pData)) != ok)
            return rc ;
        }
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpParse_FreeContent                                              */
/*                                                                          */
/*! 
*   \_en
*   Free the cached data
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Gibt die gecachten Daten frei
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int ProviderEpParse_FreeContent(/*in*/ req *             r,
                                /*in*/ tCacheItem * pItem)
    {
    /*
    Do not delete, because it's same dom tree as compiler 
    if (pItem -> xData)
        return DomTree_delete (r -> pApp, DomTree_self(pItem -> xData)) ;
    */
    return ok ;
    }
/* ------------------------------------------------------------------------ */
tProviderClass ProviderClassEpParse = 
    {   
    "X-Embperl/DomTree", 
    &ProviderEpParse_New, 
    &ProviderEpParse_AppendKey, 
    NULL,
    NULL,
    NULL,
    &ProviderEpParse_GetContentIndex,
    &ProviderEpParse_FreeContent,
    NULL,
    } ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*!         Provider for Embperl compiler                                   */
/*                                                                          */
typedef struct tProviderEpCompile
    {
    tProvider           Provider ;
    SV *                pSVData ;
    char *              sPackage ;
    char *              sMainSub ;
    } tProviderEpCompile ;
static int  nPackageCount = 1 ;
static perl_mutex PackageCountMutex ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpCompile_New                                                    */
/*                                                                          */
/*! 
*   \_en
*   Creates a new Embperl compile provider and fills it with data from the 
*   hash pParam. The resulting provider is put into the cache structure
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               package     Packagename
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neue Provider für den Embperl Compiler. Der ein Zeiger
*   auf den resultierenden Provider wird in die Cachestrutr eingefügt
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               package     Packagename
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpCompile_New (/*in*/ req *              r,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    epTHX_
    int          rc ;
    char *       sPackage ;
    char *       sMainSub ;
     
    if ((rc = Provider_NewDependOne (r, sizeof(tProviderEpCompile), "source", pItem, pProviderClass, pProviderParam, pParam, nParamIndex)) != ok)
        return rc ;
    /*if (r -> Config.bDebug)
        lprintf (r -> pApp,  "[%d]ep_acquire_mutex(PackageCountMutex)\n", r -> pThread -> nPid) ; */
    if ((sPackage = GetHashValueStrDupA (aTHX_ pProviderParam, "package", r -> Component.Config.sPackage))) 
        {
        int n ;
        ep_acquire_mutex(PackageCountMutex) ;
        n = nPackageCount++ ;
        ep_release_mutex(PackageCountMutex) ;
        ((tProviderEpCompile *)(pItem -> pProvider)) -> sPackage = sPackage ;
        sMainSub = ((tProviderEpCompile *)(pItem -> pProvider)) -> sMainSub = malloc (40) ;
        sprintf (sMainSub, "_ep_main%d", n) ;
        }
    else
        {
        int n ;
        ep_acquire_mutex(PackageCountMutex) ;
        n = nPackageCount++ ;
        ep_release_mutex(PackageCountMutex) ;
        sPackage = ((tProviderEpCompile *)(pItem -> pProvider)) -> sPackage = malloc (sizeof (EMBPERL_PACKAGE_STR) + 32) ;
        sprintf (sPackage, EMBPERL_PACKAGE_STR"::__%d", n) ;
        sMainSub = ((tProviderEpCompile *)(pItem -> pProvider)) -> sMainSub = malloc (40) ;
        sprintf (sMainSub, "_ep_main%d", n) ;
        }
    /*if (r -> Config.bDebug)
        lprintf (r -> pApp,  "[%d]ep_release_mutex(PackageCountMutex)\n", r -> pThread -> nPid) ; */
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpCompile_AppendKey                                              */
/*                                                                          */
/*! 
*   \_en
*   Append it's key to the keystring. If it depends on anything it must 
*   call Cache_AppendKey for any dependency.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               package     Packagename
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Hängt ein eigenen Schlüssel an den Schlüsselstring an. Wenn irgednwelche
*   Abhänigkeiten bestehen, muß Cache_AppendKey für alle Abhänigkeiten aufgerufen 
*   werden.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               package     Packagename
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpCompile_AppendKey (/*in*/ req *              r,
                                        /*in*/ tProviderClass *   pProviderClass,
                                        /*in*/ HV *               pProviderParam,
                                        /*in*/ SV *               pParam,
                                        /*in*/ IV                 nParamIndex,
                                        /*i/o*/ SV *              pKey)
    {
    epTHX_
    int          rc ;
    if ((rc = Cache_AppendKey (r, pProviderParam, "source", pParam, nParamIndex, pKey)) != ok)
        return rc;
    sv_catpvf (pKey, "*epcompile:%s", GetHashValueStr (aTHX_ pProviderParam, "package", r -> Component.Config.sPackage?r -> Component.Config.sPackage:"")) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpCompile_GetContentIndex                                        */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The Embperl compile provider compiles the source DomTRee and generates
*   a Perl program and a compiled DomTRee
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der Embperl Compile Provider überstzes den Quellen DOmTree und erzeugt
*   ein Perlprogramm und einen übersetzten DomTree
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @param  bUseCache       Gesetzt wenn der Inhalt nicht neu berechnet werden soll
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpCompile_GetContentIndex (/*in*/ req *             r,
                                            /*in*/ tProvider *         pProvider,
                                            /*in*/ tIndex *            pData,
                                            /*in*/ bool                bUseCache)
    {
    epTHX_
    int     rc ;
    tIndex  xSrcDomTree ;
    tCacheItem * pSrcCache ;
    SV *         pProg = NULL ;
    pSrcCache = Cache_GetDependency(r, pProvider -> pCache, 0) ;
    if ((rc = Cache_GetContentIndex (r, pSrcCache, &xSrcDomTree, bUseCache)) != ok)
        return rc ;
         
    r -> Component.sCurrPackage =  ((tProviderEpCompile *)(pProvider)) -> sPackage  ;
    r -> Component.sEvalPackage =  ((tProviderEpCompile *)(pProvider)) -> sPackage  ;
    r -> Component.nEvalPackage =  strlen (((tProviderEpCompile *)(pProvider)) -> sPackage)  ;
    r -> Component.sMainSub     =  ((tProviderEpCompile *)(pProvider)) -> sMainSub ;
     
    if (!bUseCache)
        {
        if ((rc =  embperl_Compile (r, xSrcDomTree, pData, &pProg )) != ok)
            {
            ((tProviderEpCompile *)pProvider) -> pSVData = NULL ;
            if (pProg)
                SvREFCNT_dec (pProg) ;
      
            Cache_FreeContent (r, pSrcCache) ; /* make sure we don't leave an invalid dom tree */
            return rc ;
            }
        ((tProviderEpCompile *)pProvider) -> pSVData = pProg ;
        }
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpCompile_GetContentIndex                                        */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The Embperl compile provider compiles the source DomTRee and generates
*   a Perl program and a compiled DomTRee
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der Embperl Compile Provider überstzes den Quellen DOmTree und erzeugt
*   ein Perlprogramm und einen übersetzten DomTree
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpCompile_GetContentSV  (/*in*/ req *             r,
                                            /*in*/ tProvider *       pProvider,
                                            /*in*/ SV * *            pData,
                                            /*in*/ bool              bUseCache)
    {
    epTHX_
    if (!bUseCache)
        *pData = SvREFCNT_inc (((tProviderEpCompile *)pProvider) -> pSVData) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpCompile_FreeContent                                            */
/*                                                                          */
/*! 
*   \_en
*   Free the cached data
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Gibt die gecachten Daten frei
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int ProviderEpCompile_FreeContent(/*in*/ req *             r,
                                /*in*/ tCacheItem * pItem)
    {
    epTHX_
    if (pItem -> xData)
        return DomTree_delete (r -> pApp, DomTree_self(pItem -> xData)) ;
    /*
    if (((tProviderEpCompile *)(pItem -> pProvider)) -> sPackage)
        free (((tProviderEpCompile *)(pItem -> pProvider)) -> sPackage) ;
    */
    return ok ;
    }
/* ------------------------------------------------------------------------ */
tProviderClass ProviderClassEpCompile = 
    {   
    "X-Embperl/DomTree", 
    &ProviderEpCompile_New, 
    &ProviderEpCompile_AppendKey, 
    NULL,
    &ProviderEpCompile_GetContentSV,
    NULL,
    &ProviderEpCompile_GetContentIndex,
    &ProviderEpCompile_FreeContent,
    NULL,
    } ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*!         Provider for Embperl Executer                                   */
/*                                                                          */
typedef struct tProviderEpRun
    {
    tProvider           Provider ;
    char *              sPackage ;
    } tProviderEpRun ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpRun_New                                                        */
/*                                                                          */
/*! 
*   \_en
*   Creates a new Embperl run provider and fills it with data from the 
*   hash pParam. The resulting provider is put into the cache structure
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neue Provider für den Embperl Executer. Der ein Zeiger
*   auf den resultierenden Provider wird in die Cachestrutr eingefügt
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpRun_New (/*in*/ req *              r,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    int          rc ;
     
    if ((rc = Provider_NewDependOne (r, sizeof(tProviderEpRun), "source", pItem, pProviderClass, pProviderParam, pParam, nParamIndex)) != ok)
        return rc ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpRun_AppendKey                                          */
/*                                                                          */
/*! 
*   \_en
*   Append it's key to the keystring. If it depends on anything it must 
*   call Cache_AppendKey for any dependency.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*                               cache_key   
*                               cache_key_options   
*                               cache_key_func   
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Hängt ein eigenen Schlüssel an den Schlüsselstring an. Wenn irgednwelche
*   Abhänigkeiten bestehen, muß Cache_AppendKey für alle Abhänigkeiten aufgerufen 
*   werden.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*                               cache_key   
*                               cache_key_options   
*                               cache_key_func   
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpRun_AppendKey (/*in*/ req *              r,
                                   /*in*/ tProviderClass *   pProviderClass,
                                      /*in*/ HV *               pProviderParam,
                                      /*in*/ SV *               pParam,
                                      /*in*/ IV                 nParamIndex,
                                   /*i/o*/ SV *              pKey)
    {
    epTHX_
    int          rc ;
    const char * sKey        = GetHashValueStr (aTHX_ pProviderParam, "cache_key", r -> Component.Config.sCacheKey) ;
    int          bKeyOptions = GetHashValueInt (aTHX_ pProviderParam, "cache_key_options", r -> Component.Config.bCacheKeyOptions) ;
    CV *         pKeyCV ; 
    if ((rc = Cache_AppendKey (r, pProviderParam, "source", pParam, nParamIndex, pKey)) != ok)
        return rc;
    sv_catpv (pKey, "*eprun:") ;
    if ((rc = GetHashValueCREF (r, pProviderParam, "cache_key_func", &pKeyCV)) != ok)
        return rc ;
     
    if (!pKeyCV)
        pKeyCV = r -> Component.Config.pCacheKeyFunc ;
    if (pKeyCV)
        {
        SV * pRet ;
        if ((rc = CallCV (r, "CacheKey", pKeyCV, 0, &pRet)) != ok)
            return rc ;
        if (pRet && SvOK(pRet))
            sv_catsv (pKey, pRet) ;
        }
     
    if ((bKeyOptions & ckoptPathInfo) && r -> Param.sPathInfo)
        sv_catpv (pKey, r -> Param.sPathInfo) ;
    if ((bKeyOptions & ckoptQueryInfo) && r -> Param.sQueryInfo)
        sv_catpv (pKey, r -> Param.sQueryInfo) ;
     
    if (sKey)
        sv_catpv (pKey, sKey) ;
     
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* embperl_PreExecute                                                       */
/*                                                                          */
/* Looks for vars/subs inside compiled document                             */
/*                                                                          */
/* ------------------------------------------------------------------------ */
static int embperl_PreExecute               (/*in*/  tReq *       r,
                                     /*in*/  tCacheItem * pCache,
                                     /*in*/  char *       sPackage)
    {
    epTHX_
    STRLEN      l ;
    SV *        pSV ;
    CV *        pCV ;
    SV *        pSVVar ;
     
    pSV = newSVpvf("%s::EXPIRES", sPackage) ;
    newSVpvf2(pSV) ;
    pCV = perl_get_cv (SvPV(pSV, l), 0) ;
    if (pCV)
        {
        SvREFCNT_dec (pCache -> pExpiresCV) ;
        pCache -> pExpiresCV = pCV ;
        SvREFCNT_inc (pCV) ;
        }    
    SvREFCNT_dec(pSV);
     
    pSV = newSVpvf("%s::EXPIRES", sPackage) ;
    newSVpvf2(pSV) ;
    pSVVar = perl_get_sv (SvPV(pSV, l), 0) ;
    if (pSVVar)
        {
        pCache -> nExpiresInTime = SvUV (pSVVar) ;
        }    
    SvREFCNT_dec(pSV);
     
    /*
    pSV = newSVpvf("%s::CACHE_KEY", r -> Component.sEvalPackage) ;
    newSVpvf2(pSV) ;
    pCV = perl_get_cv (SvPV(pSV, l), 0) ;
    if (pCV)
        {
        SvREFCNT_dec (pProcessor -> pCacheKeyCV) ;
        pProcessor -> pCacheKeyCV = pCV ;
        SvREFCNT_inc (pCV) ;
        }    
    SvREFCNT_dec(pSV);
     
    pSV = newSVpvf("%s::CACHE_KEY", r -> Component.sEvalPackage) ;
    newSVpvf2(pSV) ;
    pSVVar = perl_get_sv (SvPV(pSV, l), 0) ;
    if (pSVVar)
        {
        pProcessor -> sCacheKey = SvPV (pSVVar, l) ;
        }    
    SvREFCNT_dec(pSV);
    pSV = newSVpvf("%s::CACHE_KEY_OPTIONS", r -> Component.sEvalPackage) ;
    newSVpvf2(pSV) ;
    pSVVar = perl_get_sv (SvPV(pSV, l), 0) ;
    if (pSVVar)
        {
        pProcessor -> bCacheKeyOptions = SvIV (pSVVar) ;
        }    
    SvREFCNT_dec(pSV);
    */
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpRun_IsExpired                                                  */
/*                                                                          */
/*! 
*   \_en
*   Check if content of provider is expired
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider 
*   @return                 TRUE if expired
*   \endif                                                                       
*
*   \_de                                                                           
*   Prüft ob der Inhalt des Providers noch gültig ist.
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider 
*   @return                 WAHR wenn abgelaufen
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpRun_IsExpired  (/*in*/ req *              r,
                                   /*in*/ tProvider *        pProvider)
    {
    int rc ;
    bool bCache = pProvider -> pCache -> bCache ;
    if (!((tProviderEpRun *)(pProvider)) -> sPackage)
        return FALSE ;
    /* update cache parameters */
    if ((rc =  embperl_PreExecute (r, pProvider -> pCache, ((tProviderEpRun *)(pProvider)) -> sPackage)) != ok)
        {
        LogError (r, rc) ;
        }
    if (pProvider -> pCache -> nExpiresInTime || pProvider -> pCache -> pExpiresCV)
        pProvider -> pCache -> bCache = 1 ;
    else
        {
        pProvider -> pCache -> bCache = 0 ;
        if (bCache)
            Cache_FreeContent (r, pProvider -> pCache) ;
        return TRUE ;
        }
         
    return FALSE ; 
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpRun_UpdateParam                                                */
/*                                                                          */
/*! 
*   \_en
*   Update the parameter of the provider
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider record
*   @param  pParam          Parameter Hash
*                               name        name 
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Aktualisiert die Parameter des Providers
*   
*   @param  r               Embperl request record
*   @param  pProvider       Provider record
*   @param  pParam          Parameter Hash
*                               name        name
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpRun_UpdateParam(/*in*/ req *              r,
                                   /*in*/ tProvider *        pProvider,
                                   /*in*/ HV *               pParam)
    {
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpRun_GetContentIndex                                            */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The Embperl Run provider executes the compiled DomTree & Perl program
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der Embperl Run Provider führt den übersetzen DomTree und das Perlprogramm aus
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @param  bUseCache       Gesetzt wenn der Inhalt nicht neu berechnet werden soll
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpRun_GetContentIndex   (/*in*/ req *             r,
                                            /*in*/ tProvider *       pProvider,
                                            /*in*/ tIndex *          pData,
                                            /*in*/ bool              bUseCache)
    {
    int         rc ;
    tIndex      xSrcDomTree ;
    CV *        pCV ;
    tCacheItem * pSrcCache = Cache_GetDependency(r, pProvider -> pCache, 0) ;
    if ((rc = Cache_GetContentSvIndex (r, pSrcCache, (SV **)&pCV, &xSrcDomTree, bUseCache)) != ok)
        return rc ;
         
    if (!bUseCache || !*pData || !pProvider -> pCache -> bCache)
        {
        if ((rc =  embperl_Execute (r, xSrcDomTree, pCV, pData)) != ok)
            return rc ;
        ((tProviderEpRun *)(pProvider)) -> sPackage = ((tProviderEpCompile *)(pSrcCache -> pProvider)) -> sPackage ;
        /* update cache parameter from source */
        ProviderEpRun_IsExpired  (r, pProvider) ;
        }
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpRun_FreeContent                                        */
/*                                                                          */
/*! 
*   \_en
*   Free the cached data
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Gibt die gecachten Daten frei
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int ProviderEpRun_FreeContent(/*in*/ req *             r,
                                /*in*/ tCacheItem * pItem)
    {
    if (pItem -> xData)
        return DomTree_delete (r -> pApp, DomTree_self(pItem -> xData)) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
tProviderClass ProviderClassEpRun = 
    {   
    "X-Embperl/DomTree", 
    &ProviderEpRun_New, 
    &ProviderEpRun_AppendKey, 
    NULL, 
    NULL,
    NULL,
    &ProviderEpRun_GetContentIndex,
    &ProviderEpRun_FreeContent,
    &ProviderEpRun_IsExpired,
    } ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*!         Provider for Embperl DomTree to String converter                */
/*                                                                          */
typedef struct tProviderEpToString
    {
    tProvider           Provider ;
    } tProviderEpToString ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpToString_New                                                   */
/*                                                                          */
/*! 
*   \_en
*   Creates a new DomTree to String provider and fills it with data from the 
*   hash pParam. The resulting provider is put into the cache structure
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem which holds the output of the provider
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Erzeugt einen neue Provider für den Embperl zu Textkonverter. Der ein Zeiger
*   auf den resultierenden Provider wird in die Cachestrutr eingefügt
*   
*   @param  r               Embperl request record
*   @param  pItem           CacheItem welches die Ausgabe des Providers 
*                           speichert
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpToString_New (/*in*/ req *              r,
                             /*in*/ tCacheItem *       pItem,
                             /*in*/ tProviderClass *   pProviderClass,
                             /*in*/ HV *               pProviderParam,
                             /*in*/ SV *               pParam,
                             /*in*/ IV                 nParamIndex)
    {
    int          rc ;
     
    if ((rc = Provider_NewDependOne (r, sizeof(tProviderEpToString), "source", pItem, pProviderClass, pProviderParam, pParam, nParamIndex)) != ok)
        return rc ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpToString_AppendKey                                             */
/*                                                                          */
/*! 
*   \_en
*   Append it's key to the keystring. If it depends on anything it must 
*   call Cache_AppendKey for any dependency.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash of this Providers
*   @param  pParam          All Parameters 
*   @param  nParamIndex       If pParam is an AV, this parameter gives the index into the Array
*   @param  pKey            Key to which string should be appended
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Hängt ein eigenen Schlüssel an den Schlüsselstring an. Wenn irgednwelche
*   Abhänigkeiten bestehen, muß Cache_AppendKey für alle Abhänigkeiten aufgerufen 
*   werden.
*   
*   @param  r               Embperl request record
*   @param  pProviderClass  Provider class record
*   @param  pProviderParam  Parameter Hash dieses Providers
*   @param  pParam          Parameter insgesamt
*   @param  nParamIndex       Wenn pParam ein AV ist, gibt dieser Parameter den Index an
*   @param  pKey            Schlüssel zu welchem hinzugefügt wird
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpToString_AppendKey (/*in*/ req *              r,
                                   /*in*/ tProviderClass *   pProviderClass,
                                      /*in*/ HV *               pProviderParam,
                                      /*in*/ SV *               pParam,
                                      /*in*/ IV                 nParamIndex,
                                   /*i/o*/ SV *              pKey)
    {
    epTHX_
    int          rc ;
    if ((rc = Cache_AppendKey (r, pProviderParam, "source", pParam, nParamIndex, pKey)) != ok)
        return rc;
    sv_catpv (pKey, "*eptostring") ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpToString_GetContentIndex                                       */
/*                                                                          */
/*! 
*   \_en
*   Get the whole content from the provider. 
*   The Embperl parser provider parsers the source and generates a DomTree
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Returns the content
*   @param  bUseCache       Set if the content should not recomputed
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Holt den gesamt Inhalt vom Provider.
*   Der Embperl Parser Provider parsest die Quelle und erzeugt einen DomTree
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @param  pData           Liefert den Inhalt
*   @param  bUseCache       Gesetzt wenn der Inhalt nicht neu berechnet werden soll
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
static int ProviderEpToString_GetContentSV (/*in*/ req *             r,
                                            /*in*/ tProvider *       pProvider,
                                            /*in*/ SV * *            pData,
                                            /*in*/ bool              bUseCache)
    {
    epTHX_
    int     rc ;
    STRLEN  len ;
    tIndex  xSrcDomTree ;
    tCacheItem * pSrcCache ;
    SV * pOut ;
    char * pBuf ;
    tDomTree * pDomTree ;
    pSrcCache = Cache_GetDependency(r, pProvider -> pCache, 0) ;
    if ((rc = Cache_GetContentIndex (r, pSrcCache, &xSrcDomTree, bUseCache)) != ok)
        return rc ;
    if (!bUseCache)
        {
        if (xSrcDomTree == 0)
            {
            strncpy (r -> errdat1, "EpToString source", sizeof (r -> errdat1)) ;
            return rcMissingInput ;
            }
         
        oRollbackOutput (r, NULL) ;
        oBegin (r) ;
        pDomTree = DomTree_self (xSrcDomTree) ;
        Node_toString (r, pDomTree, pDomTree -> xDocument, 0) ;
        pOut = newSV (1) ;
        len = GetContentLength (r) + 1 ;
     
        SvGROW (pOut, len) ;
        pBuf = SvPVX (pOut) ;
        oCommitToMem (r, NULL, pBuf) ;
        oRollbackOutput (r, NULL) ;
        SvCUR_set (pOut, len - 1) ;
        SvPOK_on (pOut) ;
        *pData = pOut ;
        }
    return ok ;
    }
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* ProviderEpToString_FreeContent                                           */
/*                                                                          */
/*! 
*   \_en
*   Free the cached data
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 error code
*   \endif                                                                       
*
*   \_de                                                                           
*   Gibt die gecachten Daten frei
*   
*   @param  r               Embperl request record
*   @param  pProvider       The provider record
*   @return                 Fehlercode
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int ProviderEpToString_FreeContent(/*in*/ req *             r,
                                /*in*/ tCacheItem * pItem)
    {
    if (pItem -> xData)
        return DomTree_delete (r -> pApp, DomTree_self(pItem -> xData)) ;
    return ok ;
    }
/* ------------------------------------------------------------------------ */
tProviderClass ProviderClassEpToString = 
    {   
    "text/*", 
    &ProviderEpToString_New, 
    &ProviderEpToString_AppendKey, 
    NULL,
    &ProviderEpToString_GetContentSV,
    NULL,
    NULL,
    &ProviderEpToString_FreeContent,
    NULL,
    } ;
/* ------------------------------------------------------------------------ */
/*                                                                          */
/* Provider_Init                                                            */
/*                                                                          */
/*! 
*   \_en
*   Register all the providers
*   @return                 error code
*   
*   \endif                                                                       
*
*   \_de                                                                           
*   Provider registrieren
*   @return                 Fehlercode
*   
*   \endif                                                                       
*                                                                          
* ------------------------------------------------------------------------ */
int Provider_Init (/*in*/ tApp * a)
    {
    Cache_AddProviderClass ("file",      &ProviderClassFile) ;
    Cache_AddProviderClass ("memory",    &ProviderClassMem) ;
    Cache_AddProviderClass ("epparse",   &ProviderClassEpParse) ;
    Cache_AddProviderClass ("epcompile", &ProviderClassEpCompile) ;
    Cache_AddProviderClass ("eprun",     &ProviderClassEpRun) ;
    Cache_AddProviderClass ("eptostring",&ProviderClassEpToString) ;
    ep_create_mutex(PackageCountMutex) ;
    return ok ;
    }