fsl_buffer.c \
	fsl_content.c \
	fsl_config.c \
	fsl_cx.c \
	fsl_db.c \
	fsl_delta.c \
	fsl_encode.c \
	fsl_event.c \
	fsl_fs.c \
	fsl_io.c \
	fsl_leaf.c \
	fsl_md5.c \
	fsl_mf.c \
	fsl_pq.c \
	fsl_repo.c \

  fsl_cx * f = FossilApp.f;
  fsl_db * db = fsl_cx_db_repo(f);
  fsl_deck DECK = fsl_deck_empty;
  fsl_deck * d = &DECK;
  fsl_buffer dout = fsl_buffer_empty;
  fsl_buffer hash = fsl_buffer_empty;
  int rc;
  fsl_double_t now = 1
    ? 2456525.3001276273 /* 2013-08-20T19:12:11.027 */
    : fsl_db_julian_now(db);
  if(!db){
    return fsl_cx_err_set(f, FSL_RC_MISUSE, "This app requires a repo.");
  }
  VERBOSE(("now=%"FSL_JULIAN_T_PFMT"\n", now));
  fsl_deck_init(f, d, FSL_CATYPE_EVENT);
  assert(f==d->f);
  assert(FSL_CATYPE_EVENT==d->type);
  assert(NULL==d->allocStamp);

  rc = fsl_deck_C_set(d, "Test event - automatically generated", -1);
  assert(!rc);

  rc = fsl_deck_D_set( d, now );
  assert(!rc);

#if 0
  {
    char * eventId = fsl_db_random_hex(db, FSL_UUID_STRLEN);
    assert(fsl_is_uuid(eventId));
    rc = fsl_deck_E_set( d, now, eventId );
    fsl_free(eventId);
  }
#else
  rc = fsl_deck_E_set( d, now,

                       "b82b583b2cf60075c99e2ee5accec41906d3e6a2");
