SQLite

# A very fast test that checks basic sanity.  The name comes from
# the 60s-era electronics testing:  "Turn it on and see if smoke
# comes out."
#
smoketest:	$(TESTPROGS) fuzzcheck$(TEXE)
	./testfixture$(TEXE) $(TOP)/test/main.test $(TESTOPTS)

TESTRUNS_SHX = \
 $(TOP)/test/shell_x/shell9.test \
 $(TOP)/test/shell_x/shell10.test

shellxtest: $(TESTPROGS_SHX)
	./testfixture$(TEXE) $(TESTRUNS_SHX)

shelltest: $(TESTPROGS)
	./testfixture$(TEXE) $(TOP)/test/permutations.test shell

sqlite3_analyzer.c: sqlite3.c $(TOP)/src/tclsqlite.c $(TOP)/tool/spaceanal.tcl $(TOP)/tool/mkccode.tcl $(TOP)/tool/sqlite3_analyzer.c.in
	$(TCLSH_CMD) $(TOP)/tool/mkccode.tcl $(TOP)/tool/sqlite3_analyzer.c.in >sqlite3_analyzer.c

*/
#define NOT_IFDEF_BIT(x,bitnum) (x? (!(x & (1<<bitnum))) : !(x+0))

/* Whether build will include extended input parsing option */
#define SHEXT_PARSING_BIT 0
#define SHELL_EXTENDED_PARSING \
  NOT_IFDEF_BIT(SHELL_OMIT_EXTENSIONS, SHEXT_PARSING_BIT)
/* Whether build will include runtime extension via .shxload */
#define SHEXT_DYNEXT_BIT 1
#define SHELL_DYNAMIC_EXTENSION ( !SHELL_OMIT_LOAD_EXTENSION \
  && NOT_IFDEF_BIT(SHELL_OMIT_EXTENSIONS, SHEXT_DYNEXT_BIT) )
/* Whether build will include expansion of variables in dot-commands */
#define SHEXT_VAREXP_BIT 2
#define SHELL_VARIABLE_EXPANSION \
  NOT_IFDEF_BIT(SHELL_OMIT_EXTENSIONS, SHEXT_VAREXP_BIT)

      return DCR_Error;
    }else{
      sqlite3IoTrace = iotracePrintf;
    }
  }
  return DCR_Ok;
}

/*****************
 * The .limits and .load commands
 */
COLLECT_HELP_TEXT[
  ",limits ?LIMIT_NAME?     Display limit selected by its name, or all limits",
  ".load FILE ?ENTRY?       Load a SQLite extension library",
  "   If ENTRY is provided, the entry point \"sqlite_ENTRY_init\" is called.",
  "   Otherwise, the entry point name is derived from the FILE's name.",
];

DISPATCHABLE_COMMAND( limits 5 1 3 ){
  static const struct {
    const char *zLimitName;   /* Name of a limit */
    int limitCode;            /* Integer code for that limit */
  } aLimit[] = {
    { "length",                SQLITE_LIMIT_LENGTH                    },
    { "sql_length",            SQLITE_LIMIT_SQL_LENGTH                },

    }
  }else{
    *pzErr = smprintf("%s\n", sqlite3_errmsg(db));
  }

  return DCR_Ok|(rc!=0);
}

DISPATCHABLE_COMMAND( load ? 2 3 ){
  const char *zFile = 0, *zProc = 0;
  int ai = 1, rc;
  if( ISS(p)->bSafeMode ) return DCR_AbortError;
  while( ai<nArg ){
    const char *zA = azArg[ai++];
    if( zFile==0 ) zFile = zA;
    else if( zProc==0 ) zProc = zA;
    else return DCR_TooMany|ai;
  }
  open_db(p, 0);
  rc = sqlite3_load_extension(DBX(p), zFile, zProc, pzErr);
  return DCR_Ok|(rc!=SQLITE_OK);
}

DISPATCHABLE_COMMAND( log ? 2 2 ){
  const char *zFile = azArg[1];
  if( ISS(p)->bSafeMode ) return DCR_AbortError;
  output_file_close(ISS(p)->pLog);
  ISS(p)->pLog = output_file_open(zFile, 0);
  return DCR_Ok;

  }
  if( zColSep!=0 ){
    sqlite3_snprintf(sizeof(psi->colSeparator), psi->colSeparator, zColSep);
  }
  psi->mode = modeNominal;
}





























































