← Back to branch summary

~ubuntu-branches/ubuntu/hardy/php5/hardy-updates

« back to all changes in this revision

Viewing changes to ext/sqlite/libsqlite/src/vdbeaux.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-10-09 03:14:32 UTC
  • Revision ID: james.westby@ubuntu.com-20051009031432-kspik3lobxstafv9
Tags: upstream-5.0.5
Import upstream version 5.0.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/sqlite/libsqlite/src/vdbeaux.c
 
1
/*
 
2
** 2003 September 6
 
3
**
 
4
** The author disclaims copyright to this source code.  In place of
 
5
** a legal notice, here is a blessing:
 
6
**
 
7
**    May you do good and not evil.
 
8
**    May you find forgiveness for yourself and forgive others.
 
9
**    May you share freely, never taking more than you give.
 
10
**
 
11
*************************************************************************
 
12
** This file contains code used for creating, destroying, and populating
 
13
** a VDBE (or an "sqlite_vm" as it is known to the outside world.)  Prior
 
14
** to version 2.8.7, all this code was combined into the vdbe.c source file.
 
15
** But that file was getting too big so this subroutines were split out.
 
16
*/
 
17
#include "sqliteInt.h"
 
18
#include "os.h"
 
19
#include <ctype.h>
 
20
#include "vdbeInt.h"
 
21
 
 
22
 
 
23
/*
 
24
** When debugging the code generator in a symbolic debugger, one can
 
25
** set the sqlite_vdbe_addop_trace to 1 and all opcodes will be printed
 
26
** as they are added to the instruction stream.
 
27
*/
 
28
#ifndef NDEBUG
 
29
int sqlite_vdbe_addop_trace = 0;
 
30
#endif
 
31
 
 
32
 
 
33
/*
 
34
** Create a new virtual database engine.
 
35
*/
 
36
Vdbe *sqliteVdbeCreate(sqlite *db){
 
37
  Vdbe *p;
 
38
  p = sqliteMalloc( sizeof(Vdbe) );
 
39
  if( p==0 ) return 0;
 
40
  p->db = db;
 
41
  if( db->pVdbe ){
 
42
    db->pVdbe->pPrev = p;
 
43
  }
 
44
  p->pNext = db->pVdbe;
 
45
  p->pPrev = 0;
 
46
  db->pVdbe = p;
 
47
  p->magic = VDBE_MAGIC_INIT;
 
48
  return p;
 
49
}
 
50
 
 
51
/*
 
52
** Turn tracing on or off
 
53
*/
 
54
void sqliteVdbeTrace(Vdbe *p, FILE *trace){
 
55
  p->trace = trace;
 
56
}
 
57
 
 
58
/*
 
59
** Add a new instruction to the list of instructions current in the
 
60
** VDBE.  Return the address of the new instruction.
 
61
**
 
62
** Parameters:
 
63
**
 
64
**    p               Pointer to the VDBE
 
65
**
 
66
**    op              The opcode for this instruction
 
67
**
 
68
**    p1, p2          First two of the three possible operands.
 
69
**
 
70
** Use the sqliteVdbeResolveLabel() function to fix an address and
 
71
** the sqliteVdbeChangeP3() function to change the value of the P3
 
72
** operand.
 
73
*/
 
74
int sqliteVdbeAddOp(Vdbe *p, int op, int p1, int p2){
 
75
  int i;
 
76
  VdbeOp *pOp;
 
77
 
 
78
  i = p->nOp;
 
79
  p->nOp++;
 
80
  assert( p->magic==VDBE_MAGIC_INIT );
 
81
  if( i>=p->nOpAlloc ){
 
82
    int oldSize = p->nOpAlloc;
 
83
    Op *aNew;
 
84
    p->nOpAlloc = p->nOpAlloc*2 + 100;
 
85
    aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op));
 
86
    if( aNew==0 ){
 
87
      p->nOpAlloc = oldSize;
 
88
      return 0;
 
89
    }
 
90
    p->aOp = aNew;
 
91
    memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op));
 
92
  }
 
93
  pOp = &p->aOp[i];
 
94
  pOp->opcode = op;
 
95
  pOp->p1 = p1;
 
96
  if( p2<0 && (-1-p2)<p->nLabel && p->aLabel[-1-p2]>=0 ){
 
97
    p2 = p->aLabel[-1-p2];
 
98
  }
 
99
  pOp->p2 = p2;
 
100
  pOp->p3 = 0;
 
101
  pOp->p3type = P3_NOTUSED;
 
102
#ifndef NDEBUG
 
103
  if( sqlite_vdbe_addop_trace ) sqliteVdbePrintOp(0, i, &p->aOp[i]);
 
104
#endif
 
105
  return i;
 
106
}
 
107
 
 
108
/*
 
109
** Add an opcode that includes the p3 value.
 
110
*/
 
111
int sqliteVdbeOp3(Vdbe *p, int op, int p1, int p2, const char *zP3, int p3type){
 
112
  int addr = sqliteVdbeAddOp(p, op, p1, p2);
 
113
  sqliteVdbeChangeP3(p, addr, zP3, p3type);
 
114
  return addr;
 
115
}
 
116
 
 
117
/*
 
118
** Add multiple opcodes.  The list is terminated by an opcode of 0.
 
119
*/
 
120
int sqliteVdbeCode(Vdbe *p, ...){
 
121
  int addr;
 
122
  va_list ap;
 
123
  int opcode, p1, p2;
 
124
  va_start(ap, p);
 
125
  addr = p->nOp;
 
126
  while( (opcode = va_arg(ap,int))!=0 ){
 
127
    p1 = va_arg(ap,int);
 
128
    p2 = va_arg(ap,int);
 
129
    sqliteVdbeAddOp(p, opcode, p1, p2);
 
130
  }
 
131
  va_end(ap);
 
132
  return addr;
 
133
}
 
