Fossil

}

#endif
/* end TH_USE_SQLITE */


#ifdef TH_USE_OUTBUF








struct Th_Ob_Man {
  Blob ** aBuf;
  int nBuf;
  int cursor;


  Th_Interp * interp;
  Th_Vtab ** aVtab;





};

typedef struct Th_Ob_Man Th_Ob_Man;
#define Th_Ob_Man_empty_m { NULL, 0, -1, NULL, NULL }
static const Th_Ob_Man Th_Ob_Man_empty = Th_Ob_Man_empty_m;
static Th_Ob_Man Th_Ob_Man_instance = Th_Ob_Man_empty_m;





static Blob * Th_ob_current( Th_Ob_Man * pMan ){
  return pMan->nBuf>0 ? pMan->aBuf[pMan->cursor] : 0;
}






static int Th_output_ob( char const * zData, int len, void * pState ){
  Th_Ob_Man * pMan = (Th_Ob_Man*)pState;
  Blob * b = Th_ob_current( pMan );
  assert( NULL != pMan );
  assert( b );
  blob_append( b, zData, len );
  return len;
}




static Th_Vtab Th_Vtab_Ob = { th_fossil_realloc,
  {
    Th_output_ob,
    NULL,
    1
  }
};

#if 0

#define OB_MALLOC(I,N) malloc((N))
#define OB_REALLOC(I,P,N) realloc((P),(N))
#define OB_FREE(I,P) free((P))
#else
#define OB_MALLOC(I,N) Th_Malloc((I),(N))
#define OB_REALLOC(I,P,N) Th_Realloc((I),(P),(N))
#define OB_FREE(I,P) Th_Free((I),(P))
#endif

int Th_ob_push( Th_Ob_Man * pMan, Blob ** pOut ){
  Blob * pBlob;
  int x, i;
  assert( NULL != pMan->interp );
  pBlob = (Blob *)OB_MALLOC(pMan->interp, sizeof(Blob));
  *pBlob = empty_blob;

  if( pMan->cursor <= pMan->nBuf ){
    /* expand if needed */
    x = (pMan->cursor>0 ? pMan->cursor : 1) * 2;
    /*fprintf(stderr,"OB EXPAND x=%d\n",x);*/
    void * re = OB_REALLOC( pMan->interp, pMan->aBuf, x * sizeof(Blob*) );
    if(NULL==re){
      goto error;
    }
    pMan->aBuf = (Blob **)re;
    re = OB_REALLOC( pMan->interp, pMan->aVtab, x * sizeof(Th_Vtab*) );
    if(NULL==re){
      goto error;
    }
    pMan->aVtab = (Th_Vtab**)re;
    for( i = pMan->nBuf; i < x; ++i ){
      pMan->aVtab[i] = NULL;
      pMan->aBuf[i] = NULL;
................................................................................
  if( pOut ){
    *pOut = pBlob;
  }
  /*fprintf(stderr,"OB PUSH: %p\n", pBlob);*/
  return TH_OK;
  error:
  if( pBlob ){
    OB_FREE( pMan->interp, pBlob );
  }
  return TH_ERROR;
}









Blob * Th_ob_pop( Th_Ob_Man * pMan ){
  if( pMan->cursor < 0 ){
    return NULL;
  }else{
    Blob * rc;
    assert( pMan->nBuf > pMan->cursor );
    rc = pMan->aBuf[pMan->cursor];
    pMan->aBuf[pMan->cursor] = NULL;
    pMan->interp->pVtab = pMan->aVtab[pMan->cursor];
    pMan->aVtab[pMan->cursor] = NULL;
    if(-1 == --pMan->cursor){
      OB_FREE( pMan->interp, pMan->aBuf );
      OB_FREE( pMan->interp, pMan->aVtab );
      *pMan = Th_Ob_Man_empty;
    }
    /*fprintf(stderr,"OB pop: %p level=%d\n", rc, pMan->cursor-1);*/
    return rc;
  }
}









static int ob_clean_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl
){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b;
  assert( pMan && (interp == pMan->interp) );
  b = pMan ? Th_ob_current(pMan) : NULL;
................................................................................
    return TH_ERROR;
  }else{
    blob_reset(b);
  }
  return TH_OK;
}









