/*###################################################################################
#
#   Embperl - Copyright (c) 1997-2001 Gerald Richter / ECOS
#
#   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.
#
#   $Id: epdat.h,v 1.37 2001/11/02 10:03:48 richter Exp $
#
###################################################################################*/
#ifdef EP2
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  cache Options                                                  */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef enum tCacheOptions
    {
    ckoptCarryOver = 1,   /* use result from CacheKeyCV of preivious step if any */
    ckoptPathInfo  = 2,   /* include the PathInfo into CacheKey */
    ckoptQueryInfo = 4,   /* include the QueryInfo into CacheKey */
    ckoptDontCachePost = 8,       /* don't cache POST requests */
    ckoptDefault    = 15          /* default is all options set */
    } tCacheOptions ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Processor                                                      */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef struct tProcessor
    {
    int nProcessorNo ;
    const char *    sName ;
    int (* pPreCompiler)            (/*in*/  tReq *       r,
                                     /*in*/  struct tProcessor * pProcessor,
                                     /*in*/  tDomTree **  ppDomTree,
                                     /*in*/  SV **        ppPreCompResult,
                                     /*out*/ SV **        ppCompResult) ;
    int (* pCompiler)               (/*in*/  tReq *       r,
                                     /*in*/  struct tProcessor * pProcessor,
                                     /*in*/  tDomTree **  ppDomTree,
                                     /*in*/  SV **        ppPreCompResult,
                                     /*out*/ SV **        ppCompResult) ;
    int (* pPreExecuter)            (/*in*/  tReq *       r,
                                     /*in*/  struct tProcessor * pProcessor,
                                     /*in*/  tDomTree **  pDomTree,
                                     /*in*/  SV **        ppPreCompResult,
                                     /*in*/  SV **        ppCompResult) ;
    int (* pExecuter)               (/*in*/  tReq *       r,
                                     /*in*/  struct tProcessor * pProcessor,
                                     /*in*/  tDomTree **  pDomTree,
                                     /*in*/  SV **        ppPreCompResult,
                                     /*in*/  SV **        ppCompResult,
                                     /*out*/ SV **        ppExecResult) ;
    const char *    sCacheKey ;     /* literal to add to key for cache */
    CV *            pCacheKeyCV ;   /* CV to call and add result to key for cache */
    tCacheOptions   bCacheKeyOptions ;
    double          nOutputExpiresIn ;
    CV *            pOutputExpiresCV ;
    struct tProcessor * pNext ;
    } tProcessor ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  RequestPhases                                                  */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef enum 
    {
    phInit,
    phParse,
    phCompile,
    phRunAfterCompile,
    phPerlCompile,
    phRun,
    phTerm
    } tPhase ;
     
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Parser data structures                                         */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef   unsigned char tCharMap [256/(sizeof(unsigned char)*8)]   ;
struct tToken
    {
    const char *            sText ;     /* string of token (MUST be first item!) */
    const char *            sName ;     /* name of token (only for description) */
    int                     nTextLen ;  /* len of string */
    const char *            sEndText ;  /* string which ends the block */
    const char *            sNodeName;  /* name of the node to create */
    int                     nNodeName ; /* index in string table of node name */
    tNodeType               nNodeType ; /* type of the node that should be created */
    tNodeType               nCDataType ;/* type for sub nodes that contains text */
    tNodeType               nForceType ;/* force this type for sub nodes */
    int                     bUnescape ; /* translate input?  */
    int                     bAddFlags ; /* add flags to node  */
    int                     bRemoveSpaces ;     /* 1 remove spaces before tag, 2 remove after */
    unsigned char *         pContains ; /* chars that could be contained in the string */
    int                     bInsideMustExist ;  /* if inside definition doesn't exists, ignore whole tag */
    struct tTokenTable *    pFollowedBy;/* table of tokens that can follow this one */
    struct tTokenTable *    pInside ;   /* table of tokens that can apear inside this one */
    struct tToken      *    pStartTag ; /* token that contains definition for the start of the current token */
    struct tToken      *    pEndTag ;   /* token that contains definition for the end of the current token */
    const char *            sParseTimePerlCode ; /* perl code that is executed when this token is parsed, %% is replaced by the value of the current attribute */
    } ;        