134
 
 
135
 
 
136
 
 
137
/*
 
138
** Create a new symbolic label for an instruction that has yet to be
 
139
** coded.  The symbolic label is really just a negative number.  The
 
140
** label can be used as the P2 value of an operation.  Later, when
 
141
** the label is resolved to a specific address, the VDBE will scan
 
142
** through its operation list and change all values of P2 which match
 
143
** the label into the resolved address.
 
144
**
 
145
** The VDBE knows that a P2 value is a label because labels are
 
146
** always negative and P2 values are suppose to be non-negative.
 
147
** Hence, a negative P2 value is a label that has yet to be resolved.
 
148
*/
 
149
int sqliteVdbeMakeLabel(Vdbe *p){
 
150
  int i;
 
151
  i = p->nLabel++;
 
152
  assert( p->magic==VDBE_MAGIC_INIT );
 
153
  if( i>=p->nLabelAlloc ){
 
154
    int *aNew;
 
155
    p->nLabelAlloc = p->nLabelAlloc*2 + 10;
 
156
    aNew = sqliteRealloc( p->aLabel, p->nLabelAlloc*sizeof(p->aLabel[0]));
 
157
    if( aNew==0 ){
 
158
      sqliteFree(p->aLabel);
 
159
    }
 
160
    p->aLabel = aNew;
 
161
  }
 
162
  if( p->aLabel==0 ){
 
163
    p->nLabel = 0;
 
164
    p->nLabelAlloc = 0;
 
165
    return 0;
 
166
  }
 
167
  p->aLabel[i] = -1;
 
168
  return -1-i;
 
169
}
 
170
 
 
171
/*
 
172
** Resolve label "x" to be the address of the next instruction to
 
173
** be inserted.  The parameter "x" must have been obtained from
 
174
** a prior call to sqliteVdbeMakeLabel().
 
175
*/
 
176
void sqliteVdbeResolveLabel(Vdbe *p, int x){
 
177
  int j;
 
178
  assert( p->magic==VDBE_MAGIC_INIT );
 
179
  if( x<0 && (-x)<=p->nLabel && p->aOp ){
 
180
    if( p->aLabel[-1-x]==p->nOp ) return;
 
181
    assert( p->aLabel[-1-x]<0 );
 
182
    p->aLabel[-1-x] = p->nOp;
 
183
    for(j=0; j<p->nOp; j++){
 
184
      if( p->aOp[j].p2==x ) p->aOp[j].p2 = p->nOp;
 
185
    }
 
186
  }
 
187
}
 
188
 
 
189
/*
 
190
** Return the address of the next instruction to be inserted.
 
191
*/
 
192
int sqliteVdbeCurrentAddr(Vdbe *p){
 
193
  assert( p->magic==VDBE_MAGIC_INIT );
 
194
  return p->nOp;
 
195
}
 
196
 
 
197
/*
 
198
** Add a whole list of operations to the operation stack.  Return the
 
199
** address of the first operation added.
 
200
*/
 
201
int sqliteVdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
 
202
  int addr;
 
203
  assert( p->magic==VDBE_MAGIC_INIT );
 
204
  if( p->nOp + nOp >= p->nOpAlloc ){
 
205
    int oldSize = p->nOpAlloc;
 
206
    Op *aNew;
 
207
    p->nOpAlloc = p->nOpAlloc*2 + nOp + 10;
 
208
    aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op));
 
209
    if( aNew==0 ){
 
210
      p->nOpAlloc = oldSize;
 
211
      return 0;
 
212
    }
 
213
    p->aOp = aNew;
 
214
    memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op));
 
215
  }
 
216
  addr = p->nOp;
 
217
  if( nOp>0 ){
 
218
    int i;
 
219
    VdbeOpList const *pIn = aOp;
 
220
    for(i=0; i<nOp; i++, pIn++){
 
221
      int p2 = pIn->p2;
 
222
      VdbeOp *pOut = &p->aOp[i+addr];
 
223
      pOut->opcode = pIn->opcode;
 
224
      pOut->p1 = pIn->p1;
 
225
      pOut->p2 = p2<0 ? addr + ADDR(p2) : p2;
 
226
      pOut->p3 = pIn->p3;
 
227
      pOut->p3type = pIn->p3 ? P3_STATIC : P3_NOTUSED;
 
228
#ifndef NDEBUG
 
229
      if( sqlite_vdbe_addop_trace ){
 
230
        sqliteVdbePrintOp(0, i+addr, &p->aOp[i+addr]);
 
231
      }
 
232
#endif
 
233
    }
 
234
    p->nOp += nOp;
 
235
  }
 
236
  return addr;
 
237
}
 
238
 
 
239
/*
 
240
** Change the value of the P1 operand for a specific instruction.
 
241
** This routine is useful when a large program is loaded from a
 
242
** static array using sqliteVdbeAddOpList but we want to make a
 
243
** few minor changes to the program.
 
244
*/
 
245
void sqliteVdbeChangeP1(Vdbe *p, int addr, int val){
 
246
  assert( p->magic==VDBE_MAGIC_INIT );
 
247
  if( p && addr>=0 && p->nOp>addr && p->aOp ){
 
248
    p->aOp[addr].p1 = val;
 
249
  }
 
250
}
 
251
 
 
252
/*
 
253
** Change the value of the P2 operand for a specific instruction.
 
254
** This routine is useful for setting a jump destination.
 
255
*/
 
256
void sqliteVdbeChangeP2(Vdbe *p, int addr, int val){
 
257
  assert( val>=0 );
 
258
  assert( p->magic==VDBE_MAGIC_INIT );
 
259
  if( p && addr>=0 && p->nOp>addr && p->aOp ){
 
260
    p->aOp[addr].p2 = val;
 
261
  }
 
262
}
 