/*****************
 * The .mode command
 */
COLLECT_HELP_TEXT[
  ".mode MODE ?OPTIONS?     Set output mode",
  "   MODE is one of:",
  "     ascii       Columns/rows delimited by 0x1F and 0x1E",

    shell_exec(p, zSql, 0);
  }
  sqlite3_free(zSql);
  return DCR_Ok;
}

/*****************
 * The .selftest*, .shell, and .show commands
 */
CONDITION_COMMAND( selftest_bool defined(SQLITE_DEBUG) );
CONDITION_COMMAND( selftest_int defined(SQLITE_DEBUG) );



COLLECT_HELP_TEXT[
  ",selftest ?OPTIONS?      Run tests defined in the SELFTEST table",
  "    Options:",
  "       --init               Create a new SELFTEST table",
  "       -v                   Verbose output",
  ",selftest_bool ?ARGS?    Show boolean values of ARGS as flag tokens",
  ",selftest_int ?ARGS?     Show integer values of ARGS as integer tokens",

  ".show                    Show the current values for various settings",








];

DISPATCHABLE_COMMAND( selftest_bool 10 0 0 ){
  int i, v;
  for(i=1; i<nArg; i++){
    v = booleanValue(azArg[i]);
    utf8_printf(ISS(p)->out, "%s: %d 0x%x\n", azArg[i], v, v);

    sqlite3_finalize(pStmt);
  } /* End loop over k */
  freeText(&str);
  utf8_printf(psi->out, "%d errors out of %d tests\n", nErr, nTest);
  return rc > 0;
}

/*****************
 * The .shell, .stats and .system commands
 */
CONDITION_COMMAND( shell !defined(SQLITE_NOHAVE_SYSTEM) );
CONDITION_COMMAND( system !defined(SQLITE_NOHAVE_SYSTEM) );
COLLECT_HELP_TEXT[
  ".shell CMD ARGS...       Run CMD ARGS... in a system shell",
  ".stats ?ARG?             Show stats or turn stats on or off",
  "   off                      Turn off automatic stat display",
  "   on                       Turn on automatic stat display",
  "   stmt                     Show statement stats",
  "   vmstep                   Show the virtual machine step count only",
  ".system CMD ARGS...      Run CMD ARGS... in a system shell",
];

#ifndef SQLITE_NOHAVE_SYSTEM
static DotCmdRC shellOut(char *azArg[], int nArg,
                         ShellExState *psx, char **pzErr){
  char *zCmd;
  int i, x;
  if( ISS(psx)->bSafeMode ) return DCR_AbortError;
  zCmd = smprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);

  for(i=2; i<nArg; i++){
    zCmd = smprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
                    zCmd, azArg[i]);

  }
  shell_check_oom(zCmd);
  x = system(zCmd);
  sqlite3_free(zCmd);
  if( x ) raw_printf(STD_ERR, "%s command returns %d\n", azArg[0], x);
  return DCR_Ok;
}
#endif
DISPATCHABLE_COMMAND( shell ? 2 0 ){
  return shellOut(azArg, nArg, p, pzErr);
}

DISPATCHABLE_COMMAND( system ? 2 0 ){
  return shellOut(azArg, nArg, p, pzErr);
}

/*****************
 * The .shxload and .shxopts commands
 */
CONDITION_COMMAND( shxload (SHELL_DYNAMIC_EXTENSION)!=0 );
CONDITION_COMMAND( shxopts (SHELL_EXTENSIONS)!=0 );
COLLECT_HELP_TEXT[
  ".shxload FILE ?OPTIONS?  Load a CLI shell extension library",
  "   The first option may name the init function to be called upon load.",
  "   Otherwise, its name is derived from FILE. Either way, the entry point"
  "   \"sqlite_NAME_init\" is called. All options after \"--\" are passed to",
  "   the extension's init function in the ShellExtensionLink struct.",
  ".shxopts ?SIGNED_OPTS?   Show or alter shell extension options",
  "   Run without arguments to see their self-descriptive names",
];