struct tTokenTable
    {
    void *          pCompilerInfo ; /* stores tables of the compiler , must be first item */
    const char *    sName ;         /* name of syntax */
    tCharMap        cStartChars ;   /* for every vaild start char there is one bit set */
    tCharMap        cAllChars   ;   /* for every vaild char there is one bit set */
    struct tToken * pTokens ;       /* table with all tokens */
    int             numTokens ;     /* number of tokens in above table */
    int             bLSearch ;      /* when set perform a linear, instead of a binary search */
    int             nDefNodeType ;  /* either ntypCDATA or ntypText */
    struct tToken * pContainsToken ;/* pointer to the token that has a pContains defined (could be only one per table) */
    } ;
typedef struct tTokenTable tTokenTable ;
     
#else
typedef void * tTokenTable ;
#endif
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Per (directory) configuration data                             */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef struct tConf
    {
    HV *    pReqParameter ; /* parameters passed to this request */
    int     bDebug ;        /* Debugging options */
    int     bOptions ;      /* Options */
    char *  sPackage ;      /* Packagename */
    char *  sLogFilename ;  /* name of logfile */
    char *  sVirtLogURI ;      /* uri for access virtual log file */
    SV *    pOpcodeMask ;   /* Opcode mask (if any) */
    int     nEscMode ;      /* default escape mode */
    char *  sCookieName ;   /* Name to use for cookie */
    char *  sCookieExpires ; /* cookie expiration time */
    char *  sCookieDomain ; /* domain patter for which the cookie should be returned */
    char *  sCookiePath ;   /* path to which cookie should be returned */
    char    cMultFieldSep ;
    char *  pOpenBracket  ;
    char *  pCloseBracket ;
#ifdef EP2
    bool    bEP1Compat ;    /* run in Embperl 1.x compatible mode */
    tProcessor ** pProcessor ;   /* [array] processors used to process the file */
    char *  sCacheKey ;    /* Key used to store expires setting */
    CV *            pCacheKeyCV ;   /* CV to call and add result to key for cache */
    tCacheOptions   bCacheKeyOptions ;
    double  nExpiresIn ;   /* Data expiers at */
    CV *    pExpiresCV ;   /* sub that is called to determinate expiration */
    char *  sRecipe ;      /* name of recipe used to process the current file */
#endif    
    char *  sPath ;         /* file search path */
    char *  sReqFilename ;  /* filename of original request */
    } tConf ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Per sourcefile data                                            */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef struct tFile
    {
    char *  sSourcefile ;   /* Name of sourcefile */
    double  mtime ;         /* last modification time of file */
    size_t  nFilesize ;     /* size of File */
    SV *    pBufSV ;        /* SV that contains the file content */
    bool    bKeep ;         /* set true if you want to keep file in memory */
     
    HV *    pCacheHash ;    /* Hash containing CVs to precompiled subs */
    char *  sCurrPackage ;  /* Package of file  */
    STRLEN  nCurrPackage ;  /* Package of file (length) */
    HV *    pExportHash ;   /* exportable Macros */
    int     nFirstLine ;    /* First line number of sourcefile */
    struct tFile * pNext2Free ;  /* Next file that has to be freed after the request */
    } tFile ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Per sourcebuffer data                                          */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef struct tSrcBuf
    {
    tFile * pFile ;             /* pointer source file/package specific data */
    char *  pBuf ;              /* Buffer which holds the html source file */
    char *  pCurrPos ;          /* Current position in html file */
    char *  pCurrStart ;        /* Current start position of html tag / eval expression */
    char *  pEndPos ;           /* end of html file */
    int     nBlockNo ;          /* Block number where we are currently */
    char *  pCurrTag ;          /* Current start position of html tag */
    int     nSourceline ;       /* Currentline in sourcefile */
    char *  pSourcelinePos ;    /* Positon of nSourceline in sourcefile */
    char *  pLineNoCurrPos ;    /* save pCurrPos for line no calculation */
    char *  sEvalPackage ;      /* Package for eval (normaly same sCurrPackage,
                                   differs when running in a safe namespace */
    STRLEN  nEvalPackage ;      /* Package for eval (length) */
    } tSrcBuf ;
     
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Commandtypes                                                   */
/*                                                                 */
/*-----------------------------------------------------------------*/
    
