自学教程：C++ sqlite3_realloc函数代码示例

/* Resize the opcode and argument arrays for an RE under construction.*/static int re_resize(ReCompiled *p, int N){  char *aOp;  int *aArg;  aOp = sqlite3_realloc(p->aOp, N*sizeof(p->aOp[0]));  if( aOp==0 ) return 1;  p->aOp = aOp;  aArg = sqlite3_realloc(p->aArg, N*sizeof(p->aArg[0]));  if( aArg==0 ) return 1;  p->aArg = aArg;  p->nAlloc = N;  return 0;}

/*** Enlarge a memory allocation.  If an out-of-memory allocation occurs,** then free the old allocation.*/static void *fts3ReallocOrFree(void *pOrig, int nNew){  void *pRet = sqlite3_realloc(pOrig, nNew);  if( !pRet ){    sqlite3_free(pOrig);  }  return pRet;}

/*** Extract the next token from a tokenization cursor.  The cursor must** have been opened by a prior call to simpleOpen().从一个标记化的游标中提取下一个标记。这个游标必须被先前的函数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 && simpleDelim(t, p[c->iOffset]) ){      c->iOffset++;    }    /*	Count non-delimiter characters.	计算非定界字符	*/    iStartOffset = c->iOffset;    while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){      c->iOffset++;    }    if( c->iOffset>iStartOffset ){      int i, n = c->iOffset-iStartOffset;      if( n>c->nTokenAllocated ){        char *pNew;        c->nTokenAllocated = n+20;        pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated);        if( !pNew ) return SQLITE_NOMEM;        c->pToken = pNew;      }      for(i=0; i<n; i++){        /* TODO(shess) This needs expansion to handle UTF-8        ** case-insensitivity.		这需要去扩展到不灵敏的UTF-8编码	        */        unsigned char ch = p[iStartOffset+i];        c->pToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch);      }      *ppToken = c->pToken;      *pnBytes = n;      *piStartOffset = iStartOffset;      *piEndOffset = c->iOffset;      *piPosition = c->iToken++;      return SQLITE_OK;    }  }  return SQLITE_DONE;}

/*** Fill in the azDb[] array for the cursor.*/static int memstatFindSchemas(memstat_cursor *pCur){  sqlite3_stmt *pStmt = 0;  int rc;  if( pCur->nDb ) return SQLITE_OK;  rc = sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pStmt, 0);  if( rc ){    sqlite3_finalize(pStmt);    return rc;  }  while( sqlite3_step(pStmt)==SQLITE_ROW ){    char **az, *z;    az = sqlite3_realloc(pCur->azDb, sizeof(char*)*(pCur->nDb+1));    if( az==0 ){      memstatClearSchema(pCur);      return SQLITE_NOMEM;    }    pCur->azDb = az;    z = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));    if( z==0 ){      memstatClearSchema(pCur);      return SQLITE_NOMEM;    }    pCur->azDb[pCur->nDb] = z;    pCur->nDb++;  }  sqlite3_finalize(pStmt);  return SQLITE_OK;}

/*** Resize the block of memory pointed to by p to n bytes. If the** resize fails, set the mallocFailed flag in the connection object.*/void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){  void *pNew = 0;  assert( db!=0 );  assert( sqlite3_mutex_held(db->mutex) );  if( db->mallocFailed==0 ){    if( p==0 ){      return sqlite3DbMallocRaw(db, n);    }    if( isLookaside(db, p) ){      if( n<=db->lookaside.sz ){        return p;      }      pNew = sqlite3DbMallocRaw(db, n);      if( pNew ){        memcpy(pNew, p, db->lookaside.sz);        sqlite3DbFree(db, p);      }    }else{      pNew = sqlite3_realloc(p, n);      if( !pNew ){        db->mallocFailed = 1;      }    }  }  return pNew;}