static int ob_end_command( Th_Interp *interp, void *ctx,
                           int argc,  const char **argv, int *argl ){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b;
  assert( pMan && (interp == pMan->interp) );
  b = Th_ob_pop(pMan);
  if(!b){
    Th_ErrorMessage( interp, "Not currently buffering.", NULL, 0 );
    return TH_ERROR;
  }else{
    blob_reset(b);
    OB_FREE( interp, b );
  }
  return TH_OK;
}













static int ob_flush_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl ){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b = NULL;
  Th_Vtab * oldVtab;
  assert( pMan && (interp == pMan->interp) );
  b = Th_ob_current(pMan);
................................................................................
  interp->pVtab = pMan->aVtab[pMan->cursor];
  Th_output( interp, blob_str(b), b->nUsed );
  interp->pVtab = oldVtab;
  blob_reset(b);
  return TH_OK;
}












static int ob_get_command( Th_Interp *interp, void *ctx,
                           int argc,  const char **argv, int *argl){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b = NULL;
  assert( pMan && (interp == pMan->interp) );
  b = Th_ob_current(pMan);
  if( NULL == b ){
................................................................................
        rc |= ob_end_command(interp, ctx, argc-1, argv+1, argl+1);
      }
    }
    return rc;
  }
}

























static int ob_start_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl
){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b = NULL;
  int rc;
  assert( pMan && (interp == pMan->interp) );
................................................................................
  rc = Th_ob_push(pMan, &b);
  if( TH_OK != rc ){
    assert( NULL == b );
    return rc;
  }
  assert( NULL != b );
  /*fprintf(stderr,"OB STARTED: %p level=%d\n", b, pMan->cursor);*/
  Th_SetResultInt( interp, pMan->cursor );
  return TH_OK;
}









static int ob_cmd(
  Th_Interp *interp, 
  void *ignored, 
  int argc, 
  const char **argv, 
  int *argl
){
  static Th_Ob_Man * pMan = &Th_Ob_Man_instance;
  Th_SubCommand aSub[] = {
    { "clean",     ob_clean_command },
    { "end",       ob_end_command },
    { "flush",     ob_flush_command },
    { "get",       ob_get_command },

    { "start",     ob_start_command },
    { 0, 0 }
  };
  if(NULL == pMan->interp){
    pMan->interp = interp;
    /*
      FIXME: add rudamentary at-finalization GC to Th_Interp and clean
      this up there.

    */
  }
  return Th_CallSubCommand(interp, pMan, argc, argv, argl, aSub);
  
}

int th_register_ob(Th_Interp * interp){
  static Th_Command_Reg aCommand[] = {
    {"ob",    ob_cmd,   0},
    {0,0,0}
  };
  return Th_register_commands( interp, aCommand );
}
#undef OB_MALLOC
#undef OB_REALLOC
#undef OB_FREE
#endif
/* end TH_USE_OUTBUF */

}

#endif
/* end TH_USE_SQLITE */


#ifdef TH_USE_OUTBUF
/* Reminder: the ob code "really" belongs in th_lang.c,
   but we need access to Th_Interp internals in order to
   swap out Th_Vtab parts for purposes of stacking layers
   of buffers.
*/
/*
** Manager of a stack of Blob objects for output buffering.
*/
struct Th_Ob_Man {
  Blob ** aBuf;        /* Stack of Blobs */


  int nBuf;            /* Number of blobs */
  int cursor;          /* Current level (-1=not active) */
  Th_Interp * interp;  /* The associated interpreter */
  Th_Vtab ** aVtab;    /* Stack of Vtabs (they get restored
                          when a buffering level is popped).
                          Has nBuf entries.

                          FIXME? Only swap out the "out" members?
                       */
};

typedef struct Th_Ob_Man Th_Ob_Man;
#define Th_Ob_Man_empty_m { NULL, 0, -1, NULL, NULL }
static const Th_Ob_Man Th_Ob_Man_empty = Th_Ob_Man_empty_m;
static Th_Ob_Man Th_Ob_Man_instance = Th_Ob_Man_empty_m;

/*
** Returns the top-most Blob in pMan's stack, or NULL
** if buffering is not active.
*/
static Blob * Th_ob_current( Th_Ob_Man * pMan ){
  return pMan->nBuf>0 ? pMan->aBuf[pMan->cursor] : 0;
}


/*
** Th_output_f() impl which expects pState to be (Th_Ob_Man*).
** (zData,len) are appended to pState's current output buffer.
*/
static int Th_output_f_ob( char const * zData, int len, void * pState ){
  Th_Ob_Man * pMan = (Th_Ob_Man*)pState;
  Blob * b = Th_ob_current( pMan );
  assert( NULL != pMan );
  assert( b );
  blob_append( b, zData, len );
  return len;
}

