Fossil

#endif

extern void *fossil_realloc(void *p, size_t n);
static void * th_fossil_realloc(void *p, unsigned int n){
  return fossil_realloc( p, n );
}
static int Th_output_f_ob( char const * zData, int len, void * pState );
static void Th_output_dispose_ob( void * pState );
typedef struct Th_Command   Th_Command;
typedef struct Th_Frame     Th_Frame;
typedef struct Th_Variable  Th_Variable;

const Th_Vtab_Output Th_Vtab_Output_FILE = {
  Th_output_f_FILE /* write() */,
  Th_output_dispose_FILE /* dispose() */,
  NULL /*pState*/,
  1/*enabled*/
};

/*
** Holds client-provided "garbage collected" data for
** a Th_Interp instance.
*/
struct Th_GcEntry {
  void * pData;                        /* arbitrary data */

void *Th_Realloc(Th_Interp *pInterp, void *z, int nByte){
  void *p = pInterp->pVtab->xRealloc(z, nByte);
  return p;
}


int Th_Vtab_output( Th_Vtab *vTab, char const * zData, int nData ){
  if(!vTab->out.write){
    return -1;
  }else if(!vTab->out.enabled){
    return 0;
  }else{
    return vTab->out.write( zData, nData, vTab->out.pState );
  }
}


int Th_output( Th_Interp *pInterp, char const * zData, int nData ){
  return Th_Vtab_output( pInterp->pVtab, zData, nData );
}

int Th_output_f_FILE( char const * zData, int nData, void * pState ){
  FILE * dest = pState ? (FILE*)pState : stdout;
  int rc = (int)fwrite(zData, 1, nData, dest);
  fflush(dest);
  return rc;
}

void Th_output_dispose_FILE( void * pState ){
  FILE * f = pState ? (FILE*)pState : NULL;
  if(f
     && (f != stdout)
     && (f != stderr)
     && (f != stdin)){
    fflush(f);
    fclose(f);
  }
}

/*
** Install a new th1 command. 
**
** If a command of the same name already exists, it is deleted automatically.
*/
int Th_CreateCommand(

#define Th_Ob_Man_empty_m { \
  NULL/*aBuf*/,           \
  0/*nBuf*/,            \
  -1/*cursor*/,       \
  NULL/*interp*/,     \
  NULL/*aOutput*/       \
}

/*
** Vtab impl for the ob buffering layer.
*/
#define Th_Vtab_Output_empty_m { \
  NULL /* write() */, \
  NULL /* dispose() */, \
  NULL /*pState*/,\
  1/*enabled*/\
}
#define Th_Vtab_Output_ob_m { \
  Th_output_f_ob /*write()*/, \
  Th_output_dispose_ob /* dispose() */, \
  NULL /*pState*/,\
  1/*enabled*/\
}
static const Th_Ob_Man Th_Ob_Man_empty = Th_Ob_Man_empty_m;
static Th_Vtab_Output Th_Vtab_Output_ob = Th_Vtab_Output_ob_m;
static Th_Vtab_Output Th_Vtab_Output_empty = Th_Vtab_Output_empty_m;
#define Th_Ob_Man_KEY "Th_Ob_Man"
Th_Ob_Man * Th_ob_manager(Th_Interp *interp){
  return (Th_Ob_Man*) Th_Data_Get(interp, Th_Ob_Man_KEY );
}


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.
*/
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;
}

static void Th_output_dispose_ob( void * pState ){
  /* possible todo: move the cleanup logic from
     Th_ob_pop() to here? */
  /*printf("disposing() ob vtab.\n"); */

#if 0
  Th_Ob_Man * pMan = (Th_Ob_Man*)pState;
  Blob * b = Th_ob_current( pMan );
  assert( NULL != pMan );
  assert( b );
#endif
}




int Th_ob_push( Th_Ob_Man * pMan,
                Th_Vtab_Output const * pWriter,
                Blob ** pOut ){
  Blob * pBlob;
  int x, i;
  if( NULL == pWriter ){
    pWriter = &Th_Vtab_Output_ob;
  }
  assert( NULL != pMan->interp );
  pBlob = (Blob *)Th_Malloc(pMan->interp, sizeof(Blob));
  *pBlob = empty_blob;

  if( pMan->cursor >= pMan->nBuf-2 ){
    /* expand if needed */
    x = pMan->nBuf + 5;

    pMan->nBuf = x;
  }
  assert( pMan->nBuf > pMan->cursor );
  assert( pMan->cursor >= -1 );
  ++pMan->cursor;
  pMan->aBuf[pMan->cursor] = pBlob;
  pMan->aOutput[pMan->cursor] = pMan->interp->pVtab->out;
  pMan->interp->pVtab->out = *pWriter;
  pMan->interp->pVtab->out.pState = pMan;
  if( pOut ){
    *pOut = pBlob;
  }
  /*printf( "push: pMan->nBuf=%d, pMan->cursor=%d\n", pMan->nBuf, pMan->cursor);*/
  return TH_OK;
  error:
  if( pBlob ){
    Th_Free( pMan->interp, pBlob );
  }
  return TH_ERROR;
}