#endif
  assert(!rc);

  rc = fsl_deck_T_add( d, FSL_TAGTYPE_ADD, NULL, "automated", NULL);
  assert(!rc);

  
  {

   ** Passes each element in the given list to
   ** childFinalizer(item,finalizerState). If that returns non-0,
   ** processing stops and that value is returned, otherwise
   ** fsl_list_reserve(list,0) is called and 0 is returned.
   **/
  int fsl_list_clear( fsl_list * list, fsl_list_visitor_f childFinalizer,
                      void * finalizerState );
  /**
   ** Similar to fsl_list_clear(list, fsl_list_v_fsl_free, NULL), but
   ** only clears the list itself if the second argument is true,
   ** otherwise it sets the list's length to 0 but keeps its memory
   ** intact for later use.
   **
   ** Be sure only to use this on lists of types for which fsl_free()
   ** is legal. i.e. don't use it on a list of fsl_deck objects or
   ** other types which have their own finalizers.
   **
   ** Results are undefined if list is NULL.
   */
  void fsl_list_visit_free( fsl_list * list, char freeListMem );
  
  /**
   **
   **
   ** Works similarly to the visit operation without the _p suffix
   ** except that the pointer the visitor function gets is a (**)
   ** pointing back to the entry within this list. That means that

  int fsl_deck_D_set( fsl_deck * mf, fsl_double_t date);

  /**
   ** Sets the E card in the given deck. date may not be negative - use
   ** fsl_db_julian_now() or similar to get a default time if needed.
   ** Retursn FSL_RC_MISUSE if !mf or !uuid, FSL_RC_RANGE if date is
   ** not positive, FSL_RC_RANGE if uuid is not a valid UUID string.
   **
   ** Note that the UUID for an event, unlike most other UUIDs, need
   ** not be calculated - it may be a random hex string, but it must
   ** pass the fsl_is_uuid() test. Use fsl_db_random_hex() to generate
   ** random UUIDs. When editing events, e.g. using the HTML UI, only
   ** the most recent event with the same UUID is shown. So when
   ** updating events, be sure to apply the same UUID to the edited
   ** copies before saving them.
   */
  int fsl_deck_E_set( fsl_deck * mf, fsl_double_t date, fsl_uuid_cstr uuid);

  /**
   ** Adds a new F card to the given deck. The uuid argument is
   ** required to pass the fsl_is_uuid() test. The name must be a
   ** "simplified path name" (as determined by

   ** success because they would otherwise refer to db records which
   ** get destroyed when the transaction rolls back.
   **
   ** After saving, the deck gets crosslinked (fsl_deck_crosslink()).
   **
   ** The save operation happens within a transaction, of course,
   ** and on any sort of error, db-side changes are rolled back.
   **
   ** Maintenance reminder: this function also does a small bit of
   ** artifact-type-specific processing.
   **
   ** @see fsl_deck_output()
   ** @see fsl_repo_content_put_ex()
   */
  int fsl_deck_save( fsl_cx * f, fsl_deck * d, char isPrivate );
  
  /**

   ** Tries to convert the value of errNo, which is assumed to come
   ** from the global errno, to a fsl_rc_t code. If it can, it returns
   ** something approximating the errno value, else it returns dflt.
   */
  int fsl_errno_to_rc(int errNo, int dflt);

  /**
   ** Experimental generic callback interface for visiting decks. The
   ** interface does not generically require that d survive after this
   ** call returns.
   */
  typedef int (*fsl_deck_cb_f)( fsl_cx * f, fsl_deck const * d,
                                void * state );

  /**

   ** For each unique wiki page name in f's repostory, this calls
   ** cb(), passing it the manifest of the most recent version of that
   ** page. The callback should return 0 on success, FSL_RC_BREAK to
   ** stop looping without an error, or any other non-0 code
   ** (preferably a value from fsl_rc_t) on error.
   **
   ** The 3rd parameter has no meaning for this function but it is
   ** passed on as-is to the callback.
   **
   ** ACHTUNG: the deck passed to the callback is transient and will
   ** be cleaned up after the callback has returned, so the callback
   ** must not hold a pointer to it or its contents.

   ** indicating more serious problems. If no such page is found,n
   ** newRid is not modified and this function returns 0 (as opposed
   ** to FSL_RC_NOT_FOUND) because that simplifies usage (so far).
   **
   ** On error *newRid is not modified.
   */
  int fsl_wiki_latest_rid( fsl_cx * f, char const * pageName, fsl_id_t * newRid );

  
  /**
   ** Loads the artifact for the most recent version of the given wiki page,
   ** populating d with its contents.
   **
   ** Returns 0 on success. On error d might be partially populated,
   ** so it needs to be passed to fsl_deck_finalize() regardless of

   **
   ** Whether or not this function is allowed to create a new page
   ** or not is determined by isNew. If isNew is true then then this
   ** will fail with FSL_RC_ALREADY_EXISTS if a page with the given
   ** name already exists. If it is false and the page does _not_
   ** exist, FSL_RC_NOT_FOUND is returned.
   **
   ** TODO: find better semantics for isNew, so clients don't have to
   ** check if it exists first. e.g. a policy enum which specifies
   ** whether to allow creation of a new page.
   **
   ** @see fsl_wiki_page_exists()
   */
  int fsl_wiki_save(fsl_cx * f, char const * pageName,
                    fsl_buffer const * b,
                    char const * userName,
                    char const * mimeType,
                    char isNew );

  /**
   ** Fetches the list of all wiki page names in f's current repo db
   ** and appends them as new (char *) strings to tgt. On error tgt
   ** might be partially populated (but this will only happen on an
   ** OOM).
   **
   ** It is up to the caller free the entries added to the list. Some
   ** of the many possibilities include:
   **
   ** @code
   ** fsl_list_visit( list, 0, fsl_list_v_fsl_free, NULL );
   ** fsl_list_reserve(list,0);
   ** // Or:
   ** fsl_list_clear(list, fsl_list_v_fsl_free, NULL);
   ** // Or simply:
   ** fsl_list_visit_free( list, 1 );
   ** @endcode
   **
   */
  int fsl_wiki_names_get( fsl_cx * f, fsl_list * tgt );

  /**
   ** Returns n bytes of random lower-case hexidecimal characters
   ** using the given db as its data source. The returned memory must
   ** eventually be freed using fsl_free(). Returns NULL if !db, !n,
   ** or on a db-level error.
   */
  char * fsl_db_random_hex(fsl_db * db, fsl_size_t n);

  /**
   ** Expects fmt to be a SELECT-style query. For each row in the
   ** query, the first column is fetched as a string and appended to
   ** the tgt list.
   **
   ** Returns 0 on success, FSL_RC_MISUSE if !db, !tgt, or !fmt, any
   ** number of potential FSL_RC_OOM or db-related errors.
   **
   ** Results rows with a NULL value (resulting from an SQL NULL) are
   ** added to the list as NULL entries.
   **
   ** Each entry appended to the list is a (char *) which must
   ** be freed using fsl_free(). To easiest way to clean up
   ** the list and its contents is:
   **
   ** @code
   ** fsl_list_visit_free(tgt);
   ** @endcode
   **
   ** On error the list may be partially populated.
   **
   ** Complete example:
   ** @code
   ** fsl_list li = fsl_list_empty;
   ** int rc = fsl_db_select_slist(db, &li,
   **           "SELECT uuid FROM blob WHERE rid<20");
   ** if(!rc){
   **   fsl_size_t i;
   **   for(i = 0;i < li.used; ++i){
   **      char const * uuid = (char const *)li.list[i];
   **      fsl_fprintf(stdout, "UUID: %s\n", uuid);
   **   }
   ** }
   ** fsl_list_visit_free(&li, 1);
   ** @endcode
   **
   ** Of course fsl_list_visit() may be used to traverse the list as
   ** well, as long as the visitor expects (char [const]*) list
   ** elements.
   */
  int fsl_db_select_slist( fsl_db * db, fsl_list * tgt,
                                 char const * fmt, ... );

  /**
   ** The va_list counterpart of fsl_db_select_slist().
   */
  int fsl_db_select_slistv( fsl_db * db, fsl_list * tgt,
                            char const * fmt, va_list args );

  
#if defined(__cplusplus)
} /*extern "C"*/
#endif

