/*

 ** The author disclaims copyright to this source code.

 **

 *************************************************************************

 ** Implementation of the "simple" full-text-search tokenizer.

 */

 /*

 ** The code in this file is only compiled if:

 **

 **     * The FTS1 module is being built as an extension

 **       (in which case SQLITE_CORE is not defined), or

 **

 **     * The FTS1 module is being built into the core of

 **       SQLite (in which case SQLITE_ENABLE_FTS1 is defined).

 */

 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1)

 #include <assert.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include <ctype.h>

 #include "fts1_tokenizer.h"

 typedef struct simple_tokenizer {

   sqlite3_tokenizer base;

   char delim[128];             /* flag ASCII delimiters */

 } simple_tokenizer;

 typedef struct simple_tokenizer_cursor {

   sqlite3_tokenizer_cursor base;

   const char *pInput;          /* input we are tokenizing */

   int nBytes;                  /* size of the input */

   int iOffset;                 /* current position in pInput */

   int iToken;                  /* index of next token to be returned */

   char *pToken;                /* storage for current token */

   int nTokenAllocated;         /* space allocated to zToken buffer */

 } simple_tokenizer_cursor;

 /* Forward declaration */

 static const sqlite3_tokenizer_module simpleTokenizerModule;

 static int isDelim(simple_tokenizer *t, unsigned char c){

   return c<0x80 && t->delim[c];

 }

 /*

 ** Create a new tokenizer instance.

 */

 static int simpleCreate(

   int argc, const char * const *argv,

   sqlite3_tokenizer **ppTokenizer

 ){

   simple_tokenizer *t;

   t = (simple_tokenizer *) calloc(sizeof(*t), 1);

   if( t==NULL ) return SQLITE_NOMEM;

   /* TODO(shess) Delimiters need to remain the same from run to run,

   ** else we need to reindex.  One solution would be a meta-table to

   ** track such information in the database, then we'd only want this

   ** information on the initial create.

   */

   if( argc>1 ){

     int i, n = strlen(argv[1]);

     for(i=0; i<n; i++){

       unsigned char ch = argv[1][i];

       /* We explicitly don't support UTF-8 delimiters for now. */

       if( ch>=0x80 ){

         free(t);

         return SQLITE_ERROR;

       }

       t->delim[ch] = 1;

     }

   } else {

     /* Mark non-alphanumeric ASCII characters as delimiters */

     int i;

     for(i=1; i<0x80; i++){

       t->delim[i] = !isalnum(i);

     }

   }

   *ppTokenizer = &t->base;

   return SQLITE_OK;

 }

 /*

 ** Destroy a tokenizer

 */

 static int simpleDestroy(sqlite3_tokenizer *pTokenizer){

   free(pTokenizer);

   return SQLITE_OK;

 }

 /*

 ** Prepare to begin tokenizing a particular string.  The input

 ** string to be tokenized is pInput[0..nBytes-1].  A cursor

 ** used to incrementally tokenize this string is returned in 

 ** *ppCursor.

 */

 static int simpleOpen(

   sqlite3_tokenizer *pTokenizer,         /* The tokenizer */

   const char *pInput, int nBytes,        /* String to be tokenized */

   sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */

 ){

   simple_tokenizer_cursor *c;

   c = (simple_tokenizer_cursor *) malloc(sizeof(*c));

   if( c==NULL ) return SQLITE_NOMEM;

   c->pInput = pInput;

   if( pInput==0 ){

     c->nBytes = 0;

   }else if( nBytes<0 ){

     c->nBytes = (int)strlen(pInput);

   }else{

     c->nBytes = nBytes;

   }

   c->iOffset = 0;                 /* start tokenizing at the beginning */

   c->iToken = 0;

   c->pToken = NULL;               /* no space allocated, yet. */

   c->nTokenAllocated = 0;

   *ppCursor = &c->base;

   return SQLITE_OK;

 }

 /*

 ** Close a tokenization cursor previously opened by a call to

 ** simpleOpen() above.

 */

 static int simpleClose(sqlite3_tokenizer_cursor *pCursor){

   simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;

   free(c->pToken);

   free(c);

   return SQLITE_OK;

 }

 /*

 ** Extract the next token from a tokenization cursor.  The cursor must

 ** have been opened by a prior call to simpleOpen().

 */

 static int simpleNext(

   sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */

   const char **ppToken,               /* OUT: *ppToken is the token text */

   int *pnBytes,                       /* OUT: Number of bytes in token */

   int *piStartOffset,                 /* OUT: Starting offset of token */

   int *piEndOffset,                   /* OUT: Ending offset of token */

   int *piPosition                     /* OUT: Position integer of token */

 ){

   simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;

   simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;

   unsigned char *p = (unsigned char *)c->pInput;

   while( c->iOffset<c->nBytes ){

     int iStartOffset;

     /* Scan past delimiter characters */

     while( c->iOffset<c->nBytes && isDelim(t, p[c->iOffset]) ){

       c->iOffset++;

     }

     /* Count non-delimiter characters. */

     iStartOffset = c->iOffset;

     while( c->iOffset<c->nBytes && !isDelim(t, p[c->iOffset]) ){

       c->iOffset++;

     }

     if( c->iOffset>iStartOffset ){

       int i, n = c->iOffset-iStartOffset;

       if( n>c->nTokenAllocated ){

         c->nTokenAllocated = n+20;

         c->pToken = realloc(c->pToken, c->nTokenAllocated);

         if( c->pToken==NULL ) return SQLITE_NOMEM;

       }

       for(i=0; i<n; i++){

         /* TODO(shess) This needs expansion to handle UTF-8

         ** case-insensitivity.

         */

         unsigned char ch = p[iStartOffset+i];

         c->pToken[i] = ch<0x80 ? tolower(ch) : ch;

       }

       *ppToken = c->pToken;

       *pnBytes = n;

       *piStartOffset = iStartOffset;

       *piEndOffset = c->iOffset;

       *piPosition = c->iToken++;

       return SQLITE_OK;

     }

   }

   return SQLITE_DONE;

 }

 /*

 ** The set of routines that implement the simple tokenizer

 */

 static const sqlite3_tokenizer_module simpleTokenizerModule = {

   0,

   simpleCreate,

   simpleDestroy,

   simpleOpen,

   simpleClose,

   simpleNext,

 };

 /*

 ** Allocate a new simple tokenizer.  Return a pointer to the new

 ** tokenizer in *ppModule

 */

 void sqlite3Fts1SimpleTokenizerModule(

   sqlite3_tokenizer_module const**ppModule

 ){

   *ppModule = &simpleTokenizerModule;

 }

 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1) */