Blob * Th_ob_pop( Th_Ob_Man * pMan ){
  if( pMan->cursor < 0 ){
    return NULL;
  }else{
    Blob * rc;
    Th_Vtab_Output * theOut;
    /*printf( "pop: pMan->nBuf=%d, pMan->cursor=%d\n", pMan->nBuf, pMan->cursor);*/
    assert( pMan->nBuf > pMan->cursor );
    rc = pMan->aBuf[pMan->cursor];
    pMan->aBuf[pMan->cursor] = NULL;
    theOut = &pMan->aOutput[pMan->cursor];
    if( theOut->dispose ){
      theOut->dispose( theOut->pState );
    }
    pMan->interp->pVtab->out = *theOut;
    pMan->aOutput[pMan->cursor] = Th_Vtab_Output_empty;
    if(-1 == --pMan->cursor){
      Th_Interp * interp = pMan->interp;
      Th_Free( pMan->interp, pMan->aBuf );
      Th_Free( pMan->interp, pMan->aOutput );
      *pMan = Th_Ob_Man_empty;
      pMan->interp = interp;

  Th_SetResultInt( interp, 1 + pMan->cursor );
  return TH_OK;
}

/*
** TH Syntax:
**
** ob start|push
**
** Pushes a new level of buffering onto the buffer stack.
** Returns the new buffering level (1-based).
**
** TODO: take an optional final argument naming the output handler.
** e.g. "stdout" or "cgi" or "default"
** 
*/
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;
  Th_Vtab_Output const * pWriter = &Th_Vtab_Output_ob;
  assert( pMan && (interp == pMan->interp) );
  rc = Th_ob_push(pMan, NULL, &b);
  if( TH_OK != rc ){
    assert( NULL == b );
    return rc;
  }
  assert( NULL != b );
  Th_SetResultInt( interp, 1 + pMan->cursor );
  return TH_OK;

** implementation-specific state pointer (may be NULL, depending on
** the implementation). The return value is the number of bytes output
** (which may differ from len due to encoding and whatnot).  On error
** a negative value must be returned.
*/
typedef int (*Th_output_f)( char const * zData, int len, void * pState );

/*
** This structure defines the output state associated with a
** Th_Vtab. It is intended that a given Vtab be able to swap out
** output back-ends during its lifetime, e.g. to form a stack of
** buffers.
*/
struct Th_Vtab_Output {
  Th_output_f write;   /* output handler */
  void (*dispose)( void * pState );
  void * pState;   /* final argument for xOut() and dispose()*/
  char enabled;    /* if 0, Th_output() does nothing. */
};
typedef struct Th_Vtab_Output Th_Vtab_Output;

/*
** Shared Th_Vtab_Output instance used for copy-initialization.
*/
extern const Th_Vtab_Output Th_Vtab_Output_FILE;

/*
** Before creating an interpreter, the application must allocate and
** populate an instance of the following structure. It must remain valid
** for the lifetime of the interpreter.
*/
struct Th_Vtab {
  void *(*xRealloc)(void *, unsigned int); /* Re/deallocation routine. */
  Th_Vtab_Output out;                      /* output implementation */
};
typedef struct Th_Vtab Th_Vtab;


/*
** Opaque handle for interpeter.
*/

/*
** Th_output_f() implementation which sends its output to either
** pState (which must be NULL or a (FILE*)) or stdout (if pState is
** NULL).
*/
int Th_output_f_FILE( char const * zData, int len, void * pState );
/*
** Th_Vtab_Output::dispose impl for FILE handles. If pState is not
** one of the standard streams then it is fclose()d.
*/
void Th_output_dispose_FILE( void * pState );

typedef struct Th_Command_Reg Th_Command_Reg;
/*
** A helper type for holding lists of function registration information.
** For use with Th_register_commands().
*/
struct Th_Command_Reg {

/*
** 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, Th_Vtab_Output const * pWriter, Blob ** pOut );

/*
** 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 (but pMan is not
** freed).
**

      /* FIXME: try to find some reasonable nOutstandingMalloc
         heuristics, e.g. if !p then ++, if !n then --, etc.
      */;
  }
}

static Th_Vtab vtab = { xRealloc, {
  NULL /*write()*/,
  NULL/*dispose()*/,
  NULL/*pState*/,
  1/*enabled*/
  }
};

/*
** Generate a TH1 trace message if debugging is enabled.
*/
void Th_Trace(const char *zFormat, ...){

    {"wiki",          wikiCmd,              0},

    {0, 0, 0}
  };
  if( g.interp==0 ){
    int i;
    if(g.cgiOutput){
      vtab.out.write = Th_output_f_cgi_content;
    }else{
      vtab.out = Th_Vtab_Output_FILE;
      vtab.out.pState = stdout;
    }
    vtab.out.enabled = enableOutput;
    g.interp = Th_CreateInterp(&vtab);
    th_register_language(g.interp);       /* Basic scripting commands. */
#ifdef FOSSIL_ENABLE_TCL
    if( getenv("TH1_ENABLE_TCL")!=0 || db_get_boolean("tcl", 0) ){

<th1>
set i 0
set max 6
for {} {$i < $max} {incr i} {
    ob start
    puts "this is level " [ob level]
    set buf($i) [ob get]
}

for {set i [expr $max-1]} {$i >= 0} {incr i -1} {
    ob pop
}
for {set i [expr $max-1]} {$i >= 0} {incr i -1} {
    puts buf($i) = $buf($i) "\n"
}
puts "buffering level = " [ob level] \n
</th1>