263
 
 
264
/*
 
265
** Change the value of the P3 operand for a specific instruction.
 
266
** This routine is useful when a large program is loaded from a
 
267
** static array using sqliteVdbeAddOpList but we want to make a
 
268
** few minor changes to the program.
 
269
**
 
270
** If n>=0 then the P3 operand is dynamic, meaning that a copy of
 
271
** the string is made into memory obtained from sqliteMalloc().
 
272
** A value of n==0 means copy bytes of zP3 up to and including the
 
273
** first null byte.  If n>0 then copy n+1 bytes of zP3.
 
274
**
 
275
** If n==P3_STATIC  it means that zP3 is a pointer to a constant static
 
276
** string and we can just copy the pointer.  n==P3_POINTER means zP3 is
 
277
** a pointer to some object other than a string.
 
278
**
 
279
** If addr<0 then change P3 on the most recently inserted instruction.
 
280
*/
 
281
void sqliteVdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){
 
282
  Op *pOp;
 
283
  assert( p->magic==VDBE_MAGIC_INIT );
 
284
  if( p==0 || p->aOp==0 ) return;
 
285
  if( addr<0 || addr>=p->nOp ){
 
286
    addr = p->nOp - 1;
 
287
    if( addr<0 ) return;
 
288
  }
 
289
  pOp = &p->aOp[addr];
 
290
  if( pOp->p3 && pOp->p3type==P3_DYNAMIC ){
 
291
    sqliteFree(pOp->p3);
 
292
    pOp->p3 = 0;
 
293
  }
 
294
  if( zP3==0 ){
 
295
    pOp->p3 = 0;
 
296
    pOp->p3type = P3_NOTUSED;
 
297
  }else if( n<0 ){
 
298
    pOp->p3 = (char*)zP3;
 
299
    pOp->p3type = n;
 
300
  }else{
 
301
    sqliteSetNString(&pOp->p3, zP3, n, 0);
 
302
    pOp->p3type = P3_DYNAMIC;
 
303
  }
 
304
}
 
305
 
 
306
/*
 
307
** If the P3 operand to the specified instruction appears
 
308
** to be a quoted string token, then this procedure removes 
 
309
** the quotes.
 
310
**
 
311
** The quoting operator can be either a grave ascent (ASCII 0x27)
 
312
** or a double quote character (ASCII 0x22).  Two quotes in a row
 
313
** resolve to be a single actual quote character within the string.
 
314
*/
 
315
void sqliteVdbeDequoteP3(Vdbe *p, int addr){
 
316
  Op *pOp;
 
317
  assert( p->magic==VDBE_MAGIC_INIT );
 
318
  if( p->aOp==0 ) return;
 
319
  if( addr<0 || addr>=p->nOp ){
 
320
    addr = p->nOp - 1;
 
321
    if( addr<0 ) return;
 
322
  }
 
323
  pOp = &p->aOp[addr];
 
324
  if( pOp->p3==0 || pOp->p3[0]==0 ) return;
 
325
  if( pOp->p3type==P3_POINTER ) return;
 
326
  if( pOp->p3type!=P3_DYNAMIC ){
 
327
    pOp->p3 = sqliteStrDup(pOp->p3);
 
328
    pOp->p3type = P3_DYNAMIC;
 
329
  }
 
330
  sqliteDequote(pOp->p3);
 
331
}
 
332
 
 
333
/*
 
334
** On the P3 argument of the given instruction, change all
 
335
** strings of whitespace characters into a single space and
 
336
** delete leading and trailing whitespace.
 
337
*/
 
338
void sqliteVdbeCompressSpace(Vdbe *p, int addr){
 
339
  unsigned char *z;
 
340
  int i, j;
 
341
  Op *pOp;
 
342
  assert( p->magic==VDBE_MAGIC_INIT );
 
343
  if( p->aOp==0 || addr<0 || addr>=p->nOp ) return;
 
344
  pOp = &p->aOp[addr];
 
345
  if( pOp->p3type==P3_POINTER ){
 
346
    return;
 
347
  }
 
348
  if( pOp->p3type!=P3_DYNAMIC ){
 
349
    pOp->p3 = sqliteStrDup(pOp->p3);
 
350
    pOp->p3type = P3_DYNAMIC;
 
351
  }
 
352
  z = (unsigned char*)pOp->p3;
 
353
  if( z==0 ) return;
 
354
  i = j = 0;
 
355
  while( isspace(z[i]) ){ i++; }
 
356
  while( z[i] ){
 
357
    if( isspace(z[i]) ){
 
358
      z[j++] = ' ';
 
359
      while( isspace(z[++i]) ){}
 
360
    }else{
 
361
      z[j++] = z[i++];
 
362
    }
 
363
  }
 
364
  while( j>0 && isspace(z[j-1]) ){ j--; }
 
365
  z[j] = 0;
 
366
}
 
367
 
 
368
/*
 
369
** Search for the current program for the given opcode and P2
 
370
** value.  Return the address plus 1 if found and 0 if not found.
 
371
*/
 
372
int sqliteVdbeFindOp(Vdbe *p, int op, int p2){
 
373
  int i;
 
374
  assert( p->magic==VDBE_MAGIC_INIT );
 
375
  for(i=0; i<p->nOp; i++){
 
376
    if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return i+1;
 
377
  }
 
378
  return 0;
 
379
}
 
380
 
 
381
/*
 
382
** Return the opcode for a given address.
 
383
*/
 
384
VdbeOp *sqliteVdbeGetOp(Vdbe *p, int addr){
 
385
  assert( p->magic==VDBE_MAGIC_INIT );
 
386
  assert( addr>=0 && addr<p->nOp );
 
387
  return &p->aOp[addr];
 
388
}
 