/*
** Vtab impl for the ob buffering layer.
*/
static Th_Vtab Th_Vtab_Ob = { th_fossil_realloc,
  {
    Th_output_f_ob,
    NULL,
    1
  }
};


/*
** Pushes a new blob onto pMan's stack. On success
** returns TH_OK and assigns *pOut (if pOut is not NULL)
** to the new blob (which is owned by pMan). On error
** pOut is not modified and non-0 is returned.




*/
int Th_ob_push( Th_Ob_Man * pMan, Blob ** pOut ){
  Blob * pBlob;
  int x, i;
  assert( NULL != pMan->interp );
  pBlob = (Blob *)Th_Malloc(pMan->interp, sizeof(Blob));
  *pBlob = empty_blob;

  if( pMan->cursor <= pMan->nBuf ){
    /* expand if needed */
    x = (pMan->cursor>0 ? pMan->cursor : 1) * 2;
    /*fprintf(stderr,"OB EXPAND x=%d\n",x);*/
    void * re = Th_Realloc( pMan->interp, pMan->aBuf, x * sizeof(Blob*) );
    if(NULL==re){
      goto error;
    }
    pMan->aBuf = (Blob **)re;
    re = Th_Realloc( pMan->interp, pMan->aVtab, x * sizeof(Th_Vtab*) );
    if(NULL==re){
      goto error;
    }
    pMan->aVtab = (Th_Vtab**)re;
    for( i = pMan->nBuf; i < x; ++i ){
      pMan->aVtab[i] = NULL;
      pMan->aBuf[i] = NULL;
................................................................................
  if( pOut ){
    *pOut = pBlob;
  }
  /*fprintf(stderr,"OB PUSH: %p\n", pBlob);*/
  return TH_OK;
  error:
  if( pBlob ){
    Th_Free( pMan->interp, pBlob );
  }
  return TH_ERROR;
}

/*
** Pops the top-most output buffer off the stack and returns
** it. Returns NULL if there is no current buffer.  When the last
** buffer is popped, pMan's internals are cleaned up.
**
** The caller owns the returned object and must eventually call
** blob_reset() on it.
*/
Blob * Th_ob_pop( Th_Ob_Man * pMan ){
  if( pMan->cursor < 0 ){
    return NULL;
  }else{
    Blob * rc;
    assert( pMan->nBuf > pMan->cursor );
    rc = pMan->aBuf[pMan->cursor];
    pMan->aBuf[pMan->cursor] = NULL;
    pMan->interp->pVtab = pMan->aVtab[pMan->cursor];
    pMan->aVtab[pMan->cursor] = NULL;
    if(-1 == --pMan->cursor){
      Th_Free( pMan->interp, pMan->aBuf );
      Th_Free( pMan->interp, pMan->aVtab );
      *pMan = Th_Ob_Man_empty;
    }
    /*fprintf(stderr,"OB pop: %p level=%d\n", rc, pMan->cursor-1);*/
    return rc;
  }
}

/*
** TH Syntax:
**
** ob clean
**
** Erases any currently buffered contents but does not modify
** the buffering level.
*/
static int ob_clean_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl
){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b;
  assert( pMan && (interp == pMan->interp) );
  b = pMan ? Th_ob_current(pMan) : NULL;
................................................................................
    return TH_ERROR;
  }else{
    blob_reset(b);
  }
  return TH_OK;
}

/*
** TH Syntax:
**
** ob end
**
** Erases any currently buffered contents and pops the current buffer
** from the stack.
*/
static int ob_end_command( Th_Interp *interp, void *ctx,
                           int argc,  const char **argv, int *argl ){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b;
  assert( pMan && (interp == pMan->interp) );
  b = Th_ob_pop(pMan);
  if(!b){
    Th_ErrorMessage( interp, "Not currently buffering.", NULL, 0 );
    return TH_ERROR;
  }else{
    blob_reset(b);
    Th_Free( interp, b );
  }
  return TH_OK;
}

/*
** TH Syntax:
**
** ob flush
**
** UNTESTED! Maybe not needed.
**
** Briefly reverts the output layer to the next-lower
** level, flushes the current buffer to that output layer,
** and clears out the current buffer. Does not change the
** buffering level.
*/
static int ob_flush_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl ){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b = NULL;
  Th_Vtab * oldVtab;
  assert( pMan && (interp == pMan->interp) );
  b = Th_ob_current(pMan);
................................................................................
  interp->pVtab = pMan->aVtab[pMan->cursor];
  Th_output( interp, blob_str(b), b->nUsed );
  interp->pVtab = oldVtab;
  blob_reset(b);
  return TH_OK;
}

