Index: src/shell.c.in
==================================================================
--- src/shell.c.in
+++ src/shell.c.in
@@ -10615,59 +10615,111 @@
   }
   p->bSafeMode = p->bSafeModePersist;
   return rc;
 }
 
-/*
-** Return TRUE if a semicolon occurs anywhere in the first N characters
-** of string z[].
-*/
-static int line_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(z[0]) ) 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;
+/* Line scan result and intermediate states (supporting scan resumption)
+*/
+typedef enum {
+  QSS_HasDark = 1<<CHAR_BIT, QSS_EndingSemi = 2<<CHAR_BIT,
+  QSS_CharMask = (1<<CHAR_BIT)-1, QSS_ScanMask = 3<<CHAR_BIT,
+  QSS_Start = 0
+} QuickScanState;
+#define QSS_SETV(qss, newst) ((newst) | ((qss) & QSS_ScanMask))
+#define QSS_INPLAIN(qss) (((qss)&QSS_CharMask)==QSS_Start)
+#define QSS_PLAINWHITE(qss) (((qss)&~QSS_EndingSemi)==QSS_Start)
+#define QSS_PLAINDARK(qss) (((qss)&~QSS_EndingSemi)==QSS_HasDark)
+#define QSS_SEMITERM(qss) (((qss)&~QSS_HasDark)==QSS_EndingSemi)
+
+/*
+** Scan line for classification to guide shell's handling.
+** The scan is resumable for subsequent lines when prior
+** return values are passed as the 2nd argument.
+*/
+static QuickScanState quickscan(char *zLine, QuickScanState qss){
+  char cin;
+  char cWait = (char)qss; /* intentional narrowing loss */
+  if( cWait==0 ){
+  PlainScan:
+    while (cin = *zLine++){
+      if( IsSpace(cin) )
+        continue;
+      switch (cin){
+      case '-':
+        if( *zLine!='-' )
+          break;
+        while((cin = *++zLine)!=0 )
+          if( cin=='\n')
+            goto PlainScan;
+        return qss;
+      case ';':
+        qss |= QSS_EndingSemi;
+        continue;
+      case '/':
+        if( *zLine=='*' ){
+          ++zLine;
+          cWait = '*';
+          qss = QSS_SETV(qss, cWait);
+          goto TermScan;
+        }
+        break;
+      case '[':
+        cin = ']';
+        /* fall thru */
+      case '`': case '\'': case '"':
+        cWait = cin;
+        qss = QSS_HasDark | cWait;
+        goto TermScan;
+      default:
+        break;
+      }
+      qss = (qss & ~QSS_EndingSemi) | QSS_HasDark;
+    }
+  }else{
+  TermScan:
+    while (cin = *zLine++){
+      if( cin==cWait ){
+        switch( cWait ){
+        case '*':
+          if( *zLine != '/' )
+            continue;
+          ++zLine;
+          cWait = 0;
+          qss = QSS_SETV(qss, 0);
+          goto PlainScan;
+        case '`': case '\'': case '"':
+          if(*zLine==cWait){
+            ++zLine;
+            continue;
+          }
+          /* fall thru */
+        case ']':
+          cWait = 0;
+          qss = QSS_SETV(qss, 0);
+          goto PlainScan;
+        default: assert(0); 
+        }
+      }
+    }
+  }
+  return qss;
 }
 
 /*
 ** 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 line_is_command_terminator(const char *zLine){
+static int line_is_command_terminator(char *zLine){
   while( IsSpace(zLine[0]) ){ 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;
+  if( zLine[0]=='/' )
+    zLine += 1; /* Oracle */
+  else if ( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' )
+    zLine += 2; /* SQL Server */
+  else
+    return 0;
+  return quickscan(zLine,QSS_Start)==QSS_Start;
 }
 
 /*
 ** We need a default sqlite3_complete() implementation to use in case
 ** the shell is compiled with SQLITE_OMIT_COMPLETE.  The default assumes
@@ -10746,11 +10798,11 @@
   int nAlloc = 0;           /* Allocated zSql[] space */
   int nSqlPrior = 0;        /* Bytes of zSql[] used by prior line */
   int rc;                   /* Error code */
   int errCnt = 0;           /* Number of errors seen */
   int startline = 0;        /* Line number for start of current input */
-  int bAllWhite = 1;        /* Accumulated line empty or all whitespace */
+  QuickScanState qss = QSS_Start; /* Accumulated line status (so far) */
 
   p->lineno = 0;
   while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
     fflush(p->out);
     zLine = one_input_line(p->in, zLine, nSql>0);
@@ -10762,18 +10814,21 @@
     if( seenInterrupt ){
       if( p->in!=0 ) break;
       seenInterrupt = 0;
     }
     p->lineno++;
-    if( _all_whitespace(zLine) ){
-      if( nSql==0 ){
-        if( ShellHasFlag(p, SHFLG_Echo) )
-          printf("%s\n", zLine);
-        continue;
-      }
-    }else{
-      bAllWhite = 0;
+    if( QSS_INPLAIN(qss)
+        && line_is_command_terminator(zLine)
+        && line_is_complete(zSql, nSql) ){
+      memcpy(zLine,";",2);
+    }
+    qss = quickscan(zLine, qss);
+    if( QSS_PLAINWHITE(qss) && nSql==0 ){
+      if( ShellHasFlag(p, SHFLG_Echo) )
+        printf("%s\n", zLine);
+      /* Just swallow leading whitespace */
+      continue;
     }
     if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
       if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
       if( zLine[0]=='.' ){
         rc = do_meta_command(zLine, p);
@@ -10783,13 +10838,10 @@
           errCnt++;
         }
       }
       continue;
     }