enum tCmdType
    {
    cmdNorm     = 1,
    cmdIf       = 2,
    cmdEndif    = 4,
    cmdWhile    = 8,
    cmdTable    = 16,
    cmdTablerow = 32,
    cmdTextarea = 64,
    cmdDo       = 128,
    cmdForeach  = 256,
    cmdSub      = 512,
    cmdAll      = 1023
    } ;
enum tCmdNo
    {
    cnNop,       
    cnTable,
    cnTr,
    cnDir,
    cnMenu,
    cnOl,
    cnUl,
    cnDl,
    cnSelect,
    cnDo,
    cnForeach
    } ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Commands                                                       */
/*                                                                 */
/*-----------------------------------------------------------------*/
    
typedef struct tCmd
    {
    const char *    sCmdName ;     /* Commandname */
    int            ( *pProc)(/*i/o*/ register req * r, /*in*/ const char *   sArg) ;   /* pointer to the procedure */
    bool            bPush ;         /* Push current state? */
    bool            bPop ;          /* Pop last state? */
    enum tCmdType   nCmdType ;      /* Type of the command  */
    bool            bScanArg ;      /* is it nessesary to scan the command arg */
    bool            bSaveArg ;      /* is it nessesary to save the command arg for later use */
    enum tCmdNo     nCmdNo ;        /* number of command to catch mismatch in start/end */
    int             bDisableOption ; /* option bit which disables this cmd */
    bool            bHtml ;          /* this is an html tag */
    } tCmd ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Command/HTML-Stack                                             */
/*                                                                 */
/*-----------------------------------------------------------------*/
    
typedef struct tStackEntry
    {
    enum tCmdType   nCmdType ;      /* Type of the command which the pushed the entry on the stack */
    char *          pStart ;        /* Startposition for loops */
    int             nBlockNo ;      /* Block number where the startposition is */
    long            bProcessCmds ;  /* Process corresponding cmds */
    int             nResult ;       /* Result of Command which starts the block */
    char *          sArg ;          /* Argument of Command which starts the block */
    SV *            pSV ;           /* Additional Data */
    SV *            pSV2 ;          /* Additional Data */
    struct tBuf *   pBuf;          /* Output buf for table rollback          */
    struct tCmd *   pCmd ;          /* pointer to command infos */
    struct tStackEntry * pNext ;      /* pointer to next one on stack/free list */
    } tStackEntry ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Table-Stack                                                    */
/*                                                                 */
/*-----------------------------------------------------------------*/
    
typedef struct tTableStackEntry
    {
    int             nResult ;       /* Result of Command which starts the block */
    int             nCount ;        /* Count for tables, lists etc */
    int             nCountUsed ;    /* Count for tables, lists is used in Table  */
    int             nRow ;          /* Row Count for tables, lists etc */
    int             nRowUsed ;      /* Row Count for tables, lists is used in Table  */
    int             nCol ;          /* Column Count for tables, lists etc */
    int             nColUsed ;      /* Column Count for tables, lists is used in Table  */
    int             nMaxRow ;       /* maximum rows */
    int             nMaxCol ;       /* maximum columns */
    int             nTabMode;      /* table mode */
    int             bHead ;         /* this row contains a heading */
    int             bRowHead ;      /* the entire row is made of th tags */
    struct tTableStackEntry * pNext ;      /* pointer to next one on stack/free list */
    } tTableStackEntry ;
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Stack-Pointer                                                  */
/*                                                                 */
/*-----------------------------------------------------------------*/
typedef struct tStackPointer
    {
    struct tStackEntry * pStack  ;      /* pointer to stacked entrys */
    struct tStackEntry * pStackFree  ;  /* pointer to currently unused entrys */
    struct tStackEntry State ;          /* top of stack */
    } tStackPointer ;