389
 
 
390
/*
 
391
** The following group or routines are employed by installable functions
 
392
** to return their results.
 
393
**
 
394
** The sqlite_set_result_string() routine can be used to return a string
 
395
** value or to return a NULL.  To return a NULL, pass in NULL for zResult.
 
396
** A copy is made of the string before this routine returns so it is safe
 
397
** to pass in an ephemeral string.
 
398
**
 
399
** sqlite_set_result_error() works like sqlite_set_result_string() except
 
400
** that it signals a fatal error.  The string argument, if any, is the
 
401
** error message.  If the argument is NULL a generic substitute error message
 
402
** is used.
 
403
**
 
404
** The sqlite_set_result_int() and sqlite_set_result_double() set the return
 
405
** value of the user function to an integer or a double.
 
406
**
 
407
** These routines are defined here in vdbe.c because they depend on knowing
 
408
** the internals of the sqlite_func structure which is only defined in 
 
409
** this source file.
 
410
*/
 
411
char *sqlite_set_result_string(sqlite_func *p, const char *zResult, int n){
 
412
  assert( !p->isStep );
 
413
  if( p->s.flags & MEM_Dyn ){
 
414
    sqliteFree(p->s.z);
 
415
  }
 
416
  if( zResult==0 ){
 
417
    p->s.flags = MEM_Null;
 
418
    n = 0;
 
419
    p->s.z = 0;
 
420
    p->s.n = 0;
 
421
  }else{
 
422
    if( n<0 ) n = strlen(zResult);
 
423
    if( n<NBFS-1 ){
 
424
      memcpy(p->s.zShort, zResult, n);
 
425
      p->s.zShort[n] = 0;
 
426
      p->s.flags = MEM_Str | MEM_Short;
 
427
      p->s.z = p->s.zShort;
 
428
    }else{
 
429
      p->s.z = sqliteMallocRaw( n+1 );
 
430
      if( p->s.z ){
 
431
        memcpy(p->s.z, zResult, n);
 
432
        p->s.z[n] = 0;
 
433
      }
 
434
      p->s.flags = MEM_Str | MEM_Dyn;
 
435
    }
 
436
    p->s.n = n+1;
 
437
  }
 
438
  return p->s.z;
 
439
}
 
440
void sqlite_set_result_int(sqlite_func *p, int iResult){
 
441
  assert( !p->isStep );
 
442
  if( p->s.flags & MEM_Dyn ){
 
443
    sqliteFree(p->s.z);
 
444
  }
 
445
  p->s.i = iResult;
 
446
  p->s.flags = MEM_Int;
 
447
}
 
448
void sqlite_set_result_double(sqlite_func *p, double rResult){
 
449
  assert( !p->isStep );
 
450
  if( p->s.flags & MEM_Dyn ){
 
451
    sqliteFree(p->s.z);
 
452
  }
 
453
  p->s.r = rResult;
 
454
  p->s.flags = MEM_Real;
 
455
}
 
456
void sqlite_set_result_error(sqlite_func *p, const char *zMsg, int n){
 
457
  assert( !p->isStep );
 
458
  sqlite_set_result_string(p, zMsg, n);
 
459
  p->isError = 1;
 
460
}
 
461
 
 
462
/*
 
463
** Extract the user data from a sqlite_func structure and return a
 
464
** pointer to it.
 
465
*/
 
466
void *sqlite_user_data(sqlite_func *p){
 
467
  assert( p && p->pFunc );
 
468
  return p->pFunc->pUserData;
 
469
}
 
470
 
 
471
/*
 
472
** Allocate or return the aggregate context for a user function.  A new
 
473
** context is allocated on the first call.  Subsequent calls return the
 
474
** same context that was returned on prior calls.
 
475
**
 
476
** This routine is defined here in vdbe.c because it depends on knowing
 
477
** the internals of the sqlite_func structure which is only defined in
 
478
** this source file.
 
479
*/
 
480
void *sqlite_aggregate_context(sqlite_func *p, int nByte){
 
481
  assert( p && p->pFunc && p->pFunc->xStep );
 
482
  if( p->pAgg==0 ){
 
483
    if( nByte<=NBFS ){
 
484
      p->pAgg = (void*)p->s.z;
 
485
      memset(p->pAgg, 0, nByte);
 
486
    }else{
 
487
      p->pAgg = sqliteMalloc( nByte );
 
488
    }
 
489
  }
 
490
  return p->pAgg;
 
491
}
 
492
 
 
493
/*
 
494
** Return the number of times the Step function of a aggregate has been 
 
495
** called.
 
496
**
 
497
** This routine is defined here in vdbe.c because it depends on knowing
 
498
** the internals of the sqlite_func structure which is only defined in
 
499
** this source file.
 
500
*/
 
501
int sqlite_aggregate_count(sqlite_func *p){
 
502
  assert( p && p->pFunc && p->pFunc->xStep );
 
503
  return p->cnt;
 
504
}
 
505
 
 
506
#if !defined(NDEBUG) || defined(VDBE_PROFILE)
 
507
/*
 
508
** Print a single opcode.  This routine is used for debugging only.
 
509
*/
 
510
void sqliteVdbePrintOp(FILE *pOut, int pc, Op *pOp){
 
511
  char *zP3;
 
512
  char zPtr[40];
 
513
  if( pOp->p3type==P3_POINTER ){
 
514
    sprintf(zPtr, "ptr(%#lx)", (long)pOp->p3);
 
515
    zP3 = zPtr;
 
516
  }else{
 
517
    zP3 = pOp->p3;
 
518
  }
 
519
  if( pOut==0 ) pOut = stdout;
 
520
  fprintf(pOut,"%4d %-12s %4d %4d %s\n",
 
521
      pc, sqliteOpcodeNames[pOp->opcode], pOp->p1, pOp->p2, zP3 ? zP3 : "");
 
522
  fflush(pOut);
 
523
}
 
