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

qPBReader::qPBReader(int & argc, char ** argv) :   QApplication(argc, argv),   _bGlobalConfMode(false),   _pViewer(0),   _pConfigDialog(0){   TRSCOPE(app, "qPBReader::qPBReader");   if (TRACEON)   {      TRACE << "Current dir " << ENC(QDir::currentPath()) << endl;      TRACE << "argc=" << argc << endl;      for (int idx = 0; idx < argc; idx++)      {         TRACE << idx << ": " << ENC(argv[idx]) << endl;      }   }   QString sLangFile = QCoreApplication::applicationFilePath() +                       "_" +                       qPBReaderConfig::GetApplicationLanguage();   TRACE << VAR(sLangFile) << endl;   _translator.load(sLangFile);   installTranslator(&_translator);}

static int dss_openssh_fmtkey(void *key, unsigned char *blob, int len){    struct dss_key *dss = (struct dss_key *) key;    int bloblen, i;    bloblen =	ssh2_bignum_length(dss->p) +	ssh2_bignum_length(dss->q) +	ssh2_bignum_length(dss->g) +	ssh2_bignum_length(dss->y) +	ssh2_bignum_length(dss->x);    if (bloblen > len)	return bloblen;    bloblen = 0;#define ENC(x) /    PUT_32BIT(blob+bloblen, ssh2_bignum_length((x))-4); bloblen += 4; /    for (i = ssh2_bignum_length((x))-4; i-- ;) blob[bloblen++]=bignum_byte((x),i);    ENC(dss->p);    ENC(dss->q);    ENC(dss->g);    ENC(dss->y);    ENC(dss->x);    return bloblen;}

static void test_destructor(  sqlite3_context *pCtx,   int nArg,  sqlite3_value **argv){  char *zVal;  int len;  sqlite3 *db = sqlite3_user_data(pCtx);   test_destructor_count_var++;  assert( nArg==1 );  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;  len = sqlite3ValueBytes(argv[0], ENC(db));   zVal = sqliteMalloc(len+3);  zVal[len] = 0;  zVal[len-1] = 0;  assert( zVal );  zVal++;  memcpy(zVal, sqlite3ValueText(argv[0], ENC(db)), len);  if( ENC(db)==SQLITE_UTF8 ){    sqlite3_result_text(pCtx, zVal, -1, destructor);#ifndef SQLITE_OMIT_UTF16  }else if( ENC(db)==SQLITE_UTF16LE ){    sqlite3_result_text16le(pCtx, zVal, -1, destructor);  }else{    sqlite3_result_text16be(pCtx, zVal, -1, destructor);#endif /* SQLITE_OMIT_UTF16 */  }}

/*** This function is responsible for invoking the collation factory callback** or substituting a collation sequence of a different encoding when the** requested collation sequence is not available in the database native** encoding.** ** If it is not NULL, then pColl must point to the database native encoding ** collation sequence with name zName, length nName.**** The return value is either the collation sequence to be used in database** db for collation type name zName, length nName, or NULL, if no collation** sequence can be found.*/CollSeq *sqlite3GetCollSeq(  sqlite3* db,   CollSeq *pColl,   const char *zName,   int nName){  CollSeq *p;  p = pColl;  if( !p ){    p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0);  }  if( !p || !p->xCmp ){    /* No collation sequence of this type for this encoding is registered.    ** Call the collation factory to see if it can supply us with one.    */    callCollNeeded(db, zName, nName);    p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0);  }  if( p && !p->xCmp && synthCollSeq(db, p) ){    p = 0;  }  assert( !p || p->xCmp );  return p;}

/* ** This function is used to allocate and populate UnpackedRecord ** structures intended to be compared against sample index keys stored ** in the sqlite_stat4 table. ** ** A single call to this function attempts to populates field iVal (leftmost ** is 0 etc.) of the unpacked record with a value extracted from expression ** pExpr. Extraction of values is possible if: ** **  * (pExpr==0). In this case the value is assumed to be an SQL NULL, ** **  * The expression is a bound variable, and this is a reprepare, or ** **  * The sqlite3ValueFromExpr() function is able to extract a value **    from the expression (i.e. the expression is a literal value). ** ** If a value can be extracted, the affinity passed as the 5th argument ** is applied to it before it is copied into the UnpackedRecord. Output ** parameter *pbOk is set to true if a value is extracted, or false  ** otherwise. ** ** When this function is called, *ppRec must either point to an object ** allocated by an earlier call to this function, or must be NULL. If it ** is NULL and a value can be successfully extracted, a new UnpackedRecord ** is allocated (and *ppRec set to point to it) before returning. ** ** Unless an error is encountered, SQLITE_OK is returned. It is not an ** error if a value cannot be extracted from pExpr. If an error does ** occur, an SQLite error code is returned. */SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue(                                             Parse *pParse,                  /* Parse context */                                             Index *pIdx,                    /* Index being probed */                                             UnpackedRecord **ppRec,         /* IN/OUT: Probe record */                                             Expr *pExpr,                    /* The expression to extract a value from */                                             u8 affinity,                    /* Affinity to use */                                             int iVal,                       /* Array element to populate */                                             int *pbOk                       /* OUT: True if value was extracted */){    int rc = SQLITE_OK;    sqlite3_value *pVal = 0;    sqlite3 *db = pParse->db;            struct ValueNewStat4Ctx alloc;    alloc.pParse = pParse;    alloc.pIdx = pIdx;    alloc.ppRec = ppRec;    alloc.iVal = iVal;        /* Skip over any TK_COLLATE nodes */    pExpr = sqlite3ExprSkipCollate(pExpr);        if( !pExpr ){        pVal = valueNew(db, &alloc);        if( pVal ){            sqlite3VdbeMemSetNull((Mem*)pVal);            *pbOk = 1;        }    }else if( pExpr->op==TK_VARIABLE             || (pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)             ){        Vdbe *v;        int iBindVar = pExpr->iColumn;        sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);        if( (v = pParse->pReprepare)!=0 ){            pVal = valueNew(db, &alloc);            if( pVal ){                rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);                if( rc==SQLITE_OK ){                    sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));                }                pVal->db = pParse->db;                *pbOk = 1;                sqlite3VdbeMemStoreType((Mem*)pVal);            }        }else{            *pbOk = 0;        }    }else{        rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, &alloc);        *pbOk = (pVal!=0);    }        assert( pVal==0 || pVal->db==db );    return rc;}