/*** Resize the block of memory pointed to by p to n bytes. If the** resize fails, set the mallocFailed flag in the connection object.*/void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){  void *pNew = 0;  assert( db!=0 );  assert( sqlite3_mutex_held(db->mutex) );  if( db->mallocFailed==0 ){    if( p==0 ){      return sqlite3DbMallocRaw(db, n);    }    if( isLookaside(db, p) ){      if( n<=db->lookaside.sz ){        return p;      }      pNew = sqlite3DbMallocRaw(db, n);      if( pNew ){        memcpy(pNew, p, db->lookaside.sz);        sqlite3DbFree(db, p);      }    }else{      assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );      assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );      sqlite3MemdebugSetType(p, MEMTYPE_HEAP);      pNew = sqlite3_realloc(p, n);      if( !pNew ){        sqlite3MemdebugSetType(p, MEMTYPE_DB|MEMTYPE_HEAP);        db->mallocFailed = 1;      }      sqlite3MemdebugSetType(pNew, MEMTYPE_DB |             (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));    }  }  return pNew;}

/*** Callback from sqlite_exec() for the eval() function.*/static int callback(void *pCtx, int argc, char **argv, char **colnames){  struct EvalResult *p = (struct EvalResult*)pCtx;  int i;   if( argv==0 ) return 0;  for(i=0; i<argc; i++){    const char *z = argv[i] ? argv[i] : "";    size_t sz = strlen(z);    if( (sqlite3_int64)sz+p->nUsed+p->szSep+1 > p->nAlloc ){      char *zNew;      p->nAlloc = p->nAlloc*2 + sz + p->szSep + 1;      /* Using sqlite3_realloc64() would be better, but it is a recent      ** addition and will cause a segfault if loaded by an older version      ** of SQLite.  */      zNew = p->nAlloc<=0x7fffffff ? sqlite3_realloc(p->z, (int)p->nAlloc) : 0;      if( zNew==0 ){        sqlite3_free(p->z);        memset(p, 0, sizeof(*p));        return 1;      }      p->z = zNew;    }    if( p->nUsed>0 ){      memcpy(&p->z[p->nUsed], p->zSep, p->szSep);      p->nUsed += p->szSep;    }    memcpy(&p->z[p->nUsed], z, sz);    p->nUsed += sz;  }  return 0;}

int sqlite3Fts3InitTokenizer(  Fts3Hash *pHash,                /* Tokenizer hash table */  const char *zArg,               /* Tokenizer name */  sqlite3_tokenizer **ppTok,      /* OUT: Tokenizer (if applicable) */  char **pzErr                    /* OUT: Set to malloced error message */){  int rc;  char *z = (char *)zArg;  int n = 0;  char *zCopy;  char *zEnd;                     /* Pointer to nul-term of zCopy */  sqlite3_tokenizer_module *m;  zCopy = sqlite3_mprintf("%s", zArg);  if( !zCopy ) return SQLITE_NOMEM;  zEnd = &zCopy[strlen(zCopy)];  z = (char *)sqlite3Fts3NextToken(zCopy, &n);  if( z==0 ){    assert( n==0 );    z = zCopy;  }  z[n] = '/0';  sqlite3Fts3Dequote(z);  m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);  if( !m ){    sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", z);    rc = SQLITE_ERROR;  }else{    char const **aArg = 0;    int iArg = 0;    z = &z[n+1];    while( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){      int nNew = sizeof(char *)*(iArg+1);      char const **aNew = (const char **)sqlite3_realloc((void *)aArg, nNew);      if( !aNew ){        sqlite3_free(zCopy);        sqlite3_free((void *)aArg);        return SQLITE_NOMEM;      }      aArg = aNew;      aArg[iArg++] = z;      z[n] = '/0';      sqlite3Fts3Dequote(z);      z = &z[n+1];    }    rc = m->xCreate(iArg, aArg, ppTok);    assert( rc!=SQLITE_OK || *ppTok );    if( rc!=SQLITE_OK ){      sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer");    }else{      (*ppTok)->pModule = m;     }    sqlite3_free((void *)aArg);  }  sqlite3_free(zCopy);  return rc;}