524
#endif
 
525
 
 
526
/*
 
527
** Give a listing of the program in the virtual machine.
 
528
**
 
529
** The interface is the same as sqliteVdbeExec().  But instead of
 
530
** running the code, it invokes the callback once for each instruction.
 
531
** This feature is used to implement "EXPLAIN".
 
532
*/
 
533
int sqliteVdbeList(
 
534
  Vdbe *p                   /* The VDBE */
 
535
){
 
536
  sqlite *db = p->db;
 
537
  int i;
 
538
  int rc = SQLITE_OK;
 
539
  static char *azColumnNames[] = {
 
540
     "addr", "opcode", "p1",  "p2",  "p3", 
 
541
     "int",  "text",   "int", "int", "text",
 
542
     0
 
543
  };
 
544
 
 
545
  assert( p->popStack==0 );
 
546
  assert( p->explain );
 
547
  p->azColName = azColumnNames;
 
548
  p->azResColumn = p->zArgv;
 
549
  for(i=0; i<5; i++) p->zArgv[i] = p->aStack[i].zShort;
 
550
  i = p->pc;
 
551
  if( i>=p->nOp ){
 
552
    p->rc = SQLITE_OK;
 
553
    rc = SQLITE_DONE;
 
554
  }else if( db->flags & SQLITE_Interrupt ){
 
555
    db->flags &= ~SQLITE_Interrupt;
 
556
    if( db->magic!=SQLITE_MAGIC_BUSY ){
 
557
      p->rc = SQLITE_MISUSE;
 
558
    }else{
 
559
      p->rc = SQLITE_INTERRUPT;
 
560
    }
 
561
    rc = SQLITE_ERROR;
 
562
    sqliteSetString(&p->zErrMsg, sqlite_error_string(p->rc), (char*)0);
 
563
  }else{
 
564
    sprintf(p->zArgv[0],"%d",i);
 
565
    sprintf(p->zArgv[2],"%d", p->aOp[i].p1);
 
566
    sprintf(p->zArgv[3],"%d", p->aOp[i].p2);
 
567
    if( p->aOp[i].p3type==P3_POINTER ){
 
568
      sprintf(p->aStack[4].zShort, "ptr(%#lx)", (long)p->aOp[i].p3);
 
569
      p->zArgv[4] = p->aStack[4].zShort;
 
570
    }else{
 
571
      p->zArgv[4] = p->aOp[i].p3;
 
572
    }
 
573
    p->zArgv[1] = sqliteOpcodeNames[p->aOp[i].opcode];
 
574
    p->pc = i+1;
 
575
    p->azResColumn = p->zArgv;
 
576
    p->nResColumn = 5;
 
577
    p->rc = SQLITE_OK;
 
578
    rc = SQLITE_ROW;
 
579
  }
 
580
  return rc;
 
581
}
 
582
 
 
583
/*
 
584
** Prepare a virtual machine for execution.  This involves things such
 
585
** as allocating stack space and initializing the program counter.
 
586
** After the VDBE has be prepped, it can be executed by one or more
 
587
** calls to sqliteVdbeExec().  
 
588
*/
 
589
void sqliteVdbeMakeReady(
 
590
  Vdbe *p,                       /* The VDBE */
 
591
  int nVar,                      /* Number of '?' see in the SQL statement */
 
592
  int isExplain                  /* True if the EXPLAIN keywords is present */
 
593
){
 
594
  int n;
 
595
 
 
596
  assert( p!=0 );
 
597
  assert( p->magic==VDBE_MAGIC_INIT );
 
598
 
 
599
  /* Add a HALT instruction to the very end of the program.
 
600
  */
 
601
  if( p->nOp==0 || (p->aOp && p->aOp[p->nOp-1].opcode!=OP_Halt) ){
 
602
    sqliteVdbeAddOp(p, OP_Halt, 0, 0);
 
603
  }
 
604
 
 
605
  /* No instruction ever pushes more than a single element onto the
 
606
  ** stack.  And the stack never grows on successive executions of the
 
607
  ** same loop.  So the total number of instructions is an upper bound
 
608
  ** on the maximum stack depth required.
 
609
  **
 
610
  ** Allocation all the stack space we will ever need.
 
611
  */
 
612
  if( p->aStack==0 ){
 
613
    p->nVar = nVar;
 
614
    assert( nVar>=0 );
 
615
    n = isExplain ? 10 : p->nOp;
 
616
    p->aStack = sqliteMalloc(
 
617
      n*(sizeof(p->aStack[0]) + 2*sizeof(char*))     /* aStack and zArgv */
 
618
        + p->nVar*(sizeof(char*)+sizeof(int)+1)    /* azVar, anVar, abVar */
 
619
    );
 
620
    p->zArgv = (char**)&p->aStack[n];
 
621
    p->azColName = (char**)&p->zArgv[n];
 
622
    p->azVar = (char**)&p->azColName[n];
 
623
    p->anVar = (int*)&p->azVar[p->nVar];
 
624
    p->abVar = (u8*)&p->anVar[p->nVar];
 
625
  }
 
626
 
 
627
  sqliteHashInit(&p->agg.hash, SQLITE_HASH_BINARY, 0);
 
628
  p->agg.pSearch = 0;
 
629
#ifdef MEMORY_DEBUG
 
630
  if( sqliteOsFileExists("vdbe_trace") ){
 
631
    p->trace = stdout;
 
632
  }
 
633
#endif
 
634
  p->pTos = &p->aStack[-1];
 
635
  p->pc = 0;
 
636
  p->rc = SQLITE_OK;
 
637
  p->uniqueCnt = 0;
 
638
  p->returnDepth = 0;
 
639
  p->errorAction = OE_Abort;
 
640
  p->undoTransOnError = 0;
 
641
  p->popStack =  0;
 
642
  p->explain |= isExplain;
 
643
  p->magic = VDBE_MAGIC_RUN;
 
644
#ifdef VDBE_PROFILE
 
645
  {
 
646
    int i;
 
647
    for(i=0; i<p->nOp; i++){
 
648
      p->aOp[i].cnt = 0;
 
649
      p->aOp[i].cycles = 0;
 
650
    }
 
651
  }
 
652
#endif
 
653
}
 