/*** Bind a text or BLOB value.*/static int bindText(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*),  int encoding){  Vdbe *p = (Vdbe *)pStmt;  Mem *pVar;  int rc;  rc = vdbeUnbind(p, i);  if( rc || zData==0 ){    return rc;  }  pVar = &p->aVar[i-1];  rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);  if( rc==SQLITE_OK && encoding!=0 ){    rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));  }  sqlite3Error(((Vdbe *)pStmt)->db, rc, 0);  return sqlite3ApiExit(((Vdbe *)pStmt)->db, rc);}

void qPBReaderPlatform::ReaderApplicationStarted(const QString & isBookFile){   TRSCOPE(pb, "qPBReaderPlatform::ReaderApplicationStarted");#ifdef Q_OS_POCKETBOOK   TRACE << "Declaring " << ENC(isBookFile) << endl;   // set application icon   // taskmgr looks for app_%s_icon.bmp file in theme, %s being the   // task name. Since I have not found another way to provide an icon at   // runtime, setting task name to "reader" does the job.   int task = ::GetCurrentTask();   taskinfo * pTask = ::GetTaskInfo(GetCurrentTask());   if (pTask)   {      int rc = ::SetTaskParameters(task, "reader", 0, 0, pTask->flags);      TRACE << "SetTaskParameters " << VAR(rc) << endl;   }   // switch to reading mode, seems to change panel appearance   SetReadingMode(true);   // and register book as read by this program   ::BookReady(isBookFile.toUtf8().data());#else   Q_UNUSED(isBookFile);#endif}

int qPBReaderDictionaryDialog::InternalDicProcHandler(int type, int par1,      int par2){   TRSCOPE(dic, "qPBReaderDictionaryDialog::InternalDicProcHandler");   int rc = 0;#ifdef Q_OS_POCKETBOOK   assert(_pDicInternalProc != 0);   TRACE << type << " " << ENC(iv_evttype(type)) << " " << par1 << " " << par2 <<         endl;   TRACE << "thread id=" << (int)syscall(SYS_gettid) << endl;   rc = _pDicInternalProc(type, par1, par2);   TRACE << "_pDicInternalProc rc=" << rc << endl;   if (!rc && !Instance()._bReenter && !ISKEYEVENT(type))   {      assert(_pOrgProc != 0);      TRACE << "Calling _pOrgProc" << endl;      rc = _pOrgProc(type, par1, par2);   }#else   Q_UNUSED(type);   Q_UNUSED(par1);   Q_UNUSED(par2);#endif   return rc;}

/*** Bind a text or BLOB value.*/static int bindText(  sqlite3_stmt *pStmt,   /* The statement to bind against */  int i,                 /* Index of the parameter to bind */  const void *zData,     /* Pointer to the data to be bound */  int nData,             /* Number of bytes of data to be bound */  void (*xDel)(void*),   /* Destructor for the data */  u8 encoding            /* Encoding for the data */){  Vdbe *p = (Vdbe *)pStmt;  Mem *pVar;  int rc;  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    if( zData!=0 ){      pVar = &p->aVar[i-1];      rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);      if( rc==SQLITE_OK && encoding!=0 ){        rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));      }      sqlite3Error(p->db, rc);      rc = sqlite3ApiExit(p->db, rc);    }    sqlite3_mutex_leave(p->db->mutex);  }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){    xDel((void*)zData);  }  return rc;}

