****     NNN days**     NNN hours**     NNN minutes**     NNN.NNNN seconds**     NNN months**     NNN years**     start of month**     start of year**     start of week**     start of day**     weekday N**     unixepoch**     localtime**     utc**** Return 0 on success and 1 if there is any kind of error.*/static int parseModifier(const char *zMod, DateTime *p){  int rc = 1;  int n;  double r;  char *z, zBuf[30];  z = zBuf;  for(n=0; n<sizeof(zBuf)-1 && zMod[n]; n++){    z[n] = tolower(zMod[n]);  }  z[n] = 0;  switch( z[0] ){    case 'l': {      /*    localtime      **      ** Assuming the current time value is UTC (a.k.a. GMT), shift it to      ** show local time.      */      if( strcmp(z, "localtime")==0 ){        computeJD(p);        p->rJD += localtimeOffset(p);        clearYMD_HMS_TZ(p);        rc = 0;      }      break;    }    case 'u': {      /*      **    unixepoch      **      ** Treat the current value of p->rJD as the number of      ** seconds since 1970.  Convert to a real julian day number.      */      if( strcmp(z, "unixepoch")==0 && p->validJD ){        p->rJD = p->rJD/86400.0 + 2440587.5;        clearYMD_HMS_TZ(p);        rc = 0;      }else if( strcmp(z, "utc")==0 ){        double c1;        computeJD(p);        c1 = localtimeOffset(p);        p->rJD -= c1;        clearYMD_HMS_TZ(p);        p->rJD += c1 - localtimeOffset(p);        rc = 0;      }      break;    }    case 'w': {      /*      **    weekday N      **      ** Move the date to the same time on the next occurrance of      ** weekday N where 0==Sunday, 1==Monday, and so forth.  If the      ** date is already on the appropriate weekday, this is a no-op.      */      if( strncmp(z, "weekday ", 8)==0 && getValue(&z[8],&r)>0                 && (n=r)==r && n>=0 && r<7 ){        int Z;        computeYMD_HMS(p);        p->validTZ = 0;        p->validJD = 0;        computeJD(p);        Z = p->rJD + 1.5;        Z %= 7;        if( Z>n ) Z -= 7;        p->rJD += n - Z;        clearYMD_HMS_TZ(p);        rc = 0;      }      break;    }    case 's': {      /*      **    start of TTTTT      **      ** Move the date backwards to the beginning of the current day,      ** or month or year.      */      if( strncmp(z, "start of ", 9)!=0 ) break;      z += 9;      computeYMD(p);      p->validHMS = 1;      p->h = p->m = 0;      p->s = 0.0;      p->validTZ = 0;      p->validJD = 0;      if( strcmp(z,"month")==0 ){        p->D = 1;        rc = 0;      }else if( strcmp(z,"year")==0 ){        computeYMD(p);        p->M = 1;        p->D = 1;        rc = 0;      }else if( strcmp(z,"day")==0 ){        rc = 0;      }      break;    }    case '+':    case '-':    case '0':    case '1':    case '2':    case '3':    case '4':    case '5':    case '6':    case '7':    case '8':    case '9': {      n = getValue(z, &r);      if( n<=0 ) break;      if( z[n]==':' ){        /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the        ** specified number of hours, minutes, seconds, and fractional seconds        ** to the time.  The ".FFF" may be omitted.  The ":SS.FFF" may be        ** omitted.        */        const char *z2 = z;        DateTime tx;        int day;        if( !isdigit(*z2) ) z2++;        memset(&tx, 0, sizeof(tx));        if( parseHhMmSs(z2, &tx) ) break;        computeJD(&tx);        tx.rJD -= 0.5;        day = (int)tx.rJD;        tx.rJD -= day;        if( z[0]=='-' ) tx.rJD = -tx.rJD;        computeJD(p);        clearYMD_HMS_TZ(p);       p->rJD += tx.rJD;        rc = 0;        break;      }      z += n;      while( isspace(z[0]) ) z++;      n = strlen(z);      if( n>10 || n<3 ) break;      if( z[n-1]=='s' ){ z[n-1] = 0; n--; }      computeJD(p);      rc = 0;      if( n==3 && strcmp(z,"day")==0 ){        p->rJD += r;      }else if( n==4 && strcmp(z,"hour")==0 ){        p->rJD += r/24.0;      }else if( n==6 && strcmp(z,"minute")==0 ){        p->rJD += r/(24.0*60.0);      }else if( n==6 && strcmp(z,"second")==0 ){        p->rJD += r/(24.0*60.0*60.0);      }else if( n==5 && strcmp(z,"month")==0 ){        int x, y;        computeYMD_HMS(p);        p->M += r;        x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;        p->Y += x;        p->M -= x*12;        p->validJD = 0;        computeJD(p);        y = r;        if( y!=r ){          p->rJD += (r - y)*30.0;        }      }else if( n==4 && strcmp(z,"year")==0 ){        computeYMD_HMS(p);        p->Y += r;        p->validJD = 0;        computeJD(p);      }else{        rc = 1;      }      clearYMD_HMS_TZ(p);      break;    }    default: {      break;    }  }  return rc;}/*** Process time function arguments.  argv[0] is a date-time stamp.** argv[1] and following are modifiers.  Parse them all and write** the resulting time into the DateTime structure p.  Return 0** on success and 1 if there are any errors.*/static int isDate(int argc, const char **argv, DateTime *p){  int i;  if( argc==0 ) return 1;  if( argv[0]==0 || parseDateOrTime(argv[0], p) ) return 1;  for(i=1; i<argc; i++){    if( argv[i]==0 || parseModifier(argv[i], p) ) return 1;  }  return 0;}/*** The following routines implement the various date and time functions** of SQLite.*//***    julianday( TIMESTRING, MOD, MOD, ...)**** Return the julian day number of the date specified in the arguments*/static void juliandayFunc(sqlite_func *context, int argc, const char **argv){  DateTime x;  if( isDate(argc, argv, &x)==0 ){    computeJD(&x);    sqlite_set_result_double(context, x.rJD);  }}/***    datetime( TIMESTRING, MOD, MOD, ...)**** Return YYYY-MM-DD HH:MM:SS*/static void datetimeFunc(sqlite_func *context, int argc, const char **argv){  DateTime x;  if( isDate(argc, argv, &x)==0 ){    char zBuf[100];    computeYMD_HMS(&x);    sprintf(zBuf, "%04d-%02d-%02d %02d:%02d:%02d",x.Y, x.M, x.D, x.h, x.m,           (int)(x.s));    sqlite_set_result_string(context, zBuf, -1);  }}/***    time( TIMESTRING, MOD, MOD, ...)**** Return HH:MM:SS*/static void timeFunc(sqlite_func *context, int argc, const char **argv){  DateTime x;  if( isDate(argc, argv, &x)==0 ){    char zBuf[100];    computeHMS(&x);    sprintf(zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);    sqlite_set_result_string(context, zBuf, -1);  }}/***    date( TIMESTRING, MOD, MOD, ...)**** Return YYYY-MM-DD*/static void dateFunc(sqlite_func *context, int argc, const char **argv){  DateTime x;  if( isDate(argc, argv, &x)==0 ){    char zBuf[100];    computeYMD(&x);    sprintf(zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);    sqlite_set_result_string(context, zBuf, -1);  }}/***    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)**** Return a string described by FORMAT.  Conversions as follows:****   %d  day of month**   %f  ** fractional seconds  SS.SSS**   %H  hour 00-24**   %j  day of year 000-366**   %J  ** Julian day number**   %m  month 01-12**   %M  minute 00-59**   %s  seconds since 1970-01-01**   %S  seconds 00-59**   %w  day of week 0-6  sunday==0**   %W  week of year 00-53**   %Y  year 0000-9999**   %%  %*/static void strftimeFunc(sqlite_func *context, int argc, const char **argv){  DateTime x;  int n, i, j;  char *z;  const char *zFmt = argv[0];  char zBuf[100];  if( argv[0]==0 || isDate(argc-1, argv+1, &x) ) return;  for(i=0, n=1; zFmt[i]; i++, n++){    if( zFmt[i]=='%' ){      switch( zFmt[i+1] ){        case 'd':        case 'H':        case 'm':        case 'M':        case 'S':        case 'W':          n++;          /* fall thru */        case 'w':        case '%':          break;        case 'f':          n += 8;          break;        case 'j':          n += 3;          break;        case 'Y':          n += 8;          break;        case 's':        case 'J':          n += 50;          break;        default:          return;  /* ERROR.  return a NULL */      }      i++;    }  }  if( n<sizeof(zBuf) ){    z = zBuf;  }else{    z = sqliteMalloc( n );    if( z==0 ) return;  }  computeJD(&x);  computeYMD_HMS(&x);  for(i=j=0; zFmt[i]; i++){    if( zFmt[i]!='%' ){      z[j++] = zFmt[i];    }else{      i++;      switch( zFmt[i] ){        case 'd':  sprintf(&z[j],"%02d",x.D); j+=2; break;        case 'f': {          int s = x.s;          int ms = (x.s - s)*1000.0;          sprintf(&z[j],"%02d.%03d",s,ms);          j += strlen(&z[j]);          break;        }        case 'H':  sprintf(&z[j],"%02d",x.h); j+=2; break;        case 'W': /* Fall thru */        case 'j': {          int n;          DateTime y = x;          y.validJD = 0;          y.M = 1;          y.D = 1;          computeJD(&y);          n = x.rJD - y.rJD + 1;          if( zFmt[i]=='W' ){            sprintf(&z[j],"%02d",(n+6)/7);            j += 2;          }else{            sprintf(&z[j],"%03d",n);            j += 3;          }          break;        }        case 'J':  sprintf(&z[j],"%.16g",x.rJD); j+=strlen(&z[j]); break;        case 'm':  sprintf(&z[j],"%02d",x.M); j+=2; break;        case 'M':  sprintf(&z[j],"%02d",x.m); j+=2; break;        case 's': {          sprintf(&z[j],"%d",(int)((x.rJD-2440587.5)*86400.0 + 0.5));          j += strlen(&z[j]);          break;        }        case 'S':  sprintf(&z[j],"%02d",(int)(x.s+0.5)); j+=2; break;        case 'w':  z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break;        case 'Y':  sprintf(&z[j],"%04d",x.Y); j+=strlen(&z[j]); break;        case '%':  z[j++] = '%'; break;      }    }  }  z[j] = 0;  sqlite_set_result_string(context, z, -1);  if( z!=zBuf ){    sqliteFree(z);  }}#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) *//*** This function registered all of the above C functions as SQL** functions.  This should be the only routine in this file with** external linkage.*/void sqliteRegisterDateTimeFunctions(sqlite *db){  static struct {     char *zName;     int nArg;     int dataType;     void (*xFunc)(sqlite_func*,int,const char**);  } aFuncs[] = {#ifndef SQLITE_OMIT_DATETIME_FUNCS    { "julianday", -1, SQLITE_NUMERIC, juliandayFunc   },    { "date",      -1, SQLITE_TEXT,    dateFunc        },    { "time",      -1, SQLITE_TEXT,    timeFunc        },    { "datetime",  -1, SQLITE_TEXT,    datetimeFunc    },    { "strftime",  -1, SQLITE_TEXT,    strftimeFunc    },#endif  };  int i;  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){    sqlite_create_function(db, aFuncs[i].zName,           aFuncs[i].nArg, aFuncs[i].xFunc, 0);    if( aFuncs[i].xFunc ){      sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);    }  }}