654
 
 
655
 
 
656
/*
 
657
** Remove any elements that remain on the sorter for the VDBE given.
 
658
*/
 
659
void sqliteVdbeSorterReset(Vdbe *p){
 
660
  while( p->pSort ){
 
661
    Sorter *pSorter = p->pSort;
 
662
    p->pSort = pSorter->pNext;
 
663
    sqliteFree(pSorter->zKey);
 
664
    sqliteFree(pSorter->pData);
 
665
    sqliteFree(pSorter);
 
666
  }
 
667
}
 
668
 
 
669
/*
 
670
** Reset an Agg structure.  Delete all its contents. 
 
671
**
 
672
** For installable aggregate functions, if the step function has been
 
673
** called, make sure the finalizer function has also been called.  The
 
674
** finalizer might need to free memory that was allocated as part of its
 
675
** private context.  If the finalizer has not been called yet, call it
 
676
** now.
 
677
*/
 
678
void sqliteVdbeAggReset(Agg *pAgg){
 
679
  int i;
 
680
  HashElem *p;
 
681
  for(p = sqliteHashFirst(&pAgg->hash); p; p = sqliteHashNext(p)){
 
682
    AggElem *pElem = sqliteHashData(p);
 
683
    assert( pAgg->apFunc!=0 );
 
684
    for(i=0; i<pAgg->nMem; i++){
 
685
      Mem *pMem = &pElem->aMem[i];
 
686
      if( pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){
 
687
        sqlite_func ctx;
 
688
        ctx.pFunc = pAgg->apFunc[i];
 
689
        ctx.s.flags = MEM_Null;
 
690
        ctx.pAgg = pMem->z;
 
691
        ctx.cnt = pMem->i;
 
692
        ctx.isStep = 0;
 
693
        ctx.isError = 0;
 
694
        (*pAgg->apFunc[i]->xFinalize)(&ctx);
 
695
        if( pMem->z!=0 && pMem->z!=pMem->zShort ){
 
696
          sqliteFree(pMem->z);
 
697
        }
 
698
        if( ctx.s.flags & MEM_Dyn ){
 
699
          sqliteFree(ctx.s.z);
 
700
        }
 
701
      }else if( pMem->flags & MEM_Dyn ){
 
702
        sqliteFree(pMem->z);
 
703
      }
 
704
    }
 
705
    sqliteFree(pElem);
 
706
  }
 
707
  sqliteHashClear(&pAgg->hash);
 
708
  sqliteFree(pAgg->apFunc);
 
709
  pAgg->apFunc = 0;
 
710
  pAgg->pCurrent = 0;
 
711
  pAgg->pSearch = 0;
 
712
  pAgg->nMem = 0;
 
713
}
 
714
 
 
715
/*
 
716
** Delete a keylist
 
717
*/
 
718
void sqliteVdbeKeylistFree(Keylist *p){
 
719
  while( p ){
 
720
    Keylist *pNext = p->pNext;
 
721
    sqliteFree(p);
 
722
    p = pNext;
 
723
  }
 
724
}
 
725
 
 
726
/*
 
727
** Close a cursor and release all the resources that cursor happens
 
728
** to hold.
 
729
*/
 
730
void sqliteVdbeCleanupCursor(Cursor *pCx){
 
731
  if( pCx->pCursor ){
 
732
    sqliteBtreeCloseCursor(pCx->pCursor);
 
733
  }
 
734
  if( pCx->pBt ){
 
735
    sqliteBtreeClose(pCx->pBt);
 
736
  }
 
737
  sqliteFree(pCx->pData);
 
738
  memset(pCx, 0, sizeof(Cursor));
 
739
}
 
740
 
 
741
/*
 
742
** Close all cursors
 
743
*/
 
744
static void closeAllCursors(Vdbe *p){
 
745
  int i;
 
746
  for(i=0; i<p->nCursor; i++){
 
747
    sqliteVdbeCleanupCursor(&p->aCsr[i]);
 
748
  }
 
749
  sqliteFree(p->aCsr);
 
750
  p->aCsr = 0;
 
751
  p->nCursor = 0;
 
752
}
 
753
 
 
754
/*
 
755
** Clean up the VM after execution.
 
756
**
 
757
** This routine will automatically close any cursors, lists, and/or
 
758
** sorters that were left open.  It also deletes the values of
 
759
** variables in the azVariable[] array.
 
760
*/
 