qPBReaderJSLoader::qPBReaderJSLoader(QWebPage * p) :   _p(p){   TRSCOPE(js, "qPBReaderJSLoader::qPBReaderJSLoader");   // hard-coded module list, keep in synch with aliases in qrc file   _lNames.append("jquery");   _lNames.append("jquery_scrollTo");   _lNames.append("bookmarks");   _lNames.append("referencing");   _lNames.append("images");   _lNames.append("hyphenation");   _lNames.append("Hyphenator");   _lNames.append("utils");   _lNames.append("cfi");   _lNames.append("indexing");   _lNames.append("paged");   _lNames.append("full_screen");   _lNames.append("mathjax");   _lNames.append("extract");   _lNames.append("qPBReader");   // load resource   for (int idx = 0; idx < _lNames.size(); idx++)   {      QByteArray ba;      LoadResource(_lNames[idx], ba);      _lSrc.append(QString::fromUtf8(ba.data(), ba.size()));      TRACE << "Loaded " << ENC(_lNames[idx]) << ", length=" << _lSrc[idx].size() <<            endl;   }}

/* * Determine for a character is display string and columns width */static void rl_analyze_ucs (wint_tt ucs, const char **display, UWORD *columns){   char *utf = NULL;#if HAVE_WCWIDTH   int width;#endif     utf = strdup (ConvUTF8 (ucs));   *display = ConvTo (utf, ENC(enc_loc))->txt;    if (ucs < 32 || ucs == 127 || ucs == 173) /* control code */    {        *display = s_sprintf ("%s^%c%s", COLINVCHAR, (char)((ucs - 1 + 'A') & 0x7f), COLNONE);        *columns = 2;    }    else if (ucs < 127)        *columns = 1;#if HAVE_WCWIDTH    else if (!prG->locale_broken && (width = rl_wcwidth (ucs, *display)) != -1)        *columns = 256 | width;#else    else if (ucs >= 160) /* no way I'll hard-code double-width or combining marks here */        *columns = 257;#endif    else if (prG->locale_broken && !strcmp (ConvFrom (ConvTo (utf, ENC(enc_loc)), ENC(enc_loc))->txt, utf))        *columns = 257;    else if (!(ucs & 0xffff0000)) /* more control code, or unknown */    {        *display = s_sprintf ("%s//u%c%c%c%c%s", COLINVCHAR,           rl_hex (ucs / 4096), rl_hex (ucs /  256),           rl_hex (ucs /   16), rl_hex (ucs),           COLNONE);        *columns = 6;    }    else /* unknown stellar planes */    {        *display = s_sprintf ("%s//U%c%c%c%c%c%c%c%c%s", COLINVCHAR,           rl_hex (ucs / 268435456), rl_hex (ucs /  16777216),           rl_hex (ucs /   1048576), rl_hex (ucs /     65536),           rl_hex (ucs /      4096), rl_hex (ucs /       256),           rl_hex (ucs /        16), rl_hex (ucs),           COLNONE);        *columns = 10;    }    free (utf);}

void lightmac(void *data, u32 len, void *tag, void *key) {    int  i;    u8   m[BLK_LEN], v[TAG_LEN];     u8   *t=(u8*)tag, *k=(u8*)key, *p=(u8*)data;        union {      u8  b[8];      u64 q;    } s;        // 1. zero initialize V    for(i=0;i<TAG_LEN;i++) v[i] = 0;    // 2. set protected counter sum to 1    s.q = 1;        // 3. while we have blocks of data equal to (n - s)    while (len >= MSG_LEN) {      // 4. add counter s to M in big endian byte order      for(i=0;i<CTR_LEN;i++) {        m[CTR_LEN-i-1] = s.b[i];      }      // 5. add data to M      for(i=0;i<MSG_LEN;i++) {        m[CTR_LEN+i] = p[i];      }      // 6. encrypt M with K1      ENC(k, m);      // 7. update V      for(i=0;i<TAG_LEN;i++) v[i] ^= m[i];      // 8. decrease length and advance data pointer      len -= MSG_LEN;      p += MSG_LEN;      // 9. update counter      s.q++;    }    // 10. absorb any data less than (n - s)    for(i=0;i<len;i++) v[i] ^= p[i];    // 11. add end bit    v[i] ^= 0x80;    // 12. encrypt V with K2    k += BC_KEY_LEN;    ENC(k, v);    // 13. return V in T    for(i=0;i<TAG_LEN;i++) t[i] = v[i];}

void qPBReaderJSLoader::Load(const QString & isHyphenLang){   TRSCOPE(js, "qPBReaderJSLoader::Load");   if (_p)   {      for (int idx = 0; idx < _lNames.size(); idx++)      {         TRACE << "injecting " << ENC(_lNames[idx]) <<  " (" << _lSrc[idx].length() <<               ")" << endl;         _p->mainFrame()->evaluateJavaScript(_lSrc[idx]);      }      // if hyphenation is required      if (!isHyphenLang.isEmpty())      {         // if pattern lang has changed         if (isHyphenLang != _sLang)         {            // load it from resources            TRACE << "Loading pattern script" << ENC(isHyphenLang) << endl;            QByteArray ba;            LoadResource("patterns/" + isHyphenLang, ba);            // store lang and corresponding script            _sLang = isHyphenLang;            _sPattern = QString::fromUtf8(ba.data(), ba.size());            TRACE << "Loaded " << ENC(isHyphenLang) << ", length=" << _sLang.size() << endl;         }         else         {            TRACE << "Pattern script" << ENC(_sLang) << "already loaded" << endl;         }         // and load it into page         TRACE << "injecting hyphens pattern script" << endl;         _p->mainFrame()->evaluateJavaScript(_sPattern);      }   }}

bool qPBReaderEpub::Open(){   TRSCOPE(epub, "qPBReaderEpub::Open");   Clean();   // compute MD5 to get config file and temporary directory   _sMD5 = qPBReaderUtils::MD5(_sFile);   bool bOk = !_sMD5.isEmpty();   if (bOk)   {      _sTempDir = qPBReaderConfig::GetTempDir() + "/" + _sMD5;      TRACE << "temp dir " << ENC(_sTempDir) << endl;      bOk = InitSettings(qPBReaderConfig::GetDataDir() + "/" + _sMD5 + ".cfg");   }   // extract epub file   if (bOk && qgetenv("qPBReaderDisableEpubExtraction").isEmpty())   {      bOk = qPBReaderUnzip::ExtractAllTo(_sFile, _sTempDir);   }   // analyze epub. Won't be completely performed if settings are present.   if (bOk)   {      bOk = AnalyzeDocStructure();   }   // keep the input file name in config, useful when data   // will be checked for entries to removed   // will avoid deleting file if epub has been moved and reopened   // since first open   if (bOk)   {      QFile f(_sFile);      _pSettings->SaveEpubFileName(QFileInfo(f).absoluteFilePath());   }   // don't stay partially initialized in case of error   if (!bOk)   {      Clean();   }   TRACE << TRANAME << " " << VAR(bOk) << endl;   return bOk;}

/* * Sets the prompt */void ReadLinePromptSet (const char *prompt){    rl_prompt_time = time (NULL);    s_init (&rl_prompt, COLSERVER, 0);    s_cat  (&rl_prompt, ConvTo (prompt, ENC(enc_loc))->txt);    s_cat  (&rl_prompt, COLNONE);    s_catc (&rl_prompt, ' ');    if (rl_prompt_stat != 0)        rl_prompt_stat = 2;}

__declspec(dllexport) int WINAPI sqlite3_open16_interop(const char *filename, int flags, sqlite3 **ppdb){  int ret = sqlite3_open_interop(filename, flags, ppdb);  if (!ret)  {    if(!DbHasProperty(*ppdb, 0, DB_SchemaLoaded))      ENC(*ppdb) = SQLITE_UTF16NATIVE;  }  return ret;}

DCL_STATUS PMIC6326_ccci_control_handler(DCL_HANDLE handle,DCL_CTRL_CMD cmd,DCL_CTRL_DATA_T *data){	DCL_UINT16	regVal;	DCL_UINT32	val;	switch(cmd)	{		case LDO_BUCK_SET_EN:		{			PMU_CTRL_LDO_BUCK_SET_EN *pLdoBuckCtrl=&(data->rPMULdoBuckSetEn);			switch(pLdoBuckCtrl->mod)			{				case VSIM:				{					dcl_pmic6326_ccci_vsim_enable((kal_bool)pLdoBuckCtrl->enable);				}				break;					case VSIM2:				{					dcl_pmic6326_ccci_vsim2_enable((kal_bool)pLdoBuckCtrl->enable);				}				break;									default:								return STATUS_UNSUPPORTED;				break;								}					}		break;			case LDO_BUCK_SET_VOLTAGE_EN:		{			PMU_CTRL_LDO_BUCK_SET_VOLTAGE_EN *pLdoBuckCtrl=&(data->rPMULdoBuckSetVoltageEn);			regVal=PMU_Parameter_to_Value(ENC(cmd,pLdoBuckCtrl->mod),pLdoBuckCtrl->voltage);			switch(pLdoBuckCtrl->mod)			{				case VSIM:				{					dcl_pmic6326_ccci_vsim_sel_and_enable(regVal);				}				break;					case VSIM2:				{					dcl_pmic6326_ccci_vsim2_sel_and_enable(regVal);				}				break;									default:								return STATUS_UNSUPPORTED;				break;								}						}		break;		default:						return STATUS_UNSUPPORTED;		break;	}}

void qPBReaderDocView::UseHyphensChanged(const QString & isHyphenPatternLang){   TRSCOPE(view, "qPBReaderDocView::UseHyphensChanged");   TRACE << ENC(isHyphenPatternLang) << endl;   _pDoc->SetHyphenPatternLang(isHyphenPatternLang);   _pMgr->HyphenLangChanged(isHyphenPatternLang);}

/*** This routine is called on a collation sequence before it is used to** check that it is defined. An undefined collation sequence exists when** a database is loaded that contains references to collation sequences** that have not been defined by sqlite3_create_collation() etc.**** If required, this routine calls the 'collation needed' callback to** request a definition of the collating sequence. If this doesn't work, ** an equivalent collating sequence that uses a text encoding different** from the main database is substituted, if one is available.*/int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){  if( pColl && pColl->xCmp==0 ){    const char *zName = pColl->zName;    sqlite3 *db = pParse->db;    CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);    if( !p ){      return SQLITE_ERROR;    }    assert( p==pColl );  }  return SQLITE_OK;}

/*** Invoke the 'collation needed' callback to request a collation sequence** in the database text encoding of name zName, length nName.** If the collation sequence*/static void callCollNeeded(sqlite3 *db, const char *zName){  assert( !db->xCollNeeded || !db->xCollNeeded16 );  if( db->xCollNeeded ){    char *zExternal = sqlite3DbStrDup(db, zName);    if( !zExternal ) return;    db->xCollNeeded(db->pCollNeededArg, db, (int)ENC(db), zExternal);    sqlite3DbFree(db, zExternal);  }#ifndef SQLITE_OMIT_UTF16  if( db->xCollNeeded16 ){    char const *zExternal;    sqlite3_value *pTmp = sqlite3ValueNew(db);    sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);    zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);    if( zExternal ){      db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);    }    sqlite3ValueFree(pTmp);  }#endif}

static int rsa2_openssh_fmtkey(void *key, unsigned char *blob, int len){    struct RSAKey *rsa = (struct RSAKey *) key;    int bloblen, i;    bloblen =	ssh2_bignum_length(rsa->modulus) +	ssh2_bignum_length(rsa->exponent) +	ssh2_bignum_length(rsa->private_exponent) +	ssh2_bignum_length(rsa->iqmp) +	ssh2_bignum_length(rsa->p) + ssh2_bignum_length(rsa->q);    if (bloblen > len)	return bloblen;    bloblen = 0;#define ENC(x) /    PUT_32BIT(blob+bloblen, ssh2_bignum_length((x))-4); bloblen += 4; /    for (i = ssh2_bignum_length((x))-4; i-- ;) blob[bloblen++]=bignum_byte((x),i);    ENC(rsa->modulus);    ENC(rsa->exponent);    ENC(rsa->private_exponent);    ENC(rsa->iqmp);    ENC(rsa->p);    ENC(rsa->q);    return bloblen;}

/*** The most recently coded instruction was an OP_Column to retrieve the** i-th column of table pTab. This routine sets the P3 parameter of the ** OP_Column to the default value, if any.**** The default value of a column is specified by a DEFAULT clause in the ** column definition. This was either supplied by the user when the table** was created, or added later to the table definition by an ALTER TABLE** command. If the latter, then the row-records in the table btree on disk** may not contain a value for the column and the default value, taken** from the P3 parameter of the OP_Column instruction, is returned instead.** If the former, then all row-records are guaranteed to include a value** for the column and the P3 value is not required.**** Column definitions created by an ALTER TABLE command may only have ** literal default values specified: a number, null or a string. (If a more** complicated default expression value was provided, it is evaluated ** when the ALTER TABLE is executed and one of the literal values written** into the sqlite_master table.)**** Therefore, the P3 parameter is only required if the default value for** the column is a literal number, string or null. The sqlite3ValueFromExpr()** function is capable of transforming these types of expressions into** sqlite3_value objects.*/void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i){  if( pTab && !pTab->pSelect ){    sqlite3_value *pValue;    u8 enc = ENC(sqlite3VdbeDb(v));    Column *pCol = &pTab->aCol[i];    sqlite3ValueFromExpr(pCol->pDflt, enc, pCol->affinity, &pValue);    if( pValue ){      sqlite3VdbeChangeP3(v, -1, (const char *)pValue, P3_MEM);    }else{      VdbeComment((v, "# %s.%s", pTab->zName, pCol->zName));    }  }}

/*** This routine is called on a collation sequence before it is used to** check that it is defined. An undefined collation sequence exists when** a database is loaded that contains references to collation sequences** that have not been defined by sqlite3_create_collation() etc.**** If required, this routine calls the 'collation needed' callback to** request a definition of the collating sequence. If this doesn't work, ** an equivalent collating sequence that uses a text encoding different** from the main database is substituted, if one is available.*/int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){  if( pColl ){    const char *zName = pColl->zName;    sqlite3 *db = pParse->db;    CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);    if( !p ){      sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);      pParse->nErr++;      return SQLITE_ERROR;    }    assert( p==pColl );  }  return SQLITE_OK;}

/*** Bind a blob value to an SQL statement variable.*/int sqlite3_bind_blob(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, 0);}int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);  }  sqlite3_mutex_leave(p->db->mutex);  return rc;}int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){  return sqlite3_bind_int64(p, i, (i64)iValue);}int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);  }  sqlite3_mutex_leave(p->db->mutex);  return rc;}int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){  int rc;  Vdbe *p = (Vdbe*)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  sqlite3_mutex_leave(p->db->mutex);  return rc;}int sqlite3_bind_text(   sqlite3_stmt *pStmt,   int i,   const char *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);}#ifndef SQLITE_OMIT_UTF16int sqlite3_bind_text16(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);}#endif /* SQLITE_OMIT_UTF16 */int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);    if( rc==SQLITE_OK ){      rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));    }  }  rc = sqlite3ApiExit(p->db, rc);  sqlite3_mutex_leave(p->db->mutex);  return rc;}