/* ** Register a statically linked extension that is automatically ** loaded by every new database connection. */SQLITE_API int sqlite3_auto_extension(void (*xInit)(void)){    int rc = SQLITE_OK;#ifndef SQLITE_OMIT_AUTOINIT    rc = sqlite3_initialize();    if( rc ){        return rc;    }else#endif    {        int i;#if SQLITE_THREADSAFE        sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);#endif        wsdAutoextInit;        sqlite3_mutex_enter(mutex);        for(i=0; i<wsdAutoext.nExt; i++){            if( wsdAutoext.aExt[i]==xInit ) break;        }        if( i==wsdAutoext.nExt ){            int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);            void (**aNew)(void);            aNew = sqlite3_realloc(wsdAutoext.aExt, nByte);            if( aNew==0 ){                rc = SQLITE_NOMEM;            }else{                wsdAutoext.aExt = aNew;                wsdAutoext.aExt[wsdAutoext.nExt] = xInit;                wsdAutoext.nExt++;            }        }        sqlite3_mutex_leave(mutex);        assert( (rc&0xff)==rc );        return rc;    }}

int sqlite3Fts3InitTokenizer(  Fts3Hash *pHash,                  const char *zArg,                 sqlite3_tokenizer **ppTok,        char **pzErr                    ){  int rc;  char *z = (char *)zArg;  int n;  char *zCopy;  char *zEnd;                       sqlite3_tokenizer_module *m;  zCopy = sqlite3_mprintf("%s", zArg);  if( !zCopy ) return SQLITE_NOMEM;  zEnd = &zCopy[strlen(zCopy)];  z = (char *)sqlite3Fts3NextToken(zCopy, &n);  z[n] = '/0';  sqlite3Fts3Dequote(z);  m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);  if( !m ){    *pzErr = sqlite3_mprintf("unknown tokenizer: %s", z);    rc = SQLITE_ERROR;  }else{    char const **aArg = 0;    int iArg = 0;    z = &z[n+1];    while( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){      int nNew = sizeof(char *)*(iArg+1);      char const **aNew = (const char **)sqlite3_realloc((void *)aArg, nNew);      if( !aNew ){        sqlite3_free(zCopy);        sqlite3_free((void *)aArg);        return SQLITE_NOMEM;      }      aArg = aNew;      aArg[iArg++] = z;      z[n] = '/0';      sqlite3Fts3Dequote(z);      z = &z[n+1];    }    rc = m->xCreate(iArg, aArg, ppTok);    assert( rc!=SQLITE_OK || *ppTok );    if( rc!=SQLITE_OK ){      *pzErr = sqlite3_mprintf("unknown tokenizer");    }else{      (*ppTok)->pModule = m;     }    sqlite3_free((void *)aArg);  }  sqlite3_free(zCopy);  return rc;}