#endif
/* NET_FOSSIL_SCM_LIBFOSSIL_H_INCLUDED */

int fsl_list_clear( fsl_list * self, fsl_list_visitor_f childFinalizer,
                    void * finalizerState ){
  int rc = fsl_list_visit(self, 0, childFinalizer, finalizerState );
  if(!rc) fsl_list_reserve(self, 0);
  return rc;
}

void fsl_list_visit_free( fsl_list * self, char freeListMem ){
  fsl_list_visit(self, 0, fsl_list_v_fsl_free, NULL );
  if(freeListMem) fsl_list_reserve(self, 0);
  else self->used = 0;
}


int fsl_list_visit( fsl_list const * self, char order,
                    fsl_list_visitor_f visitor,
                    void * visitorState ){
  int rc = FSL_RC_OK;
  if( self && self->used && visitor ){

      break;
    }
  }
  fsl_stmt_finalize(&q);
  return rv;
}

char * fsl_db_random_hex(fsl_db * db, fsl_size_t n){
  if(!db || !n) return NULL;
  else{
    fsl_size_t rvLen = 0;
    char * rv = fsl_db_g_text(db, &rvLen,
                              "SELECT lower(hex("
                              "randomblob(%"FSL_SIZE_T_PFMT")))",
                              n/2+1);
    if(rv){
      assert(rvLen>=n);
      rv[n]=0;
    }
    return rv;
  }
}