typedef struct tTableStackPointer
    {
    struct tTableStackEntry * pStack  ;      /* pointer to stacked entrys */
    struct tTableStackEntry * pStackFree  ;  /* pointer to currently unused entrys */
    struct tTableStackEntry State ;             /* top of stack */
    } tTableStackPointer ;
    
/*-----------------------------------------------------------------*/
/*                                                                 */
/*  Per request data                                               */
/*                                                                 */
/*-----------------------------------------------------------------*/
#define ERRDATLEN 1024
#ifdef WIN32
#define pid_t int
#endif
struct tReq
    {
    SV *          pReqSV ;      /* The perl reference to this request structure */
    #ifdef APACHE
    request_rec * pApacheReq ;  /* apache request record */
    SV *          pApacheReqSV ;
    #endif
    pid_t nPid ;                /* process/thread id */
     
    tConf * pConf ;             /* pointer to configuration data */
    bool    bReqRunning  ;      /* we are inside of a request */
    int     bDebug ;            /* Debugging options */
    int     bOptions ;          /* Options */
    int     nIOType ;
    bool    bSubReq ;           /* This is a sub request (called inside an Embperl page) */
    char *  sSubName ;          /* subroutine to call */
    int     nSessionMgnt ;      /* how to retrieve the session id */
    int     nInsideSub ;        /* Are we inside of a sub? */
    int     bExit ;             /* We should exit the page */
    int     nPathNdx ;          /* gives the index in the path where the current file is found */
    char *  sSessionID ;        /* stores session name and id for status session data */
#ifdef EP2
    bool    bEP1Compat ;        /* run in Embperl 1.x compatible mode */    
    tPhase  nPhase ;            /* which phase of the request we are in */
    char *  sPathInfo ;
    char *  sQueryInfo ;
     
    /* --- DomTree ---*/
    tNode       xDocument ;     /* Document node */
    tNode       xCurrNode ;     /* node that was last executed */
    tRepeatLevel nCurrRepeatLevel ; /* repeat level for node that was last executed */
    tIndex      nCurrCheckpoint ; /* next checkpoint that should be passed if execution order is unchanged (i.e. no loop/if) */
    tIndex      xCurrDomTree ;  /* DomTree we are currently working on */
    tIndex      xSourceDomTree ;/* DomTree which contains the source */
#endif
    struct tTokenTable *  pTokenTable ; /* holds the current syntax */
    /* --- Source in memory --- */
    tSrcBuf   Buf ;            /* Buffer */
    tSrcBuf * pBufStack  ;     /* pointer to buffer stack */
    tSrcBuf * pBufStackFree  ; /* pointer to buffer stack free list*/
    tFile * pFiles2Free ;       /* files that has to be freed after the request (only valid in main request) */
    /* --- command handling --- */
    tCmd *              pCurrCmd ;      /* Current cmd which is excuted */
    /* --- Stacks --- */
    tStackPointer       CmdStack  ;      /* Stack for if, while, etc. */
    tStackPointer       HtmlStack ;      /* Stack for table etc. */
    tTableStackPointer  TableStack ;     /* Stack for table */
    /* --- Tablehandling --- */
    int nTabMode    ;    /* mode for next table (only takes affect after next <TABLE> */
    int nTabMaxRow  ;    /* maximum rows for next table (only takes affect after next <TABLE> */
    int nTabMaxCol  ;    /* maximum columns for next table (only takes affect after next <TABLE> */
    /* --- Escaping --- */
    struct tCharTrans * pCurrEscape ;   /* pointer to current escape table */
    struct tCharTrans * pNextEscape ;   /* pointer to next escape table (after end of block) */
    int                 nEscMode ;      /* escape mode set by the user */
    int                 nCurrEscMode ;  /* current active escape mode */
    int                 bEscModeSet ;   /* escape mode already set in this block */
    int                 bEscInUrl ;     /* we are inside an url */
     
    /* --- memory management --- */
    size_t nAllocSize ;             /*  Alloced memory for debugging */
    /* --- buffering output */
    struct tBuf *   pFirstBuf  ;    /* First buffer */
    struct tBuf *   pLastBuf   ;    /* Last written buffer */
    struct tBuf *   pFreeBuf   ;    /* List of unused buffers */
    struct tBuf *   pLastFreeBuf ;  /* End of list of unused buffers */
    char *          pMemBuf ;       /* temporary output */
    char *          pMemBufPtr ;    /* temporary output */
    size_t          nMemBufSize ;   /* size of pMemBuf */
    size_t          nMemBufSizeFree;/* remaining space in pMemBuf */
    int     nMarker ;               /*  Makers for rollback output */
    /* --- i/o filehandles --- */
    #ifdef PerlIO
    PerlIO *  ifd  ;    /* input file */
    PerlIO *  ofd  ;    /* output file */
    PerlIO *  lfd  ;    /* log file */
    #else
    FILE *  ifd  ;      /* input file */
    FILE *  ofd  ;      /* output file */
    FILE *  lfd  ;      /* log file */
    #endif
    SV *    ofdobj ;    /* perl object that is tied to stdout, if any */
    SV *    ifdobj ;    /* perl object that is tied to stdin, if any */
    long    nLogFileStartPos ; /* file position of logfile, when logfile started */
    char *  sOutputfile ;      /* name of output file */
    bool    bAppendToMainReq ; /* append output to main request */
    bool    bDisableOutput ;   /* no output is generated */
    SV *    pOutData ;
    SV *    pInData ;
     
    /* ------------------------ */
    tReq *  pNext ;  /* Next free one */
    tReq *  pLastReq ;  /* Request from which this one is called */
    /* ------------------------ */
     
    /* --- keep track of errors --- */
    bool    bError  ;           /* Error has occured somewhere */
    I32     nLastErrFill  ;     /* last size of error array */
    int     bLastErrState ;     /* last state of error flag */
    AV *    pErrArray ;         /* Errors to show on Error response */
    AV *    pErrFill ;          /* AvFILL of pErrArray, index is nMarker */
    AV *    pErrState ;         /* bError, index is nMarker  */
    /* Everything after here will not automaticly set to zero */
    int     zeroend ;
    char    errdat1 [ERRDATLEN] ; /* Additional error information */
    char    errdat2 [ERRDATLEN] ;
    char    lastwarn [ERRDATLEN] ; /* last warning */
    /* --- Embperl special hashs/arrays --- */
    HV *    pEnvHash ;   /* environement from CGI Script */
    HV *    pFormHash ;  /* Formular data */
    HV *    pFormSplitHash ;  /* Formular data split up at \t */
    HV *    pInputHash ; /* Data of input fields */
    AV *    pFormArray ; /* Fieldnames */
    HV *    pUserHash ;  /* Session User data */
    HV *    pStateHash ; /* Session State data */
    HV *    pModHash ;   /* Module data */
    HV *    pHeaderHash ;/* http headers */
#ifdef EP2
    AV *    pDomTreeAV ; /* holds all DomTrees alocated during the request */
    AV *    pCleanupAV ; /* set all sv's that are conatined in that array to undef after the whole request */
#endif
    /* --- for statistics --- */
    clock_t startclock ;
    I32     stsv_count ;
    I32     stsv_objcount ;
    I32     lstsv_count ;
    I32     lstsv_objcount  ;
    int     numEvals ;
    int     numCacheHits ;
    /* --- more infos for eval --- */
    int  bStrict ; /* aply use strict in each eval */
    char op_mask_buf[MAXO + 100]; /* save buffer for opcode mask - maxo shouldn't differ from MAXO but leave room anyway (see BOOT:)    */
    HV *  pImportStash ;        /* stash for package, where new macros should be imported */
#ifdef EP2
     
    char * * pProg ;            /* pointer into currently compiled code */
    char * pProgRun ;           /* pointer into currently compiled run code */
    char * pProgDef ;           /* pointer into currently compiled define code */
    SV *   pCodeSV ;            /* contains currently compiled line */
#endif
    } ;
#define EPMAINSUB   "_ep_main"