/*** Implementations of scalar functions for case mapping - upper() and ** lower(). Function upper() converts its input to upper-case (ABC).** Function lower() converts to lower-case (abc).**** ICU provides two types of case mapping, "general" case mapping and** "language specific". Refer to ICU documentation for the differences** between the two.**** To utilise "general" case mapping, the upper() or lower() scalar ** functions are invoked with one argument:****     upper('ABC') -> 'abc'**     lower('abc') -> 'ABC'**** To access ICU "language specific" case mapping, upper() or lower()** should be invoked with two arguments. The second argument is the name** of the locale to use. Passing an empty string ("") or SQL NULL value** as the second argument is the same as invoking the 1 argument version** of upper() or lower().****     lower('I', 'en_us') -> 'i'**     lower('I', 'tr_tr') -> '/u131' (small dotless i)**** http://www.icu-project.org/userguide/posix.html#case_mappings*/static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){  const UChar *zInput;            /* Pointer to input string */  UChar *zOutput = 0;             /* Pointer to output buffer */  int nInput;                     /* Size of utf-16 input string in bytes */  int nOut;                       /* Size of output buffer in bytes */  int cnt;  int bToUpper;                   /* True for toupper(), false for tolower() */  UErrorCode status;  const char *zLocale = 0;  assert(nArg==1 || nArg==2);  bToUpper = (sqlite3_user_data(p)!=0);  if( nArg==2 ){    zLocale = (const char *)sqlite3_value_text(apArg[1]);  }  zInput = sqlite3_value_text16(apArg[0]);  if( !zInput ){    return;  }  nOut = nInput = sqlite3_value_bytes16(apArg[0]);  if( nOut==0 ){    sqlite3_result_text16(p, "", 0, SQLITE_STATIC);    return;  }  for(cnt=0; cnt<2; cnt++){    UChar *zNew = sqlite3_realloc(zOutput, nOut);    if( zNew==0 ){      sqlite3_free(zOutput);      sqlite3_result_error_nomem(p);      return;    }    zOutput = zNew;    status = U_ZERO_ERROR;    if( bToUpper ){      nOut = 2*u_strToUpper(zOutput,nOut/2,zInput,nInput/2,zLocale,&status);    }else{      nOut = 2*u_strToLower(zOutput,nOut/2,zInput,nInput/2,zLocale,&status);    }    if( U_SUCCESS(status) ){      sqlite3_result_text16(p, zOutput, nOut, xFree);    }else if( status==U_BUFFER_OVERFLOW_ERROR ){      assert( cnt==0 );      continue;    }else{      icuFunctionError(p, bToUpper ? "u_strToUpper" : "u_strToLower", status);    }    return;  }  assert( 0 );     /* Unreachable */}

extern void pg_string_agg_step(sqlite3_context *context,                             int              argc,                             sqlite3_value  **argv) {  STRING_AGG_CONTEXT_T *ctx;  char                 *s;  int                   slen;  char                 *sep;  int                   seplen;  _ksu_null_if_null_param(argc, argv);  if (sqlite3_value_type(argv[0]) == SQLITE_BLOB) {    slen = sqlite3_value_bytes(argv[0]);    seplen = sqlite3_value_bytes(argv[1]);    s = (char *)sqlite3_value_text(argv[0]);    sep = (char *)sqlite3_value_text(argv[1]);  } else {    s = (char *)sqlite3_value_text(argv[0]);    sep = (char *)sqlite3_value_text(argv[1]);    slen = strlen(s);    seplen = strlen(sep);  }  ctx = (STRING_AGG_CONTEXT_T *)sqlite3_aggregate_context(context,                              sizeof(STRING_AGG_CONTEXT_T));  if (ctx) {    if (ctx->sz == 0) {      if ((ctx->aggr = (char *)sqlite3_malloc((1 + (slen+seplen)/CHUNK)                                 *  CHUNK))               == (char *)NULL) {        sqlite3_result_error_nomem(context);        return;      }      ctx->sz = (1 + (slen+seplen)/CHUNK) * CHUNK;      memcpy(ctx->aggr, s, slen);      ctx->len = slen;    } else {      if ((ctx->len + seplen + slen) > ctx->sz) {        if ((ctx->aggr = (char *)sqlite3_realloc(ctx->aggr,                             ctx->sz + (1 + (slen+seplen)/CHUNK)                                 *  CHUNK))               == (char *)NULL) {          sqlite3_result_error_nomem(context);          return;        }        ctx->sz += (1 + (slen+seplen)/CHUNK) * CHUNK;      }      memcpy(&(ctx->aggr[ctx->len]), sep, seplen);      ctx->len += seplen;      memcpy(&(ctx->aggr[ctx->len]), s, slen);      ctx->len += slen;    }  }}

/* Append n bytes of text to a string.  If n<0 append the entire string. */static void stringAppend(String *p, const char *z, int n){  if( n<0 ) n = (int)strlen(z);  if( p->n+n>=p->nAlloc ){    int nAlloc = p->nAlloc*2 + n + 100;    char *z = sqlite3_realloc(p->z, nAlloc);    if( z==0 ) fatalError("out of memory");    p->z = z;    p->nAlloc = nAlloc;  }  memcpy(p->z+p->n, z, n);  p->n += n;  p->z[p->n] = 0;}

