sqlcipher/src/complete.c at Xcode5 · securitykernel/sqlcipher · GitHub

History

283 lines (275 loc) · 8.93 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

** 2001 September 15

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

*************************************************************************

** An tokenizer for SQL

** This file contains C code that implements the sqlite3_complete() API.

** This code used to be part of the tokenizer.c source file. But by

** separating it out, the code will be automatically omitted from

** static links that do not use it.

#include "sqliteInt.h"

#ifndef SQLITE_OMIT_COMPLETE

** This is defined in tokenize.c. We just have to import the definition.

#ifndef SQLITE_AMALGAMATION

#ifdef SQLITE_ASCII

#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)

#endif

#ifdef SQLITE_EBCDIC

extern const char sqlite3IsEbcdicIdChar[];

#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))

#endif

#endif /* SQLITE_AMALGAMATION */

** Token types used by the sqlite3_complete() routine. See the header

** comments on that procedure for additional information.

#define tkSEMI 0

#define tkWS 1

#define tkOTHER 2

#ifndef SQLITE_OMIT_TRIGGER

#define tkEXPLAIN 3

#define tkCREATE 4

#define tkTEMP 5

#define tkTRIGGER 6

#define tkEND 7

#endif

** Return TRUE if the given SQL string ends in a semicolon.

** Special handling is require for CREATE TRIGGER statements.

** Whenever the CREATE TRIGGER keywords are seen, the statement

** must end with ";END;".

** This implementation uses a state machine with 8 states:

** (0) INVALID We have not yet seen a non-whitespace character.

** (1) START At the beginning or end of an SQL statement. This routine

** returns 1 if it ends in the START state and 0 if it ends

** in any other state.

** (2) NORMAL We are in the middle of statement which ends with a single

** semicolon.

** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of

** a statement.

** (4) CREATE The keyword CREATE has been seen at the beginning of a

** statement, possibly preceeded by EXPLAIN and/or followed by

** TEMP or TEMPORARY

** (5) TRIGGER We are in the middle of a trigger definition that must be

** ended by a semicolon, the keyword END, and another semicolon.

** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at

** the end of a trigger definition.

** (7) END We've seen the ";END" of the ";END;" that occurs at the end

** of a trigger difinition.

** Transitions between states above are determined by tokens extracted

** from the input. The following tokens are significant:

** (0) tkSEMI A semicolon.

** (1) tkWS Whitespace.

** (2) tkOTHER Any other SQL token.

** (3) tkEXPLAIN The "explain" keyword.

** (4) tkCREATE The "create" keyword.

** (5) tkTEMP The "temp" or "temporary" keyword.

** (6) tkTRIGGER The "trigger" keyword.

** (7) tkEND The "end" keyword.

** Whitespace never causes a state transition and is always ignored.

** This means that a SQL string of all whitespace is invalid.

** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed

** to recognize the end of a trigger can be omitted. All we have to do

** is look for a semicolon that is not part of an string or comment.

int sqlite3_complete(const char *zSql){

u8 state = 0; /* Current state, using numbers defined in header comment */

u8 token; /* Value of the next token */

#ifndef SQLITE_OMIT_TRIGGER

/* A complex statement machine used to detect the end of a CREATE TRIGGER

** statement. This is the normal case.

static const u8 trans[8][8] = {

/* Token: */

/* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */

/* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, },

/* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, },

/* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, },

/* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, },

/* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, },

/* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, },

/* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, },

/* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, },

};

#else

/* If triggers are not supported by this compile then the statement machine

** used to detect the end of a statement is much simplier

static const u8 trans[3][3] = {

/* Token: */

/* State: ** SEMI WS OTHER */

/* 0 INVALID: */ { 1, 0, 2, },

/* 1 START: */ { 1, 1, 2, },

/* 2 NORMAL: */ { 1, 2, 2, },

};

#endif /* SQLITE_OMIT_TRIGGER */

while( *zSql ){

switch( *zSql ){

case ';': { /* A semicolon */

token = tkSEMI;

break;

}

case ' ':

case '\r':

case '\t':

case '\n':

case '\f': { /* White space is ignored */

token = tkWS;

break;

}

case '/': { /* C-style comments */

if( zSql[1]!='*' ){

token = tkOTHER;

break;

}

zSql += 2;

while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }

if( zSql[0]==0 ) return 0;

zSql++;

token = tkWS;

break;

}

case '-': { /* SQL-style comments from "--" to end of line */

if( zSql[1]!='-' ){

token = tkOTHER;

break;

}

while( *zSql && *zSql!='\n' ){ zSql++; }

if( *zSql==0 ) return state==1;

token = tkWS;

break;

}

case '[': { /* Microsoft-style identifiers in [...] */

zSql++;

while( *zSql && *zSql!=']' ){ zSql++; }

if( *zSql==0 ) return 0;

token = tkOTHER;

break;

}

case '`': /* Grave-accent quoted symbols used by MySQL */

case '"': /* single- and double-quoted strings */

case '\'': {

int c = *zSql;

zSql++;

while( *zSql && *zSql!=c ){ zSql++; }

if( *zSql==0 ) return 0;

token = tkOTHER;

break;

}

default: {

#ifdef SQLITE_EBCDIC

unsigned char c;

#endif

if( IdChar((u8)*zSql) ){

/* Keywords and unquoted identifiers */

int nId;

for(nId=1; IdChar(zSql[nId]); nId++){}

#ifdef SQLITE_OMIT_TRIGGER

token = tkOTHER;

#else

switch( *zSql ){

case 'c': case 'C': {

if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){

token = tkCREATE;

}else{

token = tkOTHER;

}

break;

}

case 't': case 'T': {

if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){

token = tkTRIGGER;

}else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){

token = tkTEMP;

}else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){

token = tkTEMP;

}else{

token = tkOTHER;

}

break;

}

case 'e': case 'E': {

if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){

token = tkEND;

}else

#ifndef SQLITE_OMIT_EXPLAIN

if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){

token = tkEXPLAIN;

}else

#endif

{

token = tkOTHER;

}

break;

}

default: {

token = tkOTHER;

break;

}

#endif /* SQLITE_OMIT_TRIGGER */

zSql += nId-1;

}else{

/* Operators and special symbols */

token = tkOTHER;

}

break;

}

state = trans[state][token];

zSql++;

}

return state==1;

}

#ifndef SQLITE_OMIT_UTF16

** This routine is the same as the sqlite3_complete() routine described

** above, except that the parameter is required to be UTF-16 encoded, not

** UTF-8.

int sqlite3_complete16(const void *zSql){

sqlite3_value *pVal;

char const *zSql8;

int rc = SQLITE_NOMEM;

#ifndef SQLITE_OMIT_AUTOINIT

rc = sqlite3_initialize();

if( rc ) return rc;

#endif

pVal = sqlite3ValueNew(0);

sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);

zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);

if( zSql8 ){

rc = sqlite3_complete(zSql8);

}else{

rc = SQLITE_NOMEM;

}

sqlite3ValueFree(pVal);

return sqlite3ApiExit(0, rc);

}

#endif /* SQLITE_OMIT_UTF16 */

#endif /* SQLITE_OMIT_COMPLETE */

sqlcipher/src/complete.c at Xcode5 · securitykernel/sqlcipher · GitHub

Expand file tree

Breadcrumbs

complete.c

Latest commit

History

Breadcrumbs

complete.c

File metadata and controls