DISPATCHABLE_COMMAND( shxload 4 2 0 ){
  const char *zFile = 0, *zProc = 0;
  int ai = 1, rc;
  char **pzExtArgs = 0;
  if( ISS(p)->bSafeMode ) return DCR_AbortError;
  while( ai<nArg ){
    const char *zA = azArg[ai++];
    if( strcmp(zA, "--")==0 ){
      pzExtArgs = azArg + ai;
      break;
    }
    if( zFile==0 ) zFile = zA;
    else if( zProc==0 ) zProc = zA;
  }
  if( zFile==0 ) return DCR_Missing;
  if( pzExtArgs==0 ) pzExtArgs = azArg + ai;
  rc = load_shell_extension(p, zFile, zProc, pzErr, nArg-ai, pzExtArgs);
  return DCR_Ok|(rc!=SQLITE_OK);
}

DISPATCHABLE_COMMAND( shxopts 3 0 0 ){
  static struct { const char *name; u8 mask; } shopts[] = {
#if SHELL_DYNAMIC_COMMANDS
    {"dyn_cmds", 1<<SHEXT_DYNCMDS_BIT},
#endif
#if SHELL_EXTENDED_PARSING
    {"parsing", 1<<SHEXT_PARSING_BIT},

    }
  }
  return DCR_Ok;
 moan_error:
  raw_printf(STD_ERR, "Error: %s %s\n", zAbout, zMoan);
  return DCR_CmdErred;
}



DISPATCHABLE_COMMAND( show ? 1 1 ){
  static const char *azBool[] = { "off", "on", "trigger", "full"};
  const char *zOut;
  ShellInState *psi = ISS(p);
  FILE *out = psi->out;
  int i;
  utf8_printf(out, "%12.12s: %s\n","echo",

  enum {
    HO_Tbd, HO_AllP, HO_AllX, HO_LikeP, HO_OneX, HO_LikeT, HO_Undoc
  } hoKind = bShowUndoc? HO_Undoc : HO_Tbd;

  if( hoKind==HO_Undoc ){
    int ixct = 0;
    utf8_printf(out, "%s\n%s\n",
      "The following commands are for SQLite diagnosis and internal testing.",
      "They are undocumented and subject to change without notice.");
    /* Bypass command lookup/resolution. This is just for internal commands. */
    while( ixct<numCommands ){
      struct CommandInfo *pci = &command_table[ixct];
      const char *zH = pci->azHelp[0];
      if( zH && *zH==cLead ){
        utf8_printf(out, HELP_TEXT_FMTP, zH+1);
        zH = pci->azHelp[1];

  set rc [catch { exec $CLI :memory: << $cmd } msg]
  list $rc $msg
}

#----------------------------------------------------------------------------
# Test cases shell10-1.*: loading/running the {C,C++}-written test extensions
set cmds ".
 .shxload $blddir/test_shellext_cpp -- C++
 .tables
 .quit
"
do_test shell10-1.1 {
  catch_mdb_cmd $cmds
} {0 {BatBeing lives.
Load arguments: C++
dbUser appeared
dbUser closing
dbShell closing
BatBeing incommunicado.
BatBeing unbecoming.
BatBeing RIP.}}

set cmds ".
 .shxload $blddir/test_shellext_c -- C
 .bat 10 20 30
 .shxload $blddir/test_shellext_cpp -- C++
 .bat 10 20 30
 .tables
"
do_test shell10-1.2 {
  catch_mdb_cmd $cmds
} {0 {Load arguments: C
Column widths: 10 20 30
This execute has been called 1 times.
BatBeing lives.
Load arguments: C++
Column widths: 20 30 10
This execute has been called 2 times.
dbUser appeared
dbUser appeared
dbUser closing
dbUser closing
dbShell closing
dbShell closing
BatBeing incommunicado.
BatBeing incommunicado.
BatBeing unbecoming.
BatBeing unbecoming.
BatBeing RIP.}}


#----------------------------------------------------------------------------
# Test cases shell10-2.*: Tcl extension load and execution environment switching

set ldtce ".shxload $blddir/tclshext"

set cmds {
 ..
 puts Putsing
 for {set i 0} {$i<2} {incr i} {.print $i}
 puts [info commands ..]
 .