/*** As part of a tokenchars= or separators= option, the CREATE VIRTUAL TABLE** statement has specified that the tokenizer for this table shall consider** all characters in string zIn/nIn to be separators (if bAlnum==0) or** token characters (if bAlnum==1).**** For each codepoint in the zIn/nIn string, this function checks if the** sqlite3FtsUnicodeIsalnum() function already returns the desired result.** If so, no action is taken. Otherwise, the codepoint is added to the ** unicode_tokenizer.aiException[] array. For the purposes of tokenization,** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all** codepoints in the aiException[] array.**** If a standalone diacritic mark (one that sqlite3FtsUnicodeIsdiacritic()** identifies as a diacritic) occurs in the zIn/nIn string it is ignored.** It is not possible to change the behaviour of the tokenizer with respect** to these codepoints.*/static int unicodeAddExceptions(  unicode_tokenizer *p,           /* Tokenizer to add exceptions to */  int bAlnum,                     /* Replace Isalnum() return value with this */  const char *zIn,                /* Array of characters to make exceptions */  int nIn                         /* Length of z in bytes */){  const unsigned char *z = (const unsigned char *)zIn;  const unsigned char *zTerm = &z[nIn];  int iCode;  int nEntry = 0;  assert( bAlnum==0 || bAlnum==1 );  while( z<zTerm ){    READ_UTF8(z, zTerm, iCode);    assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 );    if( sqlite3FtsUnicodeIsalnum(iCode)!=bAlnum      && sqlite3FtsUnicodeIsdiacritic(iCode)==0     ){      nEntry++;    }  }  if( nEntry ){    int *aNew;                    /* New aiException[] array */    int nNew;                     /* Number of valid entries in array aNew[] */    aNew = sqlite3_realloc(p->aiException, (p->nException+nEntry)*sizeof(int));    if( aNew==0 ) return SQLITE_NOMEM;    nNew = p->nException;    z = (const unsigned char *)zIn;    while( z<zTerm ){      READ_UTF8(z, zTerm, iCode);      if( sqlite3FtsUnicodeIsalnum(iCode)!=bAlnum        && sqlite3FtsUnicodeIsdiacritic(iCode)==0      ){        int i, j;        for(i=0; i<nNew && aNew[i]<iCode; i++);        for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];        aNew[i] = iCode;        nNew++;      }    }    p->aiException = aNew;    p->nException = nNew;  }  return SQLITE_OK;}

/*** Add memory block to the end of a Block object*/int mem2mem(Block *p, const char * z, int n){	for (;;){		if (p->z && p->nUsed + n < p->nAlloc - 1) {			memcpy(p->z + p->nUsed, z, n);			p->nUsed += n;			break;		}		p->nAlloc = p->nAlloc * 2 + 1000;		p->z = sqlite3_realloc(p->z, p->nAlloc);		if (!p->z) break;	}	return !!p->z;}

static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){  if( nSize>pCsr->nStat ){    struct Fts3auxColstats *aNew;    aNew = (struct Fts3auxColstats *)sqlite3_realloc(pCsr->aStat,         sizeof(struct Fts3auxColstats) * nSize    );    if( aNew==0 ) return SQLITE_NOMEM;    memset(&aNew[pCsr->nStat], 0,         sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)    );    pCsr->aStat = aNew;    pCsr->nStat = nSize;  }  return SQLITE_OK;}

/*** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]** array so that an OP_VBegin will get generated for it.  Add pTab to the** array if it is missing.  If pTab is already in the array, this routine** is a no-op.*/void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){  int i, n;  Table **apVtabLock;  assert( IsVirtual(pTab) );  for(i=0; i<pParse->nVtabLock; i++){    if( pTab==pParse->apVtabLock[i] ) return;  }  n = (pParse->nVtabLock+1)*sizeof(pParse->apVtabLock[0]);  apVtabLock = sqlite3_realloc(pParse->apVtabLock, n);  if( apVtabLock ){    pParse->apVtabLock = apVtabLock;    pParse->apVtabLock[pParse->nVtabLock++] = pTab;  }else{    pParse->db->mallocFailed = 1;  }}

