}else{      rc = 1;    }    sqlite3_free_table(azResult);  }else  if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){    open_db(p);    sqlite3_busy_timeout(p->db, atoi(azArg[1]));  }else  #if HAS_TIMER    if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg>1 ){    enableTimer = booleanValue(azArg[1]);  }else#endif  if( c=='w' && strncmp(azArg[0], "width", n)==0 ){    int j;    assert( nArg<=ArraySize(azArg) );    for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){      p->colWidth[j-1] = atoi(azArg[j]);    }  }else  {    fprintf(stderr, "unknown command or invalid arguments: "      " \"%s\". Enter \".help\" for help\n", azArg[0]);  }  return rc;}/*** Return TRUE if a semicolon occurs anywhere in the first N characters** of string z[].*/static int _contains_semicolon(const char *z, int N){  int i;  for(i=0; i<N; i++){  if( z[i]==';' ) return 1; }  return 0;}/*** Test to see if a line consists entirely of whitespace.*/static int _all_whitespace(const char *z){  for(; *z; z++){    if( isspace(*(unsigned char*)z) ) continue;    if( *z=='/' && z[1]=='*' ){      z += 2;      while( *z && (*z!='*' || z[1]!='/') ){ z++; }      if( *z==0 ) return 0;      z++;      continue;    }    if( *z=='-' && z[1]=='-' ){      z += 2;      while( *z && *z!='\n' ){ z++; }      if( *z==0 ) return 1;      continue;    }    return 0;  }  return 1;}/*** Return TRUE if the line typed in is an SQL command terminator other** than a semi-colon.  The SQL Server style "go" command is understood** as is the Oracle "/".*/static int _is_command_terminator(const char *zLine){  while( isspace(*(unsigned char*)zLine) ){ zLine++; };  if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1;  /* Oracle */  if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o'         && _all_whitespace(&zLine[2]) ){    return 1;  /* SQL Server */  }  return 0;}/*** Read input from *in and process it.  If *in==0 then input** is interactive - the user is typing it it.  Otherwise, input** is coming from a file or device.  A prompt is issued and history** is saved only if input is interactive.  An interrupt signal will** cause this routine to exit immediately, unless input is interactive.**** Return the number of errors.*/static int process_input(struct callback_data *p, FILE *in){  char *zLine = 0;  char *zSql = 0;  int nSql = 0;  int nSqlPrior = 0;  char *zErrMsg;  int rc;  int errCnt = 0;  int lineno = 0;  int startline = 0;  while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){    fflush(p->out);    free(zLine);    zLine = one_input_line(zSql, in);    if( zLine==0 ){      break;  /* We have reached EOF */    }    if( seenInterrupt ){      if( in!=0 ) break;      seenInterrupt = 0;    }    lineno++;    if( p->echoOn ) printf("%s\n", zLine);    if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;    if( zLine && zLine[0]=='.' && nSql==0 ){      rc = do_meta_command(zLine, p);      if( rc==2 ){        break;      }else if( rc ){        errCnt++;      }      continue;    }    if( _is_command_terminator(zLine) ){      memcpy(zLine,";",2);    }    nSqlPrior = nSql;    if( zSql==0 ){      int i;      for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}      if( zLine[i]!=0 ){        nSql = strlen(zLine);        zSql = malloc( nSql+1 );        if( zSql==0 ){          fprintf(stderr, "out of memory\n");          exit(1);        }        memcpy(zSql, zLine, nSql+1);        startline = lineno;      }    }else{      int len = strlen(zLine);      zSql = realloc( zSql, nSql + len + 2 );      if( zSql==0 ){        fprintf(stderr,"%s: out of memory!\n", Argv0);        exit(1);      }      zSql[nSql++] = '\n';      memcpy(&zSql[nSql], zLine, len+1);      nSql += len;    }    if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)                && sqlite3_complete(zSql) ){      p->cnt = 0;      open_db(p);      BEGIN_TIMER;      rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg);      END_TIMER;      if( rc || zErrMsg ){        char zPrefix[100];        if( in!=0 || !stdin_is_interactive ){          sqlite3_snprintf(sizeof(zPrefix), zPrefix,                            "SQL error near line %d:", startline);        }else{          sqlite3_snprintf(sizeof(zPrefix), zPrefix, "SQL error:");        }        if( zErrMsg!=0 ){          printf("%s %s\n", zPrefix, zErrMsg);          sqlite3_free(zErrMsg);          zErrMsg = 0;        }else{          printf("%s %s\n", zPrefix, sqlite3_errmsg(p->db));        }        errCnt++;      }      free(zSql);      zSql = 0;      nSql = 0;    }  }  if( zSql ){    if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql);    free(zSql);  }  free(zLine);  return errCnt;}/*** Return a pathname which is the user's home directory.  A** 0 return indicates an error of some kind.  Space to hold the** resulting string is obtained from malloc().  The calling** function should free the result.*/static char *find_home_dir(void){  char *home_dir = NULL;#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE)  struct passwd *pwent;  uid_t uid = getuid();  if( (pwent=getpwuid(uid)) != NULL) {    home_dir = pwent->pw_dir;  }#endif#if defined(_WIN32_WCE)  /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()   */  home_dir = strdup("/");#else#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)  if (!home_dir) {    home_dir = getenv("USERPROFILE");  }#endif  if (!home_dir) {    home_dir = getenv("HOME");  }#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)  if (!home_dir) {    char *zDrive, *zPath;    int n;    zDrive = getenv("HOMEDRIVE");    zPath = getenv("HOMEPATH");    if( zDrive && zPath ){      n = strlen(zDrive) + strlen(zPath) + 1;      home_dir = malloc( n );      if( home_dir==0 ) return 0;      sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);      return home_dir;    }    home_dir = "c:\\";  }#endif#endif /* !_WIN32_WCE */  if( home_dir ){    int n = strlen(home_dir) + 1;    char *z = malloc( n );    if( z ) memcpy(z, home_dir, n);    home_dir = z;  }  return home_dir;}/*** Read input from the file given by sqliterc_override.  Or if that** parameter is NULL, take input from ~/.sqliterc*/static void process_sqliterc(  struct callback_data *p,        /* Configuration data */  const char *sqliterc_override   /* Name of config file. NULL to use default */){  char *home_dir = NULL;  const char *sqliterc = sqliterc_override;  char *zBuf = 0;  FILE *in = NULL;  int nBuf;  if (sqliterc == NULL) {    home_dir = find_home_dir();    if( home_dir==0 ){      fprintf(stderr,"%s: cannot locate your home directory!\n", Argv0);      return;    }    nBuf = strlen(home_dir) + 16;    zBuf = malloc( nBuf );    if( zBuf==0 ){      fprintf(stderr,"%s: out of memory!\n", Argv0);      exit(1);    }    sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir);    free(home_dir);    sqliterc = (const char*)zBuf;  }  in = fopen(sqliterc,"rb");  if( in ){    if( stdin_is_interactive ){      printf("-- Loading resources from %s\n",sqliterc);    }    process_input(p,in);    fclose(in);  }  free(zBuf);  return;}/*** Show available command line options*/static const char zOptions[] =   "   -init filename       read/process named file\n"  "   -echo                print commands before execution\n"  "   -[no]header          turn headers on or off\n"  "   -bail                stop after hitting an error\n"  "   -interactive         force interactive I/O\n"  "   -batch               force batch I/O\n"  "   -column              set output mode to 'column'\n"  "   -csv                 set output mode to 'csv'\n"  "   -html                set output mode to HTML\n"  "   -line                set output mode to 'line'\n"  "   -list                set output mode to 'list'\n"  "   -separator 'x'       set output field separator (|)\n"  "   -nullvalue 'text'    set text string for NULL values\n"  "   -version             show SQLite version\n";static void usage(int showDetail){  fprintf(stderr,      "Usage: %s [OPTIONS] FILENAME [SQL]\n"        "FILENAME is the name of an SQLite database. A new database is created\n"      "if the file does not previously exist.\n", Argv0);  if( showDetail ){    fprintf(stderr, "OPTIONS include:\n%s", zOptions);  }else{    fprintf(stderr, "Use the -help option for additional information\n");  }  exit(1);}/*** Initialize the state information in data*/static void main_init(struct callback_data *data) {  memset(data, 0, sizeof(*data));  data->mode = MODE_List;  memcpy(data->separator,"|", 2);  data->showHeader = 0;  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");  sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");}int main(int argc, char **argv){  char *zErrMsg = 0;  struct callback_data data;  const char *zInitFile = 0;  char *zFirstCmd = 0;  int i;  int rc = 0;  Argv0 = argv[0];  main_init(&data);  stdin_is_interactive = isatty(0);  /* Make sure we have a valid signal handler early, before anything  ** else is done.  */#ifdef SIGINT  signal(SIGINT, interrupt_handler);#endif  /* Do an initial pass through the command-line argument to locate  ** the name of the database file, the name of the initialization file,  ** and the first command to execute.  */  for(i=1; i<argc-1; i++){    char *z;    if( argv[i][0]!='-' ) break;    z = argv[i];    if( z[0]=='-' && z[1]=='-' ) z++;    if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){      i++;    }else if( strcmp(argv[i],"-init")==0 ){      i++;      zInitFile = argv[i];    }  }  if( i<argc ){    data.zDbFilename = argv[i++];  }else{#ifndef SQLITE_OMIT_MEMORYDB    data.zDbFilename = ":memory:";#else    data.zDbFilename = 0;#endif  }  if( i<argc ){    zFirstCmd = argv[i++];  }  data.out = stdout;#ifdef SQLITE_OMIT_MEMORYDB  if( data.zDbFilename==0 ){    fprintf(stderr,"%s: no database filename specified\n", argv[0]);    exit(1);  }#endif  /* Go ahead and open the database file if it already exists.  If the  ** file does not exist, delay opening it.  This prevents empty database  ** files from being created if a user mistypes the database name argument  ** to the sqlite command-line tool.  */  if( access(data.zDbFilename, 0)==0 ){    open_db(&data);  }  /* Process the initialization file if there is one.  If no -init option  ** is given on the command line, look for a file named ~/.sqliterc and  ** try to process it.  */  process_sqliterc(&data,zInitFile);  /* Make a second pass through the command-line argument and set  ** options.  This second pass is delayed until after the initialization  ** file is processed so that the command-line arguments will override  ** settings in the initialization file.  */  for(i=1; i<argc && argv[i][0]=='-'; i++){    char *z = argv[i];    if( z[1]=='-' ){ z++; }    if( strcmp(z,"-init")==0 ){      i++;    }else if( strcmp(z,"-html")==0 ){      data.mode = MODE_Html;    }else if( strcmp(z,"-list")==0 ){      data.mode = MODE_List;    }else if( strcmp(z,"-line")==0 ){      data.mode = MODE_Line;    }else if( strcmp(z,"-column")==0 ){      data.mode = MODE_Column;    }else if( strcmp(z,"-csv")==0 ){      data.mode = MODE_Csv;      memcpy(data.separator,",",2);    }else if( strcmp(z,"-separator")==0 ){      i++;      sqlite3_snprintf(sizeof(data.separator), data.separator,                       "%.*s",(int)sizeof(data.separator)-1,argv[i]);    }else if( strcmp(z,"-nullvalue")==0 ){      i++;      sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,                       "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);    }else if( strcmp(z,"-header")==0 ){      data.showHeader = 1;    }else if( strcmp(z,"-noheader")==0 ){      data.showHeader = 0;    }else if( strcmp(z,"-echo")==0 ){      data.echoOn = 1;    }else if( strcmp(z,"-bail")==0 ){      bail_on_error = 1;    }else if( strcmp(z,"-version")==0 ){      printf("%s\n", sqlite3_libversion());      return 0;    }else if( strcmp(z,"-interactive")==0 ){      stdin_is_interactive = 1;    }else if( strcmp(z,"-batch")==0 ){      stdin_is_interactive = 0;    }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){      usage(1);    }else{      fprintf(stderr,"%s: unknown option: %s\n", Argv0, z);      fprintf(stderr,"Use -help for a list of options.\n");      return 1;    }  }  if( zFirstCmd ){    /* Run just the command that follows the database name    */    if( zFirstCmd[0]=='.' ){      do_meta_command(zFirstCmd, &data);      exit(0);    }else{      int rc;      open_db(&data);      rc = sqlite3_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);      if( rc!=0 && zErrMsg!=0 ){        fprintf(stderr,"SQL error: %s\n", zErrMsg);        exit(1);      }    }  }else{    /* Run commands received from standard input    */    if( stdin_is_interactive ){      char *zHome;      char *zHistory = 0;      int nHistory;      printf(        "SQLite version %s\n"        "Enter \".help\" for instructions\n",        sqlite3_libversion()      );      zHome = find_home_dir();      if( zHome && (zHistory = malloc(nHistory = strlen(zHome)+20))!=0 ){        sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);      }#if defined(HAVE_READLINE) && HAVE_READLINE==1      if( zHistory ) read_history(zHistory);#endif      rc = process_input(&data, 0);      if( zHistory ){        stifle_history(100);        write_history(zHistory);        free(zHistory);      }      free(zHome);    }else{      rc = process_input(&data, stdin);    }  }  set_table_name(&data, 0);  if( db ){    if( sqlite3_close(db)!=SQLITE_OK ){      fprintf(stderr,"error closing database: %s\n", sqlite3_errmsg(db));    }  }  return rc;}