-    if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
-      memcpy(zLine,";",2);
-    }
     nLine = strlen30(zLine);
     if( nSql+nLine+2>=nAlloc ){
       /* Grow buffer by half-again increments when big. */
       nAlloc = nSql+(nSql>>1)+nLine+100;
       zSql = realloc(zSql, nAlloc);
@@ -10806,27 +10858,26 @@
     }else{
       zSql[nSql++] = '\n';
       memcpy(zSql+nSql, zLine, nLine+1);
       nSql += nLine;
     }
-    if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
-                && sqlite3_complete(zSql) ){
+    if( nSql && QSS_SEMITERM(qss) && sqlite3_complete(zSql) ){
       errCnt += runOneSqlLine(p, zSql, p->in, startline);
       nSql = 0;
       if( p->outCount ){
         output_reset(p);
         p->outCount = 0;
       }else{
         clearTempFile(p);
       }
       p->bSafeMode = p->bSafeModePersist;
-    }else if( nSql && bAllWhite ){
+    }else if( nSql && QSS_PLAINWHITE(qss) ){
       if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
       nSql = 0;
     }
   }
-  if( nSql && !bAllWhite ){
+  if( nSql && QSS_PLAINDARK(qss) ){
     errCnt += runOneSqlLine(p, zSql, p->in, startline);
   }
   free(zSql);
   free(zLine);
   return errCnt>0;

Index: test/shell2.test
==================================================================
--- test/shell2.test
+++ test/shell2.test
@@ -41,14 +41,14 @@
 } {{0 {}} 1}
 
 # Shell silently ignores extra parameters.
 # Ticket [f5cb008a65].
 do_test shell2-1.2.1 {
-  set rc [catch { eval exec $CLI \":memory:\" \"select+3\" \"select+4\" } msg]
-  list $rc $msg
+  catchcmdex {:memory: "select+3" "select+4"}
 } {0 {3
-4}}
+4
+}}
 
 # Test a problem reported on the mailing list. The shell was at one point
 # returning the generic SQLITE_ERROR message ("SQL error or missing database")
 # instead of the "too many levels..." message in the test below.
 #
@@ -121,11 +121,11 @@
 # Test with echo on using dot command and 
 # multiple commands per line.
 # NB. whitespace is important
 do_test shell2-1.4.5 {
   forcedelete foo.db
-  catchcmd "foo.db" {.echo ON
+  catchcmdex "foo.db" {.echo ON
 CREATE TABLE foo1(a);
 INSERT INTO foo1(a) VALUES(1);
 CREATE TABLE foo2(b);
 INSERT INTO foo2(b) VALUES(1);
 SELECT * FROM foo1; SELECT * FROM foo2;
@@ -153,11 +153,11 @@
 # Test with echo on and headers on using dot command and 
 # multiple commands per line.
 # NB. whitespace is important
 do_test shell2-1.4.6 {
   forcedelete foo.db
-  catchcmd "foo.db" {.echo ON
+  catchcmdex "foo.db" {.echo ON
 .headers ON
 CREATE TABLE foo1(a);
 INSERT INTO foo1(a) VALUES(1);
 CREATE TABLE foo2(b);
 INSERT INTO foo2(b) VALUES(1);

Index: test/shell3.test
==================================================================
--- test/shell3.test
+++ test/shell3.test
@@ -16,17 +16,19 @@
 
 # Test plan:
 #
 #   shell3-1.*: Basic tests for running SQL statments from command line.
 #   shell3-2.*: Basic tests for running SQL file from command line.
+#   shell3-3.*: Basic tests for processing odd SQL constructs.
 #
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 set CLI [test_find_cli]
 db close
 forcedelete test.db test.db-journal test.db-wal
 sqlite3 db test.db
+
 
 # There are inconsistencies in command-line argument quoting on Windows.
 # In particular, individual applications are responsible for command-line
 # parsing in Windows, not the shell.  Depending on whether the sqlite3.exe
 # program is compiled with MinGW or MSVC, the command-line parsing is
@@ -96,6 +98,41 @@
 } {0 {}}
 do_test shell3-2.7 {
   catchcmd "foo.db" "CREATE TABLE"
 } {1 {Error: near line 1: incomplete input}}
 
+
+#----------------------------------------------------------------------------
+#   shell3-3.*: Basic tests for processing odd SQL constructs.
+#
+
+# Run combinations of odd identifiers, comments, semicolon placement
+do_test shell3-3.1 {
+  forcedelete foo.db
+  set rc [ catchcmd "foo.db" {CREATE TABLE t1("
+a--.
+" --x
+); CREATE TABLE t2("a[""b""]");
+.header on
+INSERT INTO t1 VALUES ('
+x''y');
+INSERT INTO t2 VALUES ('
+/*.
+.*/ x
+''y');
+SELECT * from t1 limit 1;
+SELECT * from t2 limit 1;
+} ]
+  set fexist [file exist foo.db]
+  list $rc $fexist
+} {{0 {
+a--.
+
+
+x'y
+a["b"]
+
+/*.
+.*/ x
+'y}} 1}
+
 finish_test