static int fts5UnicodeAddExceptions(  Unicode61Tokenizer *p,          /* Tokenizer object */  const char *z,                  /* Characters to treat as exceptions */  int bTokenChars                 /* 1 for 'tokenchars', 0 for 'separators' */){  int rc = SQLITE_OK;  int n = strlen(z);  int *aNew;  if( n>0 ){    aNew = (int*)sqlite3_realloc(p->aiException, (n+p->nException)*sizeof(int));    if( aNew ){      int nNew = p->nException;      const unsigned char *zCsr = (const unsigned char*)z;      const unsigned char *zTerm = (const unsigned char*)&z[n];      while( zCsr<zTerm ){        int iCode;        int bToken;        READ_UTF8(zCsr, zTerm, iCode);        if( iCode<128 ){          p->aTokenChar[iCode] = bTokenChars;        }else{          bToken = sqlite3Fts5UnicodeIsalnum(iCode);          assert( (bToken==0 || bToken==1) );           assert( (bTokenChars==0 || bTokenChars==1) );          if( bToken!=bTokenChars && sqlite3Fts5UnicodeIsdiacritic(iCode)==0 ){            int i;            for(i=0; i<nNew; i++){              if( aNew[i]>iCode ) break;            }            memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));            aNew[i] = iCode;            nNew++;          }        }      }      p->aiException = aNew;      p->nException = nNew;    }else{      rc = SQLITE_NOMEM;    }  }  return rc;}

/* * Custom memory allocator helper for Lua, based on SQLite memory management API * ud - FlexiliteContext_t* */static void *lua_alloc_handler(void *ud, void *ptr, size_t osize, size_t nsize){    if (ptr == nullptr)    {        // Allocating new object. osize is a type of new object        return sqlite3_malloc((int) nsize);    }    if (nsize == 0)    {        // Delete existing object        sqlite3_free(ptr);        return nullptr;    }    // Reallocating existing object    return sqlite3_realloc(ptr, (int) nsize);}

/*** Extract the next token from a tokenization cursor.  The cursor must** have been opened by a prior call to porterOpen().*/static int porterNext(  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by porterOpen */  const char **pzToken,               /* OUT: *pzToken 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 */){  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;  const char *z = c->zInput;  while( c->iOffset<c->nInput ){    int iStartOffset, ch;    /* Scan past delimiter characters */    while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){      c->iOffset++;    }    /* Count non-delimiter characters. */    iStartOffset = c->iOffset;    while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){      c->iOffset++;    }    if( c->iOffset>iStartOffset ){      int n = c->iOffset-iStartOffset;      if( n>c->nAllocated ){        char *pNew;        c->nAllocated = n+20;        pNew = sqlite3_realloc(c->zToken, c->nAllocated);        if( !pNew ) return SQLITE_NOMEM;        c->zToken = pNew;      }      porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);      *pzToken = c->zToken;      *piStartOffset = iStartOffset;      *piEndOffset = c->iOffset;      *piPosition = c->iToken++;      return SQLITE_OK;    }  }  return SQLITE_DONE;}