/*
** TH Syntax:
**
** ob get ?clean|end?
**
** Fetches the contents of the current buffer level.  If either
** 'clean' or 'end' are specified then the effect is as if "ob clean"
** or "ob end", respectively, are called after fetching the
** value. Calling "ob get end" is functionality equivalent to "ob get"
** followed by "ob end".
*/
static int ob_get_command( Th_Interp *interp, void *ctx,
                           int argc,  const char **argv, int *argl){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b = NULL;
  assert( pMan && (interp == pMan->interp) );
  b = Th_ob_current(pMan);
  if( NULL == b ){
................................................................................
        rc |= ob_end_command(interp, ctx, argc-1, argv+1, argl+1);
      }
    }
    return rc;
  }
}

/*
** TH Syntax:
**
** ob level
**
** Returns the buffering level, where 0 means no buffering is
** active, 1 means 1 level is active, etc.
*/
static int ob_level_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl
){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Th_SetResultInt( interp, 1 + pMan->cursor );
  return TH_OK;
}

/*
** TH Syntax:
**
** ob start
**
** Pushes a new level of buffering onto the buffer stack.
** Returns the new buffering level (1-based).
*/
static int ob_start_command( Th_Interp *interp, void *ctx,
                             int argc,  const char **argv, int *argl
){
  Th_Ob_Man * pMan = (Th_Ob_Man *)ctx;
  Blob * b = NULL;
  int rc;
  assert( pMan && (interp == pMan->interp) );
................................................................................
  rc = Th_ob_push(pMan, &b);
  if( TH_OK != rc ){
    assert( NULL == b );
    return rc;
  }
  assert( NULL != b );
  /*fprintf(stderr,"OB STARTED: %p level=%d\n", b, pMan->cursor);*/
  Th_SetResultInt( interp, 1 + pMan->cursor );
  return TH_OK;
}

/*
** TH Syntax:
**
** ob clean|end|flush|get|level|start
**
** Runs the given subcommand.
** 
*/
static int ob_cmd(
  Th_Interp *interp, 
  void *ignored, 
  int argc, 
  const char **argv, 
  int *argl
){
  static Th_Ob_Man * pMan = &Th_Ob_Man_instance;
  Th_SubCommand aSub[] = {
    { "clean",     ob_clean_command },
    { "end",       ob_end_command },
    { "flush",     ob_flush_command },
    { "get",       ob_get_command },
    { "level",     ob_level_command },
    { "start",     ob_start_command },
    { 0, 0 }
  };
  if(NULL == pMan->interp){
    pMan->interp = interp;
    /*
      FIXME: add rudamentary at-finalization GC to Th_Interp and clean
      this up there. We currently leak only if the client does not
      close all buffering levels properly.
    */
  }
  return Th_CallSubCommand(interp, pMan, argc, argv, argl, aSub);
  
}

int th_register_ob(Th_Interp * interp){
  static Th_Command_Reg aCommand[] = {
    {"ob",    ob_cmd,   0},
    {0,0,0}
  };
  return Th_register_commands( interp, aCommand );
}

#undef Th_Ob_Man_empty_m

#endif
/* end TH_USE_OUTBUF */

#define TH_USE_SQLITE
#ifdef TH_USE_SQLITE
#include "sqlite3.h"
#endif

/*
** TH_USE_OUTBUF, if defined, enables the "ob" family of functions.


*/
#define TH_USE_OUTBUF
/*#undef TH_USE_OUTBUF*/


/* This header file defines the external interface to the custom Scripting
** Language (TH) interpreter.  TH is very similar to TCL but is not an

#define TH_USE_SQLITE
#ifdef TH_USE_SQLITE
#include "sqlite3.h"
#endif

/*
** TH_USE_OUTBUF, if defined, enables the "ob" family of functions.
** They are functionally similar to PHP's ob_start(), ob_end(), etc.
** family of functions, providing output capturing/buffering.
*/
#define TH_USE_OUTBUF
/*#undef TH_USE_OUTBUF*/


/* This header file defines the external interface to the custom Scripting
** Language (TH) interpreter.  TH is very similar to TCL but is not an