Lines Matching refs:input
2996 ** These routines are useful during command-line input to determine if the
2998 ** if additional input is needed before sending the text into
2999 ** SQLite for parsing. ^These routines return 1 if the input string
3018 ** regardless of whether or not the input SQL is complete.)^
3020 ** The input to [sqlite3_complete()] must be a zero-terminated
3023 ** The input to [sqlite3_complete16()] must be a zero-terminated
4045 ** Beginning with SQLite [version 3.31.0] ([dateof:3.31.0]) the input F
4203 ** ^If the most recent error references a specific token in the input
4206 ** sqlite3_error_offset() assumes that the input SQL is UTF8.
4207 ** ^If the most recent error does not reference a specific token in the input
4425 ** input text into UTF-8, then invoking the corresponding UTF-8 interface.
4443 ** is the number of bytes in the input string <i>including</i>
4453 ** to NULL. ^If the input text contains no SQL (if the input is an empty
4745 ** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
4790 ** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)
4795 ** ^If UTF16 input text contains invalid unicode
5433 ** As long as the input parameters are correct, these routines will only
5558 ** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the
5559 ** implementation invokes [sqlite3_value_text16be()] on an input, or
5710 ** the same output when the input parameters are the same.
5734 ** input parameters. The [abs|abs() function] is an example of an
5905 ** As long as the input parameter is correct, these routines can only
5962 ** is a [protected sqlite3_value] object even if the input is not.
6230 ** when the encoding is not UTF8, if the input UTF16 begins with a
6238 ** first two bytes of input are skipped and the remaining input
6241 ** ^For UTF16 input text to the sqlite3_result_text16(),
6728 ** can be used as the filename input parameter to these routines:
6890 ** does some arithmetic on its input parameters and returns a result.
7598 ** in the input SQL. If the right-hand operand is another column or an
11799 ** WARNING/TODO: This function currently assumes that the input is a valid
11804 int *pnOut, void **ppOut /* OUT: Inverse of input */
11814 ** This function combines the two input changesets using an
11858 ** always in the same format as the input.
11874 ** <li> The result of combining all input changesets together is obtained
11957 ** case, this function fails with SQLITE_SCHEMA. If the input changeset
12146 ** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2()
12487 ** Non-streaming functions that accept changesets (or patchsets) as input
12495 ** In order to avoid this problem, instead of a single large buffer, input
12497 ** the sessions module invokes to incrementally request input data as it is
12517 ** before returning SQLITE_OK. If the input is completely exhausted, (*pnData)
12663 ** By default, the sessions module streaming interfaces attempt to input
12668 ** chunk size for both input and output. Before returning, the (int) value
13061 ** For each token in the input string, the supplied callback xToken() must
13067 ** which the token is derived within the input.
13074 ** order that they occur within the input text.
13079 ** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally,
13205 int iStart, /* Byte offset of token within input text */
13206 int iEnd /* Byte offset of end of token within input text */
13870 ** Return true (non-zero) if the input is an integer that is too large
16204 #define OPFLG_IN1 0x02 /* in1: P1 is an input */
16205 #define OPFLG_IN2 0x04 /* in2: P2 is an input */
16206 #define OPFLG_IN3 0x08 /* in3: P3 is an input */
23801 ** on success and 1 if the input string is not a well-formed
23870 ** The following are acceptable forms for the input string:
23913 ** The input is the JulianDay times 86400000.
24066 ** Assuming the input DateTime is UTC, move it to its localtime equivalent.
30064 ** input: *val = 3.14159
30759 ** characters if the ! flags is present) to use from the input.
33247 unsigned char *zTerm; /* End of input */
33309 /* Set zIn to point at the start of the input buffer and zTerm to point 1
33504 ** overruns the input.
33829 ** input does not begin with a quote character, then this routine
33832 ** The input string must be zero-terminated. A new zero-terminator
33873 ** If the input token p is quoted, try to adjust the token to remove
34017 ** 1 => The input string is a pure integer
34018 ** 2 or more => The input has a decimal point or eNNN clause
34019 ** 0 or less => The input string is not a valid number
34032 ** If some prefix of the input string is a valid number, this routine
34294 ** -1 Not even a prefix of the input text looks like an integer
34310 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */
34435 ** input number to be zero-terminated.
35251 VList *pIn, /* The input VList. Might be NULL */
37467 ** standard input, output, and error.
43431 const char *zPath, /* Possibly relative input path */
50656 const char *zRelative, /* Possibly relative input path */
50835 const char *zRelative, /* Possibly relative input path */
50923 int i; /* XOR next input into a[i] */
52505 ** The input is an array of integers that acts as a program
53397 ** the input list. But that is impossible.
55055 ** The input lists are connected via pRight pointers and are
55118 ** The input, pIn, is a binary tree (or subtree) of RowSetEntry objects.
55123 struct RowSetEntry *pIn, /* Root of the input tree */
55150 ** Use as many entries from the input list as required and update the
55151 ** *ppList to point to the unused elements of the list. If the input
63436 ** the checksum. The checksum is computed by interpreting the input as
64073 ** of the input value as a little-endian integer.
64093 const u32 *aIn, /* Initial checksum value input */
65006 ht_slot *aLeft, /* IN: Left hand input list */
65008 ht_slot **paRight, /* IN/OUT: Right hand input list */
65072 const int nList = *pnList; /* Size of input list */
65075 int iList; /* Index into input list */
66943 /* Find the checksum values to use as input for the recalculating the
69583 ** input page number.
70127 int iCellStart; /* First cell offset in input */
77946 const u8 *aIn; /* Pointer to next input buffer */
77947 u32 nIn; /* Size of input buffer aIn[] */
81314 ** Every effort is made to force the conversion, even if the input
82845 ** If the input string does not end with "X" then an OP_ResultRow instruction
83742 ** If the input FuncDef structure is ephemeral, then free it. If
86827 ** The input pBlob is guaranteed to be a Blob that is not marked
90139 ** ALGORITHM: Scan the input string looking for host parameters in any of
90607 ** If bTryForInt is false, then if the input string contains a decimal
91060 Mem *pIn1 = 0; /* 1st input operand */
91061 Mem *pIn2 = 0; /* 2nd input operand */
91062 Mem *pIn3 = 0; /* 3rd input operand */
92066 ** If either input is NULL, the result is NULL.
92074 ** If either input is NULL, the result is NULL.
92081 ** If either input is NULL, the result is NULL.
92088 ** register P1 is zero, then the result is NULL. If either input is
92213 ** If either input is NULL, the result is NULL.
92220 ** If either input is NULL, the result is NULL.
92228 ** If either input is NULL, the result is NULL.
92236 ** If either input is NULL, the result is NULL.
92400 ** back into the input registers P1 and P3. So this opcode can cause
92444 ** back into the input registers P1 and P3. So this opcode can cause
92605 /* Undo any changes made by applyAffinity() to the input registers. */
92788 ** the other input is NULL. A NULL and true or two NULLs give
92798 ** even if the other input is NULL. A NULL and false or two NULLs
93184 Mem *pReg; /* PseudoTable input register */
93854 ** be one of the input registers (because the following call to
95012 /* The input value in P3 might be of any type: integer, real, string,
95490 ** branch is always taken if any part of the search key input is NULL.
95580 ** input fields are NULL, since any key with a NULL will not
101674 /* Check if the output file is full or if the input has been exhausted.
104225 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
107893 ** Check the input string to see if it is "true" or "false" (in any case).
107908 ** If the input expression is an ID with the name "true" or "false"
110815 ** except that the input expression is guaranteed to be unchanged.
113356 ** the input SQL is parsed from left to right. Repeated calls to this routine
113483 ** a part of the input string. */
113547 ** corresponding to all tokens in the input SQL that must be replaced
113571 ** original token within the input SQL was a single quote ('), then
114194 ** If there is a error in the input SQL, then raise an error, except
114195 ** if PRAGMA writable_schema=ON, then just return the input string
118600 ** as it appears in the record on disk. Or, if the input column is
118607 ** If the input column is a VIRTUAL column, then it should not appear
118612 ** input column is a VIRTUAL table, put it after all the other columns.
120473 ** allocated rather than point to the input string - which means that
122285 ** SrcList might be the same as the SrcList that was input or it might be
122287 ** that is input to this routine is automatically freed.
125414 u32 c, c2; /* Next pattern and input string chars */
125418 const u8 *zEscaped = 0; /* One past the last escaped input char */
125424 ** single character of the input string for each "?" skipped */
125451 ** pattern string past the "*". Search in the input string for the
125456 ** c but in the other case and search the input string for either
125859 ** for the first character of the input string.
125973 const unsigned char *zStr; /* The input string A */
126068 unsigned int nIn; /* Number of bytes in input */
126264 u8 approx; /* True if non-integer value was input to the sum */
137761 ** This routine returns a copy of its pPtr input (the third parameter)
145567 ** one row of the input to the aggregator has been
145716 int addrTopOfLoop; /* Top of the input loop */
147267 /* The input list pList is the list of result set terms from a RETURNING
152373 ** This routine makes a copy of the input pX expression and then adjusts
155728 ** The input to this routine is an WhereTerm structure with only the
157199 ** Estimate the logarithm of the input value to base 2.
158172 ** input rows. Otherwise, this function assumes that an "IS NOT NULL" term
164679 ** The window functions implementation sometimes caches the input rows
164686 ** An input row can be discarded after it is returned to the caller.
164689 ** An input row can be discarded after the window functions xInverse()
164693 ** An input row can be discarded after the window functions xStep()
164701 ** The windows functions implmentation caches the input rows in a temp
165410 ** if the input cursor is still finding new rows, that the end
165921 int regNew; /* Array of registers holding new input row */
166027 /* An input row has just been read into an array of registers starting
166029 ** VM code to check if the input row is the start of a new partition.
166160 /* End of the main input loop */
166233 /* This file is automatically generated by Lemon from input grammar
166249 ** file that specifies the input grammar and actions to take while parsing.
166250 ** That input file is processed by Lemon to generate a C-language
166789 ** N == YY_ACCEPT_ACTION The parser accepts its input.
167444 ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
167912 /* 185 */ "input",
168395 /* 342 */ "input ::= cmdlist",
168497 ** putting an appropriate #define in the %include section of the input
168562 ** directives of the input grammar.
168719 ** is defined in a %include section of the input grammar) then it is
168720 ** assumed that the input pointer is never NULL.
169306 185, /* (342) input ::= cmdlist */
169716 -1, /* (342) input ::= cmdlist */
171272 /* (342) input ::= cmdlist */ yytestcase(yyruleno==342);
171399 sqlite3ErrorMsg(pParse, "incomplete input");
171459 int yyendofinput; /* True if we are at the end of input */
171584 fprintf(yyTraceFILE,"%sDiscard input token %s\n",
171626 ** * Report an error message, and throw away the input token.
171628 ** * If the input token is $, then fail the parse.
171631 ** three input tokens have been successfully shifted.
171692 ** This file contains C code that splits an SQL input string up into
171818 ** returned. If the input is not a keyword, TK_ID is returned.
172803 /* Upon reaching the end of input, call the parser two more times
173106 ** from the input. The following tokens are significant:
176669 ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
179058 ** tokens from a particular input.
179082 ** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen()
179084 ** that may be used to tokenize a specific input buffer based on
179129 ** Create a tokenizer cursor to tokenize an input buffer. The caller
179130 ** is responsible for ensuring that the input buffer remains valid
179154 ** of this buffer in bytes. The input text that generated the token is
179157 ** byte of the token in the input buffer. *piEndOffset should be set
179159 ** the input buffer.
179172 int *piStartOffset, /* OUT: Byte offset of token in input buffer */
179173 int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */
180094 ** input does not begin with a quote character, then this routine
180110 int iIn = 1; /* Index of next byte to read from input */
180477 ** Return a copy of input string zInput enclosed in double-quotes (") and
181868 char **pp1, /* Left input list */
181869 char **pp2 /* Right input list */
181971 char **pp1, /* IN/OUT: Left input list */
181972 char **pp2 /* IN/OUT: Right input list */
182094 char **pp1, /* IN/OUT: Left input list */
182095 char **pp2 /* IN/OUT: Right input list */
182219 ** input doclists are sorted in ascending order, parameter bDescDoclist
182251 /* Allocate space for the output. Both the input and output doclists
182259 ** same number of bytes as it is in whichever of the input lists it is
182260 ** read from. And each subsequent docid read from the same input list
182261 ** consumes either the same or less bytes as it did in the input (since
182264 ** the input list). The same argument applies to all but the first docid
182266 ** that will be copied and merged from the input to the output.
182269 ** then the encoding of the first docid from the 'other' input list may
182270 ** be larger in the output than it was in the input (since the delta value
182274 ** sizes of the two inputs, plus enough space for exactly one of the input
182322 ** the output contains a copy of each position from the right-hand input
182323 ** doclist for which there is a position in the left-hand input doclist
182326 ** If the docids in the input doclists are sorted in ascending order,
182330 ** The right-hand input doclist is overwritten by this function.
183161 /* Following an incremental-merge operation, assuming that the input
183166 ** if the height of the input segment b-trees is N, and input segments
183167 ** are merged eight at a time, updating the input segments at the end
183175 ** Of course, updating the input segments also involves deleting a bunch
183177 ** as it would also be required by a crisis-merge that used the same input
186509 /* Set variable i to the maximum number of bytes of input to tokenize. */
186586 ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE
186706 ** structure, or set to 0 if the end of the input buffer is reached.
186832 ** the end of the input. Read a regular token using the sqlite3_tokenizer
188048 const char *zInput; /* input we are tokenizing */
188049 int nInput; /* size of the input */
188085 ** Prepare to begin tokenizing a particular string. The input
188263 ** The input word *pz and zFrom are both in reverse order. zTo
188289 ** inappropriate. The input word is copied into the output with
188290 ** US-ASCII case folding. If the input word is too long (more
188320 ** Stem the input word zIn[0..nIn-1]. Store the output in zOut.
188334 ** If the input word contains not digits but does characters not
188336 ** copies the input into the input into the output with US-ASCII
188907 ** SELECT <function-name>(<key-name>, ..., <input-string>);
188914 ** list. For each token in the <input-string>, three elements are
188917 ** substring of <input-string> associated with the token. For example,
189231 const char *pInput; /* input we are tokenizing */
189232 int nBytes; /* size of the input */
189297 ** Prepare to begin tokenizing a particular string. The input
189448 ** CREATE TABLE <tbl>(input, token, start, end, position)
189452 ** input = <string>
189459 ** input: Always set to a copy of <string>
189460 ** token: A token from the input.
189461 ** start: Byte offset of the token within the input <string>.
189463 ** token within the input string.
189464 ** pos: Token offset of token within input.
189572 #define FTS3_TOK_SCHEMA "CREATE TABLE x(input, token, start, end, position)"
189811 /* CREATE TABLE x(input, token, start, end, position) */
190218 /* This statement is used to determine which level to read the input from
192117 ** and return it via the input/output variable *ppWriter in this case.
192501 ** If there are no entries in the input position list for column iCol, then
192504 ** If parameter bZero is non-zero, then any part of the input list following
193518 ** This function opens a cursor used to read the input data for an
193601 sqlite3_int64 iAbsLevel; /* Absolute level of input segments */
194130 ** * The first key read from the input (arguments zKey and nKey) is
194136 sqlite3_int64 iAbsLevel, /* Absolute level of input segments */
194287 sqlite3_int64 iAbsLevel, /* Absolute index of input segments */
194317 ** number of leaf blocks consumed by the input segments, plus the number
194318 ** of input segments, multiplied by two. This value is stored in stack
194332 sqlite3_int64 iAbsLevel, /* Absolute level of input segments */
194633 ** Each input segment is either removed from the db completely (if all of
194661 /* Seg-reader is at EOF. Remove the entire input segment. */
194743 ** consists of two varints, the absolute level number of the input segments
194744 ** and the number of input segments.
194803 Fts3MultiSegReader *pCsr; /* Cursor used to read input data */
194806 int nSeg = 0; /* Number of input segments */
194935 /* Update or delete the input segments */
197724 ** Prepare to begin tokenizing a particular string. The input
197792 ** the input. */
199649 ** The json_test1(JSON) function return true (1) if the input is JSON
199650 ** text generated by another json function. It returns (0) if the input
199669 ** corresponding to the SQL value input. Mostly this means putting
199671 ** when given a NULL input.
199717 ** Return 0 if the input is not a well-formed JSON array.
200377 JsonParse sParse; /* Parse of the input JSON */
200726 /* No JSON input. Leave estimatedCost at the huge value that it was
205483 ** State of a parse of a GeoJSON input.
205487 const unsigned char *z; /* Unparsed input */
205564 ** If the input is a well-formed JSON array of coordinates with at least
205645 ** return a pointer to that object. Or if the input is not a well-formed
205705 ** If the input is a well-formed Geopoly BLOB or JSON string
205854 ** If the input is a well-formed Geopoly BLOB then return the area
205879 ** winding order of its input.
207483 /* Read (and consume) the next character from the input pattern. */
207686 ** lower(). Function upper() converts its input to upper-case (ABC).
207711 const UChar *zInput; /* Pointer to input string */
207713 int nInput; /* Size of utf-16 input string in bytes */
207947 UChar *aChar; /* Copy of input using utf-16 encoding */
207948 int *aOffset; /* Offsets of each character in utf-8 input */
207996 ** Prepare to begin tokenizing a particular string. The input
208390 ** target table must be present in the input table. For virtual tables,
208392 ** the input table, or not otherwise. For example, to write to an fts4
208397 ** Either of the following input table schemas may be used:
209365 ** may contain embedded NUL characters (if the input and output are
209414 /* ERROR: copy extends past end of input */
210139 int bRbuRowid = 0; /* If input table has column "rbu_rowid" */
210159 ** of the input table. Ignore any input table columns that begin with
210194 ** present in the input table. Populate the abTblPk[], azTblType[] and
212225 ** and the input cursor (p->objiter.pSelect) currently points to a valid
212226 ** input row. Perform whatever processing is required and return.
215586 ** input data. Input data may be supplied either as a single large buffer
218421 ** if there are not nByte bytes remaining in the input, that all available
218589 ** The input pointer currently points to the second byte of a table-header.
218596 ** This function ensures that all of the above is present in the input
218599 ** The input pointer is not moved.
218636 ** The input pointer currently points to the first byte of the first field
218638 ** record is buffered. It does not move the input pointer.
218672 ** The input pointer currently points to the second byte of a table-header.
218682 ** input pointer is left pointing to the byte following the table header.
218761 /* Make sure the buffer contains at least 10 bytes of input data, or all
219239 int nChangeset, /* Number of bytes in input */
219246 /* Set up the input stream */
219266 /* Set up the input stream */
220594 ** may be generated by combining the input records. */
220921 int nLeft, /* Number of bytes in lhs input */
220922 void *pLeft, /* Lhs input changeset */
220923 int nRight /* Number of bytes in rhs input */,
220924 void *pRight, /* Rhs input changeset */
221276 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
221297 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
221722 ** For each token in the input string, the supplied callback xToken() must
221728 ** which the token is derived within the input.
221735 ** order that they occur within the input text.
221740 ** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally,
221866 int iStart, /* Byte offset of token within input text */
221867 int iEnd /* Byte offset of end of token within input text */
222804 /* This file is automatically generated by Lemon from input grammar
222819 ** The "lemon" program processes an LALR(1) input grammar file, then uses
222828 ** input grammar file:
223005 ** N == fts5YY_ACCEPT_ACTION The parser accepts its input.
223098 ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
223212 /* 16 */ "input",
223230 /* 0 */ "input ::= expr",
223297 ** putting an appropriate #define in the %include section of the input
223362 ** directives of the input grammar.
223383 case 16: /* input */
223455 ** is defined in a %include section of the input grammar) then it is
223456 ** assumed that the input pointer is never NULL.
223700 16, /* (0) input ::= expr */
223733 -1, /* (0) input ::= expr */
223802 case 0: /* input ::= expr */
224065 int fts5yyendofinput; /* True if we are at the end of input */
224190 fprintf(fts5yyTraceFILE,"%sDiscard input token %s\n",
224232 ** * Report an error message, and throw away the input token.
224234 ** * If the input token is $, then fail the parse.
224237 ** three input tokens have been successfully shifted.
224402 int nIn; /* Size of input text in bytes */
225567 ** the input cursor past both and copy a single quote character
225584 ** input does not begin with a quote character, then this routine
225810 ** Gobble up the first bareword or quoted word from the input buffer zIn.
226102 ** The callback is invoked once for each token in the input text. The
226108 ** int iStart // Byte offset of start of token within input text
226109 ** int iEnd // Byte offset of end of token within input text
226110 ** int iPos // Position of token in input (first token is 0)
228454 int iIn = 0; /* Next input in pColset */
228455 int iMerge = 0; /* Next input in pMerge */
229288 int iUnused1, /* Byte offset of token within input text */
229289 int iUnused2 /* Byte offset of end of token within input text */
230091 ** + number of input segments in ongoing merge.
231765 /* This happens if the segment is being used as an input to an incremental
233212 ** Or, if the new position list is a contiguous subset of the input, set
234210 ** Iterator pIter was used to iterate through the input segments of on an
234212 ** merge step has finished but the input has not been completely exhausted.
234223 /* All keys from this input segment have been transfered to the output.
234295 int iLvl, /* Level to read input from */
234301 Fts5Iter *pIter = 0; /* Iterator to read input data */
234303 int nInput; /* Number of input segments */
234349 /* Read input from all segments in the input level */
234414 /* Remove the redundant segments from the input level */
234453 int iBestLvl = 0; /* Level offering the most input segments */
234454 int nBest = 0; /* Number of input segments on best level */
234456 /* Set iBestLvl to the level to read input segments from. */
235078 /* Initialize a doclist-iterator for each input buffer. Arrange them in
235094 ** input sizes + 1 varint (9 bytes). The extra varint is because if the
235095 ** first rowid in one input is a large negative number, and the first in
235100 ** Or, if the input position-lists are corrupt, then the output might
235103 ** it to the output. This can happen at most once for each input
235138 ** corrupt input position lists might cause the output to consume
236447 ** after either the input buffer is exhausted or a 0 value is read.
236449 ** The return value is the number of bytes read from the input buffer.
236469 ** The return value is the number of bytes read from the input buffer.
241386 u32 iCode; /* non-ASCII codepoint read from input */
244797 CODEC_STATIC int opensslCipher(void *iCtx, Buffer *input, unsigned char *output){
244801 EVP_CipherUpdate(ctx, output, &cipherLength, input->buffer, input->bufferSize);
244806 if(outputLength != input->bufferSize){
244872 CODEC_STATIC int sqlite3CodecHex2int(char input){
244873 if(input >= '0' && input <= '9'){
244874 return (int)(input - '0');
244875 }else if(input >= 'a' && input <= 'f'){
244876 return (int)(input - 'a') + 10;
244877 }else if(input >= 'A' && input <= 'F'){
244878 return (int)(input - 'A') + 10;
244902 CODEC_STATIC int sqlite3CodecIfMemset(unsigned char *input, unsigned char val, int len){
244905 if(input[i] != val){
244912 CODEC_STATIC int sqlite3CodecIsKeyInfoFormat(const unsigned char *input, int inputSize){
244913 return (input[0] == 'x') && (input[1] == '\'') && (input[inputSize - 1] == '\'') && (sqlite3CodecIsHex(input + 2, inputSize - 3)) ? 1 : 0;
244984 CODEC_STATIC int sqlite3CodecCopyDeriveKey(KeyContext *input, KeyContext *output){
244986 if(input->key != NULL && input->codecConst.keySize > 0){
244992 rc = memcpy_s(output->key, output->codecConst.keySize, input->key, input->codecConst.keySize);
244998 if(input->hmacKey != NULL && input->codecConst.keySize > 0){
245004 rc = memcpy_s(output->hmacKey, output->codecConst.keySize, input->hmacKey, input->codecConst.keySize);
245010 if(input->keyInfo != NULL && input->codecConst.keyInfoSize > 0){
245016 rc = memcpy_s(output->keyInfo, output->codecConst.keyInfoSize, input->keyInfo, input->codecConst.keyInfoSize);
245319 CODEC_STATIC int sqlite3CodecCopyKeyContext(KeyContext *input, KeyContext *output){
245320 errno_t rc = memcpy_s(output, sizeof(KeyContext), input, KEY_CONTEXT_HEAD_SIZE);
245324 if(input->password != NULL && input->passwordSize > 0){
245330 rc = memcpy_s(output->password, output->passwordSize, input->password, input->passwordSize);
245336 return sqlite3CodecCopyDeriveKey(input, output);
245477 CODEC_STATIC void sqlite3CodecTransPgno(Pgno input, unsigned char *output){
245479 sqlite3Put4byte(output, input);
245481 output[0] = (u8)input;
245482 output[1] = (u8)(input>>8);
245483 output[2] = (u8)(input>>16);
245484 output[3] = (u8)(input>>24);
245488 CODEC_STATIC int sqlite3CodecHmac(KeyContext *ctx, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *output){
245493 input1.buffer = input;
245510 CODEC_STATIC int sqlite3CodecCheckHmac(KeyContext *ctx, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *expectResult){
245517 rc = sqlite3CodecHmac(ctx, pgno, bufferSize, input, buffer);
245527 rc = sqlite3CodecHmac(ctx, pgno, bufferSize, input, output);
245538 CODEC_STATIC int sqlite3CodecEncryptData(CodecContext *ctx, OperateContext whichKey, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *output){
245561 inputBuffer.buffer = input;
245586 CODEC_STATIC int sqlite3CodecDecryptData(CodecContext *ctx, OperateContext whichKey, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *output){
245608 if(sqlite3CodecIfMemset(input, 0, bufferSize)){
245616 inputBuffer.buffer = input;
245618 if(sqlite3CodecCheckHmac(keyCtx, pgno, inputBuffer.bufferSize + keyCtx->codecConst.initVectorSize, input, input + inputBuffer.bufferSize + keyCtx->codecConst.initVectorSize)){
245623 unsigned char *initVector = input + inputBuffer.bufferSize;