761
static void Cleanup(Vdbe *p){
 
762
  int i;
 
763
  if( p->aStack ){
 
764
    Mem *pTos = p->pTos;
 
765
    while( pTos>=p->aStack ){
 
766
      if( pTos->flags & MEM_Dyn ){
 
767
        sqliteFree(pTos->z);
 
768
      }
 
769
      pTos--;
 
770
    }
 
771
    p->pTos = pTos;
 
772
  }
 
773
  closeAllCursors(p);
 
774
  if( p->aMem ){
 
775
    for(i=0; i<p->nMem; i++){
 
776
      if( p->aMem[i].flags & MEM_Dyn ){
 
777
        sqliteFree(p->aMem[i].z);
 
778
      }
 
779
    }
 
780
  }
 
781
  sqliteFree(p->aMem);
 
782
  p->aMem = 0;
 
783
  p->nMem = 0;
 
784
  if( p->pList ){
 
785
    sqliteVdbeKeylistFree(p->pList);
 
786
    p->pList = 0;
 
787
  }
 
788
  sqliteVdbeSorterReset(p);
 
789
  if( p->pFile ){
 
790
    if( p->pFile!=stdin ) fclose(p->pFile);
 
791
    p->pFile = 0;
 
792
  }
 
793
  if( p->azField ){
 
794
    sqliteFree(p->azField);
 
795
    p->azField = 0;
 
796
  }
 
797
  p->nField = 0;
 
798
  if( p->zLine ){
 
799
    sqliteFree(p->zLine);
 
800
    p->zLine = 0;
 
801
  }
 
802
  p->nLineAlloc = 0;
 
803
  sqliteVdbeAggReset(&p->agg);
 
804
  if( p->aSet ){
 
805
    for(i=0; i<p->nSet; i++){
 
806
      sqliteHashClear(&p->aSet[i].hash);
 
807
    }
 
808
  }
 
809
  sqliteFree(p->aSet);
 
810
  p->aSet = 0;
 
811
  p->nSet = 0;
 
812
  if( p->keylistStack ){
 
813
    int ii;
 
814
    for(ii = 0; ii < p->keylistStackDepth; ii++){
 
815
      sqliteVdbeKeylistFree(p->keylistStack[ii]);
 
816
    }
 
817
    sqliteFree(p->keylistStack);
 
818
    p->keylistStackDepth = 0;
 
819
    p->keylistStack = 0;
 
820
  }
 
821
  sqliteFree(p->contextStack);
 
822
  p->contextStack = 0;
 
823
  sqliteFree(p->zErrMsg);
 
824
  p->zErrMsg = 0;
 
825
}
 
826
 
 
827
/*
 
828
** Clean up a VDBE after execution but do not delete the VDBE just yet.
 
829
** Write any error messages into *pzErrMsg.  Return the result code.
 
830
**
 
831
** After this routine is run, the VDBE should be ready to be executed
 
832
** again.
 
833
*/
 
834
int sqliteVdbeReset(Vdbe *p, char **pzErrMsg){
 
835
  sqlite *db = p->db;
 
836
  int i;
 
837
 
 
838
  if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){
 
839
    sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0);
 
840
    return SQLITE_MISUSE;
 
841
  }
 
842
  if( p->zErrMsg ){
 
843
    if( pzErrMsg && *pzErrMsg==0 ){
 
844
      *pzErrMsg = p->zErrMsg;
 
845
    }else{
 
846
      sqliteFree(p->zErrMsg);
 
847
    }
 
848
    p->zErrMsg = 0;
 
849
  }else if( p->rc ){
 
850
    sqliteSetString(pzErrMsg, sqlite_error_string(p->rc), (char*)0);
 
851
  }
 
852
  Cleanup(p);
 
853
  if( p->rc!=SQLITE_OK ){
 
854
    switch( p->errorAction ){
 
855
      case OE_Abort: {
 
856
        if( !p->undoTransOnError ){
 
857
          for(i=0; i<db->nDb; i++){
 
858
            if( db->aDb[i].pBt ){
 
859
              sqliteBtreeRollbackCkpt(db->aDb[i].pBt);
 
860
            }
 
861
          }
 
862
          break;
 
863
        }
 
864
        /* Fall through to ROLLBACK */
 
865
      }
 
866
      case OE_Rollback: {
 
867
        sqliteRollbackAll(db);
 
868
        db->flags &= ~SQLITE_InTrans;
 
869
        db->onError = OE_Default;
 
870
        break;
 
871
      }
 
872
      default: {
 
873
        if( p->undoTransOnError ){
 
874
          sqliteRollbackAll(db);
 
875
          db->flags &= ~SQLITE_InTrans;
 
876
          db->onError = OE_Default;
 
877
        }
 
878
        break;
 
879
      }
 
880
    }
 
881
    sqliteRollbackInternalChanges(db);
 
882
  }
 
883
  for(i=0; i<db->nDb; i++){
 
884
    if( db->aDb[i].pBt && db->aDb[i].inTrans==2 ){
 
885
      sqliteBtreeCommitCkpt(db->aDb[i].pBt);
 
886
      db->aDb[i].inTrans = 1;
 
887
    }
 
888
  }
 
889
  assert( p->pTos<&p->aStack[p->pc] || sqlite_malloc_failed==1 );
 
890
#ifdef VDBE_PROFILE
 
891
  {
 
892
    FILE *out = fopen("vdbe_profile.out", "a");
 
893
    if( out ){
 
894
      int i;
 
895
      fprintf(out, "---- ");
 
896
      for(i=0; i<p->nOp; i++){
 
897
        fprintf(out, "%02x", p->aOp[i].opcode);
 
898
      }
 
899
      fprintf(out, "\n");
 
900
      for(i=0; i<p->nOp; i++){
 
901
        fprintf(out, "%6d %10lld %8lld ",
 
902
           p->aOp[i].cnt,
 
903
           p->aOp[i].cycles,
 
904
           p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
 
905
        );
 
906
        sqliteVdbePrintOp(out, i, &p->aOp[i]);
 
907
      }
 
908
      fclose(out);
 
909
    }
 
910
  }
 
911
#endif
 
912
  p->magic = VDBE_MAGIC_INIT;
 
913
  return p->rc;
 
914
}
 
915
 
 
916
/*
 
917
** Clean up and delete a VDBE after execution.  Return an integer which is
 
918
** the result code.  Write any error message text into *pzErrMsg.
 
919
*/
 
920
int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){
 
921
  int rc;
 
922
  sqlite *db;
 
923
 
 
924
  if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){
 
925
    sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0);
 
926
    return SQLITE_MISUSE;
 
927
  }
 
928
  db = p->db;
 
929
  rc = sqliteVdbeReset(p, pzErrMsg);
 
