Lines Matching defs:mem
3632 typedef struct Mem sqlite3_value;
8453 typedef struct Mem Mem;
8478 Mem *pMem; /* Used when p4type is P4_MEM */
8531 #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
8553 ** The Vdbe.aColName array contains 5n Mem structures, where n is the
10335 Mem *aMem; /* Values */
12947 Mem *aMem; /* Array of memory cells for parent frame */
12962 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
12970 ** Internally, the vdbe manipulates nearly all SQL values as Mem
12971 ** structures. Each Mem struct may cache multiple representations (string,
12974 struct Mem {
12990 Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
12991 void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
12993 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
12998 ** representations of the value stored in the Mem struct.
13003 ** If the MEM_Str flag is set then Mem.z points at a string representation.
13019 /* Whenever Mem contains a valid string or blob representation, one of
13021 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
13025 #define MEM_Dyn 0x0400 /* Need to call sqliteFree() on Mem.z */
13026 #define MEM_Static 0x0800 /* Mem.z points to a static string */
13027 #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
13028 #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
13029 #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
13036 ** Clear any existing type flags from a Mem and replace them with f
13079 ** (Mem) which are only defined there.
13084 Mem s; /* The return value is stored here */
13085 Mem *pMem; /* Memory cell used to store aggregate context */
13121 Mem *aMem; /* The memory locations */
13122 Mem **apArg; /* Arguments to currently executing user function */
13123 Mem *aColName; /* Column names to return */
13124 Mem *pResultSet; /* Pointer to an array of results */
13136 Mem *aVar; /* Values for the OP_Variable opcode. */
13199 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
13200 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
13201 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
13207 SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
13211 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
13212 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
13213 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
13214 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
13215 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
13216 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
13217 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
13218 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
13222 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
13224 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
13225 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
13226 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
13227 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
13228 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, int);
13229 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
13230 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
13231 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
13232 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
13233 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
13234 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
13235 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
13236 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
13237 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
13241 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
13243 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
13247 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
13261 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *, Mem *);
13264 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(sqlite3 *, VdbeCursor *, Mem *);
13265 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(VdbeCursor *, Mem *, int *);
13277 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
13286 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
13289 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
13291 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem);
13294 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *);
15535 ** into a single structure named "mem". This is to keep the
15580 } mem;
15592 mem.nAlloc[i]++;
15593 mem.nCurrent[i]++;
15594 if( mem.nCurrent[i]>mem.mxCurrent[i] ){
15595 mem.mxCurrent[i] = mem.nCurrent[i];
15598 mem.nCurrent[i]--;
15599 assert( mem.nCurrent[i]>=0 );
15651 mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
15661 mem.mutex = 0;
15707 sqlite3_mutex_enter(mem.mutex);
15708 assert( mem.disallow==0 );
15711 mem.nBacktrace*sizeof(void*) + mem.nTitle;
15715 pBt = (void**)&z[mem.nTitle];
15716 pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
15718 pHdr->pPrev = mem.pLast;
15719 if( mem.pLast ){
15720 mem.pLast->pNext = pHdr;
15722 mem.pFirst = pHdr;
15724 mem.pLast = pHdr;
15727 pHdr->nBacktraceSlots = mem.nBacktrace;
15728 pHdr->nTitle = mem.nTitle;
15729 if( mem.nBacktrace ){
15731 pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
15734 if( mem.xBacktrace ){
15735 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
15740 if( mem.nTitle ){
15741 memcpy(z, mem.zTitle, mem.nTitle);
15751 sqlite3_mutex_leave(mem.mutex);
15763 || mem.mutex!=0 );
15767 sqlite3_mutex_enter(mem.mutex);
15772 assert( mem.pFirst==pHdr );
15773 mem.pFirst = pHdr->pNext;
15779 assert( mem.pLast==pHdr );
15780 mem.pLast = pHdr->pPrev;
15788 sqlite3_mutex_leave(mem.mutex);
15803 assert( mem.disallow==0 );
15900 mem.nBacktrace = depth;
15904 mem.xBacktrace = xBacktrace;
15912 sqlite3_mutex_enter(mem.mutex);
15913 if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
15914 memcpy(mem.zTitle, zTitle, n);
15915 mem.zTitle[n] = 0;
15916 mem.nTitle = ROUND8(n);
15917 sqlite3_mutex_leave(mem.mutex);
15922 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15925 mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
15944 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15959 if( mem.nAlloc[i] ){
15961 i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
15964 if( mem.nAlloc[NCSIZE-1] ){
15966 NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
15967 mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
15979 nTotal += mem.nAlloc[i];
20676 ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
20687 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
20825 ** the encoding of the Mem adjusted. This routine does not do any
20826 ** byte-swapping, it just sets Mem.enc appropriately.
20828 ** The allocation (static, dynamic etc.) and encoding of the Mem may be
20831 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){
20924 Mem m;
20952 Mem m;
58380 ** This file contains code use to manipulate "Mem" structure. A "Mem"
58381 ** stores a single value in the VDBE. Mem is an opaque structure visible
58382 ** only within the VDBE. Interface routines refer to a Mem using the
58399 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
58434 ** not set, Mem.n is zeroed.
58436 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
58475 ** Make the given Mem object MEM_Dyn. In other words, make it so
58482 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
58504 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
58508 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
58534 ** Make sure the given Mem is \u0000 terminated.
58536 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
58551 ** Add MEM_Str to the set of representations for the given Mem. Numbers
58563 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, int enc){
58607 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
58630 ** does not free any Mem.zMalloc buffer.
58632 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
58651 ** Release any memory held by the Mem. This may leave the Mem in an
58652 ** inconsistent state, for example with (Mem.z==0) and
58653 ** (Mem.type==SQLITE_TEXT).
58655 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
58715 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
58741 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
58760 ** The MEM structure is already a MEM_Real. Try to also make it a
58763 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
58798 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
58812 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
58829 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
58849 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
58866 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
58888 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
58900 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
58916 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
58934 ** Return true if the Mem object contains a TEXT or BLOB that is
58937 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
58958 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
58960 Mem *pX;
58972 ** Size of struct Mem not including the Mem.zMalloc member.
58974 #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
58982 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
58998 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
59022 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
59028 memcpy(pTo, pFrom, sizeof(Mem));
59035 ** Change the value of a Mem to be a string or a BLOB.
59040 ** Mem structure. Otherwise, any existing buffer is freed and the
59050 Mem *pMem, /* Memory cell to set to string value */
59085 /* The following block sets the new values of Mem.z and Mem.xDel. It
59139 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
59220 Mem c1;
59221 Mem c2;
59249 ** Move data out of a btree key or data field and into a Mem structure.
59266 Mem *pMem /* OUT: Return data in this Mem structure. */
59358 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
59494 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
59502 sqlite3VdbeMemRelease((Mem *)v);
59503 sqlite3DbFree(((Mem*)v)->db, v);
59511 Mem *p = (Mem*)pVal;
60149 Mem *p = (Mem*)p4;
60434 Mem *pMem = pOp->p4.pMem;
60583 ** Release an array of N Mem elements
60585 static void releaseMemArray(Mem *p, int N){
60587 Mem *pEnd;
60630 Mem *aMem = VdbeFrameMem(p);
60661 Mem *pSub = 0; /* Memory cell hold array of subprogs */
60665 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
61051 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
61052 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
61053 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
61207 Mem *pColName;
61215 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
61242 Mem *pColName;
62094 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
62218 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
62271 Mem *pMem /* Memory cell to write value into */
62390 Mem)*(pKeyInfo->nField+1);
62400 p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
62422 Mem *pMem = p->aMem;
62474 Mem mem1;
62574 Mem m, v;
62656 Mem m;
62731 Mem *pMem = &v->aVar[iVar-1];
62735 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
62737 sqlite3VdbeMemStoreType((Mem *)pRet);
62895 ** The following routines extract information from a Mem or sqlite3_value
62899 Mem *p = (Mem*)pVal;
62916 return sqlite3VdbeRealValue((Mem*)pVal);
62919 return (int)sqlite3VdbeIntValue((Mem*)pVal);
62922 return sqlite3VdbeIntValue((Mem*)pVal);
63327 Mem *pMem;
63445 ** it is, return a pointer to the Mem for the value of that column.
63446 ** If iCol is not valid, return a pointer to a Mem which has a value
63449 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
63451 Mem *pOut;
63459 ** a pointer to the following static Mem object which contains the
63460 ** value SQL NULL. Even though the Mem structure contains an element
63462 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
63465 ** that a Mem structure is located on an 8-byte boundary. To prevent
63469 static const Mem nullMem
63483 pOut = (Mem*)&nullMem;
63565 Mem *pOut = columnMem(pStmt, i);
63612 const void *(*xFunc)(Mem*),
63645 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
63650 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
63670 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
63675 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
63688 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
63693 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
63704 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
63709 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
63720 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
63725 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
63747 Mem *pVar;
63799 Mem *pVar;
64150 Mem *pVar; /* Value of a host parameter */
64202 Mem utf8;
64448 static void updateMaxBlobsize(Mem *p){
64512 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
64559 Mem *pMem = &p->aMem[p->nMem-iCur];
64596 static void applyNumericAffinity(Mem *pRec){
64632 Mem *pRec, /* The value to apply affinity to */
64662 Mem *pMem = (Mem*)pVal;
64672 ** not the internal Mem* type.
64679 applyAffinity((Mem *)pVal, affinity, enc);
64687 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
64769 static void memTracePrint(FILE *out, Mem *p){
64789 static void registerTrace(FILE *out, int iReg, Mem *p){
64995 Mem *aMem = p->aMem; /* Copy of p->aMem */
64996 Mem *pIn1 = 0; /* 1st input operand */
64997 Mem *pIn2 = 0; /* 2nd input operand */
64998 Mem *pIn3 = 0; /* 3rd input operand */
64999 Mem *pOut = 0; /* Output operand */
65023 Mem *pVar; /* Value being transferred */
65032 Mem *pMem;
65047 Mem *pArg;
65095 Mem *pDest; /* Where to write the extracted value */
65096 Mem sMem; /* For storing the record being decoded */
65104 Mem *pReg; /* PseudoTable input register */
65112 Mem *pRec; /* The new record */
65119 Mem *pData0; /* First field to be combined into the record */
65120 Mem *pLast; /* Last field of the record */
65199 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
65206 Mem *aMx;
65221 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
65225 Mem *pData; /* MEM cell holding data for the record to be inserted */
65226 Mem *pKey; /* MEM cell holding key for the record */
65323 Mem *pnErr; /* Register keeping track of errors remaining */
65335 Mem *pRt; /* Register to allocate runtime space */
65336 Mem *pMem; /* Used to iterate through memory cells */
65337 Mem *pEnd; /* Last memory cell in new array */
65344 Mem *pIn;
65347 Mem *pIn1;
65353 Mem *pMem;
65354 Mem *pRec;
65359 Mem *pMem;
65364 Mem *pMem; /* Write results here */
65389 Mem *pQuery;
65390 Mem *pArgc;
65396 Mem **apArg;
65401 Mem *pDest;
65412 Mem *pName;
65420 Mem **apArg;
65421 Mem *pX;
65516 ** external allocations out of mem[p2] and set mem[p2] to be
65518 ** value or convert mem[p2] to a different type.
65864 Mem *pVar; /* Value being transferred */
65973 Mem *pMem;
66246 Mem *pArg;
67028 Mem *pDest; /* Where to write the extracted value */
67029 Mem sMem; /* For storing the record being decoded */
67037 Mem *pReg; /* PseudoTable input register */
67258 ** a pointer to a Mem object.
67353 Mem *pRec; /* The new record */
67360 Mem *pData0; /* First field to be combined into the record */
67361 Mem *pLast; /* Last field of the record */
68486 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
68572 Mem *aMx;
68719 Mem
68796 assert( (u.bg.pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
68897 Mem *pData; /* MEM cell holding data for the record to be inserted */
68898 Mem *pKey; /* MEM cell holding key for the record */
69889 Mem *pnErr; /* Register keeping track of errors remaining */
70048 Mem *pRt; /* Register to allocate runtime space */
70049 Mem *pMem; /* Used to iterate through memory cells */
70050 Mem *pEnd; /* Last memory cell in new array */
70095 + u.cc.nMem * sizeof(Mem)
70167 Mem *pIn;
70228 Mem *pIn1;
70312 Mem *pMem;
70313 Mem *pRec;
70377 Mem *pMem;
70399 ** or RESTART. Write 1 or 0 into mem[P3] if the checkpoint returns
70401 ** WAL after the checkpoint into mem[P3+1] and the number of pages
70403 ** completes into mem[P3+2]. However on an error, mem[P3+1] and
70404 ** mem[P3+2] are initialized to -1.
70410 Mem *pMem; /* Write results here */
70734 Mem *pQuery;
70735 Mem *pArgc;
70741 Mem **apArg;
70797 Mem *pDest;
70831 ** dynamic allocation in u.cn.sContext.s (a Mem struct) is released.
70902 Mem *pName;
70955 Mem **apArg;
70956 Mem *pX;
72266 Mem *pVal /* Memory cell containing record */
72498 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *pCsr, Mem *pOut){
72525 Mem *pVal, /* Value to compare to current sorter key */
79818 ** iMem+nCol+1 .. Mem+2*nCol:
87475 Mem *pArg = (Mem *)argv[0];
87476 Mem *pBest;
87479 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
92224 int mem = ++pParse->nMem;
92229 sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
92232 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
92437 int mem = ++pParse->nMem;
92438 sqlite3VdbeAddOp4(v, OP_String8, 0, mem, 0, aFcntl[0], 0);
92441 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
96437 ** records the previous output. mem[regPrev] is a flag that is false
98594 int iAMem; /* First Mem address for storing current GROUP BY */
98595 int iBMem; /* First Mem address for previous GROUP BY */
98596 int iUseFlag; /* Mem address holding flag indicating that at least
98599 int iAbortFlag; /* Mem address which causes query abort if positive */