static voidsFactoryAddSpace (  MQ_SIZE const add){  register MQ_SIZE newsize = space.used + add;  if (newsize <= space.size)    return;  // add extra space  newsize *= 2;  // alloc new space  space.items = (struct MqFactoryS *)	sqlite3_realloc (space.items, (newsize * sizeof (*space.items)));  memset(space.items+space.used, '/0', newsize-space.used);  space.size = newsize;}

/*** Append a result character if the character is not already in the** result.*/static void nextCharAppend(nextCharContext *p, unsigned c) {    int i;    for(i=0; i<p->nUsed; i++) {        if( p->aResult[i]==c ) return;    }    if( p->nUsed+1 > p->nAlloc ) {        unsigned int *aNew;        int n = p->nAlloc*2 + 30;        aNew = sqlite3_realloc(p->aResult, n*sizeof(unsigned int));        if( aNew==0 ) {            p->mallocFailed = 1;            return;        } else {            p->aResult = aNew;            p->nAlloc = n;        }    }    p->aResult[p->nUsed++] = c;}

/* *   Doesn't exactly behaves as the PostgreSQL version as a / *   leaves sqlite completely cold. Serves, however, the *   same purpose, which is making data extracted from the *   database usable in a statement. */extern void pg_quote_literal(sqlite3_context * context,                             int               argc,                             sqlite3_value  ** argv) {  int   len;  char *str;  char *result = (char *)NULL;  int   resultsz;  int   i;  int   j;  _ksu_null_if_null_param(argc, argv);  len = sqlite3_value_bytes(argv[0]);  str = (char *)sqlite3_value_blob(argv[0]);  if ((result = (char *)sqlite3_malloc(len + SAFETY_MARGIN + 1))        == (char *)NULL) {    sqlite3_result_error_nomem(context);    return;  }  resultsz = len + SAFETY_MARGIN;  *result = '/'';  j = 1;  for (i = 0; i < len; i++) {    switch (str[i]) {      case '/'':     // Escape quote           result[j++] = '/'';           break;      default :           break;    }    result[j++] = str[i];    if (j >= resultsz - 2) { // Time to realloc      if ((result = (char *)sqlite3_realloc(result,                               resultsz + SAFETY_MARGIN + 1))            == (char *)NULL) {        sqlite3_result_error_nomem(context);        return;      }      resultsz += SAFETY_MARGIN;    }  }  result[j++] = '/'';  sqlite3_result_text(context, result, j, sqlite3_free);}

/*** Write data to a tmp-file.*/static int tmpWrite(  sqlite3_file *pFile,   const void *zBuf,   int iAmt,   sqlite_int64 iOfst){  tmp_file *pTmp = (tmp_file *)pFile;  if( (iAmt+iOfst)>pTmp->nAlloc ){    int nNew = (int)(2*(iAmt+iOfst+pTmp->nAlloc));    char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew);    if( !zNew ){      return SQLITE_NOMEM;    }    pTmp->zAlloc = zNew;    pTmp->nAlloc = nNew;  }  memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt);  pTmp->nSize = (int)MAX(pTmp->nSize, iOfst+iAmt);  return SQLITE_OK;}

int sqlite3Fts5BufferGrow(int *pRc, Fts5Buffer *pBuf, int nByte){  /* A no-op if an error has already occurred */  if( *pRc ) return 1;  if( (pBuf->n + nByte) > pBuf->nSpace ){    u8 *pNew;    int nNew = pBuf->nSpace ? pBuf->nSpace*2 : 64;    while( nNew<(pBuf->n + nByte) ){      nNew = nNew * 2;    }    pNew = sqlite3_realloc(pBuf->p, nNew);    if( pNew==0 ){      *pRc = SQLITE_NOMEM;      return 1;    }else{      pBuf->nSpace = nNew;      pBuf->p = pNew;    }  }  return 0;}

/*** Advance a CsvCursor to its next row of input.** Set the EOF marker if we reach the end of input.*/static int csvtabNext(sqlite3_vtab_cursor *cur){  CsvCursor *pCur = (CsvCursor*)cur;  CsvTable *pTab = (CsvTable*)cur->pVtab;  int i = 0;  char *z;  do{    z = csv_read_one_field(&pCur->rdr);    if( z==0 ){      csv_xfer_error(pTab, &pCur->rdr);      break;    }    if( i<pTab->nCol ){      if( pCur->aLen[i] < pCur->rdr.n+1 ){        char *zNew = sqlite3_realloc(pCur->azVal[i], pCur->rdr.n+1);        if( zNew==0 ){          csv_errmsg(&pCur->rdr, "out of memory");          csv_xfer_error(pTab, &pCur->rdr);          break;        }        pCur->azVal[i] = zNew;        pCur->aLen[i] = pCur->rdr.n+1;      }      memcpy(pCur->azVal[i], z, pCur->rdr.n+1);      i++;    }  }while( pCur->rdr.cTerm==',' );  while( i<pTab->nCol ){    sqlite3_free(pCur->azVal[i]);    pCur->azVal[i] = 0;    pCur->aLen[i] = 0;    i++;  }  if( z==0 || pCur->rdr.cTerm==EOF ){    pCur->iRowid = -1;  }else{    pCur->iRowid++;  }  return SQLITE_OK;}