/*** This function is responsible for invoking the collation factory callback** or substituting a collation sequence of a different encoding when the** requested collation sequence is not available in the database native** encoding.** ** If it is not NULL, then pColl must point to the database native encoding ** collation sequence with name zName, length nName.**** The return value is either the collation sequence to be used in database** db for collation type name zName, length nName, or NULL, if no collation** sequence can be found.**** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq()*/CollSeq *sqlite3GetCollSeq(  sqlite3* db,          /* The database connection */  CollSeq *pColl,       /* Collating sequence with native encoding, or NULL */  const char *zName     /* Collating sequence name */){  CollSeq *p;  p = pColl;  if( !p ){    p = sqlite3FindCollSeq(db, ENC(db), zName, 0);  }  if( !p || !p->xCmp ){    /* No collation sequence of this type for this encoding is registered.    ** Call the collation factory to see if it can supply us with one.    */    callCollNeeded(db, zName);    p = sqlite3FindCollSeq(db, ENC(db), zName, 0);  }  if( p && !p->xCmp && synthCollSeq(db, p) ){    p = 0;  }  assert( !p || p->xCmp );  return p;}

    // pour new coin    EncryptedCoin(const Coin<FIELD>& coin) {        ENCRYPTOR ENC(coin.addr().cryptoKey());        RANDPOOL RNG;        std::stringstream ss;        coin.marshal_out(ss, false); // false means omit public address        const std::string& ptext = ss.str();        const std::size_t ptextLen = ptext.length() + 1;        // encrypt message        m_cipherText = std::vector<byte>(ENC.CiphertextLength(ptextLen), 0xfb);        ENC.Encrypt(RNG,                    reinterpret_cast<const byte*>(ptext.data()),                    ptextLen,                    m_cipherText.data());    }