int fsl_db_select_slistv( fsl_db * db, fsl_list * tgt,
                          char const * fmt, va_list args ){
  if(!db || !tgt || !fmt) return FSL_RC_MISUSE;
  else if(!*fmt) return FSL_RC_RANGE;
  else{
    int rc;
    fsl_stmt st = fsl_stmt_empty;
    fsl_size_t nlen;
    char const * n;
    char * cp;
    rc = fsl_db_preparev(db, &st, fmt, args);
    while( !rc && (FSL_RC_STEP_ROW==fsl_stmt_step(&st)) ){
      nlen = 0;
      n = fsl_stmt_g_text(&st, 0, &nlen);
      cp = fsl_strndup(n, (fsl_int_t)nlen);
      if(n && !cp) rc = FSL_RC_OOM;
      else{
        rc = fsl_list_append(tgt, cp);
        if(rc) fsl_free(cp);
      }
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_select_slist( fsl_db * db, fsl_list * tgt,
                         char const * fmt, ... ){
  int rc;
  va_list va;
  va_start (va,fmt);
  rc = fsl_db_select_slistv(db, tgt, fmt, va);
  va_end(va);
  return rc;
}

#undef MARKER

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 
/* vim: set ts=2 et sw=2 tw=80: */
/*
** Copyright (c) 2013 D. Richard Hipp
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the Simplified BSD License (also
** known as the "2-Clause License" or "FreeBSD License".)
**
** This program is distributed in the hope that it will be useful,
** but without any warranty; without even the implied warranty of
** merchantability or fitness for a particular purpose.
**
** Author contact information:
**   drh@hwaci.com
**   http://www.hwaci.com/drh/
**
*******************************************************************************
** This file implements event-related parts of the library.
*/
#include "fossil-scm/fossil-internal.h"
#include <assert.h>

/* Only for debugging */
#include <stdio.h>
#define MARKER(pfexp)                                               \
  do{ printf("MARKER: %s:%d:%s():\t",__FILE__,__LINE__,__func__);   \
    printf pfexp;                                                   \
  } while(0)


int fsl_event_ids_get( fsl_cx * f, fsl_list * tgt ){
  fsl_db * db = fsl_needs_repo(f);
  if(!f || !tgt) return FSL_RC_MISUSE;
  else if(!db) return FSL_RC_NOT_A_REPO;
  else {
    int rc = fsl_db_select_slist( db, tgt,
                                  "SELECT substr(tagname,7) AS n "
                                  "FROM tag "
                                  "WHERE tagname GLOB 'event-*' "
                                  "ORDER BY n");
    if(rc && db->error.code && !f->error.code){
      fsl_cx_uplift_db_error(f, db);
    }
    return rc;
  }
}


#undef MARKER

  SFREE(uuid);
  CBUF(A.name);
  SFREE(A.tgt);
  SFREE(A.src);
  SFREE(B.uuid);
  CBUF(C);
  SFREE(E.uuid);
  fsl_list_clear(&m->F.list, fsl_list_v_fsl_mf_fcard_free, NULL);

  CBUF(L);
  fsl_list_clear(&m->J, fsl_list_v_fsl_mf_jcard_free, NULL);

  SFREE(K);
  fsl_list_visit_free(&m->M, 1);

  CBUF(N);
  fsl_list_visit_free(&m->P, 1);

  fsl_list_clear(&m->Q, fsl_list_v_fsl_mf_qcard_free, NULL);

  SFREE(R);
  fsl_list_clear(&m->T, fsl_list_v_fsl_mf_tcard_free, NULL);

  CBUF(U);
  CBUF(W);

  fsl_error_clean(&m->error);
  {
    void const * allocStampKludge = m->allocStamp;
    *m = fsl_deck_empty;

                              fsl_buffer_cstr(&d->L));
    }else{
      rc = fsl_buffer_appendf(&buf,
                              "Deleted wiki page [%h]",
                              fsl_buffer_cstr(&d->L));
    }
    if(!rc){
      fsl_db_exec(db,
      "REPLACE INTO event(type,mtime,objid,user,comment,"
      "                  bgcolor,euser,ecomment) "
      "VALUES('w',%"FSL_JULIAN_T_PFMT",%"FSL_ID_T_PFMT",%B,%B,"
      "  (SELECT value FROM tagxref "
           "WHERE tagid=%"FSL_ID_T_PFMT" AND rid=%"FSL_ID_T_PFMT
           " AND tagtype>1),"
      "  (SELECT value FROM tagxref "

    fsl_buffer buf = fsl_buffer_empty;
    fsl_id_t tagid;
    fsl_id_t prior, subsequent;
    char zLength[40] = {0};
    char const * zWiki;
    char const * zTag;
    fsl_size_t nWiki = 0;
    rc = fsl_buffer_appendf(&buf, "event-%s", d->E.uuid);
    if(rc) goto wiki_end;
    zTag = fsl_buffer_cstr(&buf);
    tagid = fsl_repo_tag_id( f, zTag, 1 );
    if(tagid<=0){
      rc = f->error.code ? f->error.code :
        fsl_cx_err_set(f, FSL_RC_RANGE,
                       "Got unexpected RID (%"FSL_ID_T_PFMT") "

      assert(db->error.code);
      rc = fsl_cx_uplift_db_error(f, db);
      goto event_end;
    }
    subsequent = fsl_db_g_id(db, 0,
                             "SELECT rid FROM tagxref"
                             " WHERE tagid=%"FSL_ID_T_PFMT
                             " AND mtime>=%"FSL_JULIAN_T_PFMT
                             " AND rid!=%"FSL_ID_T_PFMT
                             " ORDER BY mtime",
                             tagid, d->D, rid);
    if(subsequent<0){
      assert(db->error.code);
      rc = fsl_cx_uplift_db_error(f, db);
      goto event_end;
    }

  } while(0)


int fsl_wiki_names_get( fsl_cx * f, fsl_list * tgt ){
  fsl_db * db = fsl_needs_repo(f);
  if(!f || !tgt) return FSL_RC_MISUSE;
  else if(!db) return FSL_RC_NOT_A_REPO;
  else {
    int rc = fsl_db_select_slist( db, tgt,





                                  "SELECT substr(tagname,6) AS name "
                                  "FROM tag "
                                  "WHERE tagname GLOB 'wiki-*' "
                                  "ORDER BY lower(name)");











    if(rc && db->error.code && !f->error.code){
      fsl_cx_uplift_db_error(f, db);
    }
    return rc;
  }
}

int fsl_wiki_latest_rid( fsl_cx * f, char const * pageName, fsl_id_t * rid ){