/* Compute the filename for the iChunk-th chunk*/static int multiplexSubFilename(multiplexGroup *pGroup, int iChunk){  if( iChunk>=pGroup->nReal ){    struct multiplexReal *p;    p = sqlite3_realloc(pGroup->aReal, (iChunk+1)*sizeof(*p));    if( p==0 ){      return SQLITE_NOMEM;    }    memset(&p[pGroup->nReal], 0, sizeof(p[0])*(iChunk+1-pGroup->nReal));    pGroup->aReal = p;    pGroup->nReal = iChunk+1;  }  if( pGroup->zName && pGroup->aReal[iChunk].z==0 ){    char *z;    int n = pGroup->nName;    pGroup->aReal[iChunk].z = z = sqlite3_malloc( n+5 );    if( z==0 ){      return SQLITE_NOMEM;    }    multiplexFilename(pGroup->zName, pGroup->nName, pGroup->flags, iChunk, z);  }  return SQLITE_OK;}

/*** Append a value to a result set.  zValue is copied into memory obtained** from malloc.  Or if zValue is NULL, then a NULL pointer is appended.*/static void appendValue(ResAccum *p, const char *zValue){  char *z;  if( zValue ){    z = sqlite3_mprintf("%s", zValue);    if( z==0 ){      fprintf(stderr, "out of memory at %s:%d/n", __FILE__,__LINE__);      exit(1);    }  }else{    z = 0;  }  if( p->nUsed>=p->nAlloc ){    char **az;    p->nAlloc += 200;    az = sqlite3_realloc(p->azValue, p->nAlloc*sizeof(p->azValue[0]));    if( az==0 ){      fprintf(stderr, "out of memory at %s:%d/n", __FILE__,__LINE__);      exit(1);    }    p->azValue = az;  }  p->azValue[p->nUsed++] = z;}

/*** Write data to a crash-file.*/static int cfWrite(  sqlite3_file *pFile,   const void *zBuf,   int iAmt,   sqlite_int64 iOfst){  CrashFile *pCrash = (CrashFile *)pFile;  if( iAmt+iOfst>pCrash->iSize ){    pCrash->iSize = iAmt+iOfst;  }  while( pCrash->iSize>pCrash->nData ){    u8 *zNew;    int nNew = (pCrash->nData*2) + 4096;    zNew = sqlite3_realloc(pCrash->zData, nNew);    if( !zNew ){      return SQLITE_NOMEM;    }    memset(&zNew[pCrash->nData], 0, nNew-pCrash->nData);    pCrash->nData = nNew;    pCrash->zData = zNew;  }  memcpy(&pCrash->zData[iOfst], zBuf, iAmt);  return writeListAppend(pFile, iOfst, zBuf, iAmt);}

/*** Add formatted text to the end of a Block object*/int strPrintf(Block *p, const char *zFormat, ...){	int nNew;	for (;;){		if (p->z){			va_list ap;			va_start(ap, zFormat);			sqlite3_vsnprintf(p->nAlloc - p->nUsed, p->z + p->nUsed, zFormat, ap);			va_end(ap);			nNew = (int)strlen(p->z + p->nUsed);		}		else{			nNew = p->nAlloc;		}		if (p->nUsed + nNew < p->nAlloc - 1){			p->nUsed += nNew;			break;		}		p->nAlloc = p->nAlloc * 2 + 1000;		p->z = sqlite3_realloc(p->z, p->nAlloc);		if (!p->z) break;	}	return !!p->z;}