930
  sqliteVdbeDelete(p);
 
931
  if( db->want_to_close && db->pVdbe==0 ){
 
932
    sqlite_close(db);
 
933
  }
 
934
  if( rc==SQLITE_SCHEMA ){
 
935
    sqliteResetInternalSchema(db, 0);
 
936
  }
 
937
  return rc;
 
938
}
 
939
 
 
940
/*
 
941
** Set the values of all variables.  Variable $1 in the original SQL will
 
942
** be the string azValue[0].  $2 will have the value azValue[1].  And
 
943
** so forth.  If a value is out of range (for example $3 when nValue==2)
 
944
** then its value will be NULL.
 
945
**
 
946
** This routine overrides any prior call.
 
947
*/
 
948
int sqlite_bind(sqlite_vm *pVm, int i, const char *zVal, int len, int copy){
 
949
  Vdbe *p = (Vdbe*)pVm;
 
950
  if( p->magic!=VDBE_MAGIC_RUN || p->pc!=0 ){
 
951
    return SQLITE_MISUSE;
 
952
  }
 
953
  if( i<1 || i>p->nVar ){
 
954
    return SQLITE_RANGE;
 
955
  }
 
956
  i--;
 
957
  if( p->abVar[i] ){
 
958
    sqliteFree(p->azVar[i]);
 
959
  }
 
960
  if( zVal==0 ){
 
961
    copy = 0;
 
962
    len = 0;
 
963
  }
 
964
  if( len<0 ){
 
965
    len = strlen(zVal)+1;
 
966
  }
 
967
  if( copy ){
 
968
    p->azVar[i] = sqliteMalloc( len );
 
969
    if( p->azVar[i] ) memcpy(p->azVar[i], zVal, len);
 
970
  }else{
 
971
    p->azVar[i] = (char*)zVal;
 
972
  }
 
973
  p->abVar[i] = copy;
 
974
  p->anVar[i] = len;
 
975
  return SQLITE_OK;
 
976
}
 
977
 
 
978
 
 
979
/*
 
980
** Delete an entire VDBE.
 
981
*/
 
982
void sqliteVdbeDelete(Vdbe *p){
 
983
  int i;
 
984
  if( p==0 ) return;
 
985
  Cleanup(p);
 
986
  if( p->pPrev ){
 
987
    p->pPrev->pNext = p->pNext;
 
988
  }else{
 
989
    assert( p->db->pVdbe==p );
 
990
    p->db->pVdbe = p->pNext;
 
991
  }
 
992
  if( p->pNext ){
 
993
    p->pNext->pPrev = p->pPrev;
 
994
  }
 
995
  p->pPrev = p->pNext = 0;
 
996
  if( p->nOpAlloc==0 ){
 
997
    p->aOp = 0;
 
998
    p->nOp = 0;
 
999
  }
 
1000
  for(i=0; i<p->nOp; i++){
 
1001
    if( p->aOp[i].p3type==P3_DYNAMIC ){
 
1002
      sqliteFree(p->aOp[i].p3);
 
1003
    }
 
1004
  }
 
1005
  for(i=0; i<p->nVar; i++){
 
1006
    if( p->abVar[i] ) sqliteFree(p->azVar[i]);
 
1007
  }
 
1008
  sqliteFree(p->aOp);
 
1009
  sqliteFree(p->aLabel);
 
1010
  sqliteFree(p->aStack);
 
1011
  p->magic = VDBE_MAGIC_DEAD;
 
1012
  sqliteFree(p);
 
1013
}
 
1014
 
 
1015
/*
 
1016
** Convert an integer in between the native integer format and
 
1017
** the bigEndian format used as the record number for tables.
 
1018
**
 
1019
** The bigEndian format (most significant byte first) is used for
 
1020
** record numbers so that records will sort into the correct order
 
1021
** even though memcmp() is used to compare the keys.  On machines
 
1022
** whose native integer format is little endian (ex: i486) the
 
1023
** order of bytes is reversed.  On native big-endian machines
 
1024
** (ex: Alpha, Sparc, Motorola) the byte order is the same.
 
1025
**
 
1026
** This function is its own inverse.  In other words
 
1027
**
 
1028
**         X == byteSwap(byteSwap(X))
 
1029
*/
 
1030
int sqliteVdbeByteSwap(int x){
 
1031
  union {
 
1032
     char zBuf[sizeof(int)];
 
1033
     int i;
 
1034
  } ux;
 
1035
  ux.zBuf[3] = x&0xff;
 
1036
  ux.zBuf[2] = (x>>8)&0xff;
 
1037
  ux.zBuf[1] = (x>>16)&0xff;
 
1038
  ux.zBuf[0] = (x>>24)&0xff;
 
1039
  return ux.i;
 
1040
}
 
1041
 
 
1042
/*
 
1043
** If a MoveTo operation is pending on the given cursor, then do that
 
1044
** MoveTo now.  Return an error code.  If no MoveTo is pending, this
 
1045
** routine does nothing and returns SQLITE_OK.
 
1046
*/
 
1047
int sqliteVdbeCursorMoveto(Cursor *p){
 
1048
  if( p->deferredMoveto ){
 
1049
    int res;
 
1050
    extern int sqlite_search_count;
 
1051
    sqliteBtreeMoveto(p->pCursor, (char*)&p->movetoTarget, sizeof(int), &res);
 
1052
    p->lastRecno = keyToInt(p->movetoTarget);
 
1053
    p->recnoIsValid = res==0;
 
1054
    if( res<0 ){
 
1055
      sqliteBtreeNext(p->pCursor, &res);
 
1056
    }
 
1057
    sqlite_search_count++;
 
1058
    p->deferredMoveto = 0;
 
1059
  }
 
1060
  return SQLITE_OK;
 
1061
}