Annotation of embedaddon/sqlite3/src/test_hexio.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2007 April 6
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: ** Code for testing all sorts of SQLite interfaces. This code
! 13: ** implements TCL commands for reading and writing the binary
! 14: ** database files and displaying the content of those files as
! 15: ** hexadecimal. We could, in theory, use the built-in "binary"
! 16: ** command of TCL to do a lot of this, but there are some issues
! 17: ** with historical versions of the "binary" command. So it seems
! 18: ** easier and safer to build our own mechanism.
! 19: */
! 20: #include "sqliteInt.h"
! 21: #include "tcl.h"
! 22: #include <stdlib.h>
! 23: #include <string.h>
! 24: #include <assert.h>
! 25:
! 26:
! 27: /*
! 28: ** Convert binary to hex. The input zBuf[] contains N bytes of
! 29: ** binary data. zBuf[] is 2*n+1 bytes long. Overwrite zBuf[]
! 30: ** with a hexadecimal representation of its original binary input.
! 31: */
! 32: void sqlite3TestBinToHex(unsigned char *zBuf, int N){
! 33: const unsigned char zHex[] = "0123456789ABCDEF";
! 34: int i, j;
! 35: unsigned char c;
! 36: i = N*2;
! 37: zBuf[i--] = 0;
! 38: for(j=N-1; j>=0; j--){
! 39: c = zBuf[j];
! 40: zBuf[i--] = zHex[c&0xf];
! 41: zBuf[i--] = zHex[c>>4];
! 42: }
! 43: assert( i==-1 );
! 44: }
! 45:
! 46: /*
! 47: ** Convert hex to binary. The input zIn[] contains N bytes of
! 48: ** hexadecimal. Convert this into binary and write aOut[] with
! 49: ** the binary data. Spaces in the original input are ignored.
! 50: ** Return the number of bytes of binary rendered.
! 51: */
! 52: int sqlite3TestHexToBin(const unsigned char *zIn, int N, unsigned char *aOut){
! 53: const unsigned char aMap[] = {
! 54: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 55: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 56: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 57: 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 0, 0, 0, 0, 0, 0,
! 58: 0,11,12,13,14,15,16, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 59: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 60: 0,11,12,13,14,15,16, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 61: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 62: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 63: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 64: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 65: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 66: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 67: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 68: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 69: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 70: };
! 71: int i, j;
! 72: int hi=1;
! 73: unsigned char c;
! 74:
! 75: for(i=j=0; i<N; i++){
! 76: c = aMap[zIn[i]];
! 77: if( c==0 ) continue;
! 78: if( hi ){
! 79: aOut[j] = (c-1)<<4;
! 80: hi = 0;
! 81: }else{
! 82: aOut[j++] |= c-1;
! 83: hi = 1;
! 84: }
! 85: }
! 86: return j;
! 87: }
! 88:
! 89:
! 90: /*
! 91: ** Usage: hexio_read FILENAME OFFSET AMT
! 92: **
! 93: ** Read AMT bytes from file FILENAME beginning at OFFSET from the
! 94: ** beginning of the file. Convert that information to hexadecimal
! 95: ** and return the resulting HEX string.
! 96: */
! 97: static int hexio_read(
! 98: void * clientData,
! 99: Tcl_Interp *interp,
! 100: int objc,
! 101: Tcl_Obj *CONST objv[]
! 102: ){
! 103: int offset;
! 104: int amt, got;
! 105: const char *zFile;
! 106: unsigned char *zBuf;
! 107: FILE *in;
! 108:
! 109: if( objc!=4 ){
! 110: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME OFFSET AMT");
! 111: return TCL_ERROR;
! 112: }
! 113: if( Tcl_GetIntFromObj(interp, objv[2], &offset) ) return TCL_ERROR;
! 114: if( Tcl_GetIntFromObj(interp, objv[3], &amt) ) return TCL_ERROR;
! 115: zFile = Tcl_GetString(objv[1]);
! 116: zBuf = sqlite3_malloc( amt*2+1 );
! 117: if( zBuf==0 ){
! 118: return TCL_ERROR;
! 119: }
! 120: in = fopen(zFile, "rb");
! 121: if( in==0 ){
! 122: in = fopen(zFile, "r");
! 123: }
! 124: if( in==0 ){
! 125: Tcl_AppendResult(interp, "cannot open input file ", zFile, 0);
! 126: return TCL_ERROR;
! 127: }
! 128: fseek(in, offset, SEEK_SET);
! 129: got = fread(zBuf, 1, amt, in);
! 130: fclose(in);
! 131: if( got<0 ){
! 132: got = 0;
! 133: }
! 134: sqlite3TestBinToHex(zBuf, got);
! 135: Tcl_AppendResult(interp, zBuf, 0);
! 136: sqlite3_free(zBuf);
! 137: return TCL_OK;
! 138: }
! 139:
! 140:
! 141: /*
! 142: ** Usage: hexio_write FILENAME OFFSET DATA
! 143: **
! 144: ** Write DATA into file FILENAME beginning at OFFSET from the
! 145: ** beginning of the file. DATA is expressed in hexadecimal.
! 146: */
! 147: static int hexio_write(
! 148: void * clientData,
! 149: Tcl_Interp *interp,
! 150: int objc,
! 151: Tcl_Obj *CONST objv[]
! 152: ){
! 153: int offset;
! 154: int nIn, nOut, written;
! 155: const char *zFile;
! 156: const unsigned char *zIn;
! 157: unsigned char *aOut;
! 158: FILE *out;
! 159:
! 160: if( objc!=4 ){
! 161: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME OFFSET HEXDATA");
! 162: return TCL_ERROR;
! 163: }
! 164: if( Tcl_GetIntFromObj(interp, objv[2], &offset) ) return TCL_ERROR;
! 165: zFile = Tcl_GetString(objv[1]);
! 166: zIn = (const unsigned char *)Tcl_GetStringFromObj(objv[3], &nIn);
! 167: aOut = sqlite3_malloc( nIn/2 );
! 168: if( aOut==0 ){
! 169: return TCL_ERROR;
! 170: }
! 171: nOut = sqlite3TestHexToBin(zIn, nIn, aOut);
! 172: out = fopen(zFile, "r+b");
! 173: if( out==0 ){
! 174: out = fopen(zFile, "r+");
! 175: }
! 176: if( out==0 ){
! 177: Tcl_AppendResult(interp, "cannot open output file ", zFile, 0);
! 178: return TCL_ERROR;
! 179: }
! 180: fseek(out, offset, SEEK_SET);
! 181: written = fwrite(aOut, 1, nOut, out);
! 182: sqlite3_free(aOut);
! 183: fclose(out);
! 184: Tcl_SetObjResult(interp, Tcl_NewIntObj(written));
! 185: return TCL_OK;
! 186: }
! 187:
! 188: /*
! 189: ** USAGE: hexio_get_int HEXDATA
! 190: **
! 191: ** Interpret the HEXDATA argument as a big-endian integer. Return
! 192: ** the value of that integer. HEXDATA can contain between 2 and 8
! 193: ** hexadecimal digits.
! 194: */
! 195: static int hexio_get_int(
! 196: void * clientData,
! 197: Tcl_Interp *interp,
! 198: int objc,
! 199: Tcl_Obj *CONST objv[]
! 200: ){
! 201: int val;
! 202: int nIn, nOut;
! 203: const unsigned char *zIn;
! 204: unsigned char *aOut;
! 205: unsigned char aNum[4];
! 206:
! 207: if( objc!=2 ){
! 208: Tcl_WrongNumArgs(interp, 1, objv, "HEXDATA");
! 209: return TCL_ERROR;
! 210: }
! 211: zIn = (const unsigned char *)Tcl_GetStringFromObj(objv[1], &nIn);
! 212: aOut = sqlite3_malloc( nIn/2 );
! 213: if( aOut==0 ){
! 214: return TCL_ERROR;
! 215: }
! 216: nOut = sqlite3TestHexToBin(zIn, nIn, aOut);
! 217: if( nOut>=4 ){
! 218: memcpy(aNum, aOut, 4);
! 219: }else{
! 220: memset(aNum, 0, sizeof(aNum));
! 221: memcpy(&aNum[4-nOut], aOut, nOut);
! 222: }
! 223: sqlite3_free(aOut);
! 224: val = (aNum[0]<<24) | (aNum[1]<<16) | (aNum[2]<<8) | aNum[3];
! 225: Tcl_SetObjResult(interp, Tcl_NewIntObj(val));
! 226: return TCL_OK;
! 227: }
! 228:
! 229:
! 230: /*
! 231: ** USAGE: hexio_render_int16 INTEGER
! 232: **
! 233: ** Render INTEGER has a 16-bit big-endian integer in hexadecimal.
! 234: */
! 235: static int hexio_render_int16(
! 236: void * clientData,
! 237: Tcl_Interp *interp,
! 238: int objc,
! 239: Tcl_Obj *CONST objv[]
! 240: ){
! 241: int val;
! 242: unsigned char aNum[10];
! 243:
! 244: if( objc!=2 ){
! 245: Tcl_WrongNumArgs(interp, 1, objv, "INTEGER");
! 246: return TCL_ERROR;
! 247: }
! 248: if( Tcl_GetIntFromObj(interp, objv[1], &val) ) return TCL_ERROR;
! 249: aNum[0] = val>>8;
! 250: aNum[1] = val;
! 251: sqlite3TestBinToHex(aNum, 2);
! 252: Tcl_SetObjResult(interp, Tcl_NewStringObj((char*)aNum, 4));
! 253: return TCL_OK;
! 254: }
! 255:
! 256:
! 257: /*
! 258: ** USAGE: hexio_render_int32 INTEGER
! 259: **
! 260: ** Render INTEGER has a 32-bit big-endian integer in hexadecimal.
! 261: */
! 262: static int hexio_render_int32(
! 263: void * clientData,
! 264: Tcl_Interp *interp,
! 265: int objc,
! 266: Tcl_Obj *CONST objv[]
! 267: ){
! 268: int val;
! 269: unsigned char aNum[10];
! 270:
! 271: if( objc!=2 ){
! 272: Tcl_WrongNumArgs(interp, 1, objv, "INTEGER");
! 273: return TCL_ERROR;
! 274: }
! 275: if( Tcl_GetIntFromObj(interp, objv[1], &val) ) return TCL_ERROR;
! 276: aNum[0] = val>>24;
! 277: aNum[1] = val>>16;
! 278: aNum[2] = val>>8;
! 279: aNum[3] = val;
! 280: sqlite3TestBinToHex(aNum, 4);
! 281: Tcl_SetObjResult(interp, Tcl_NewStringObj((char*)aNum, 8));
! 282: return TCL_OK;
! 283: }
! 284:
! 285: /*
! 286: ** USAGE: utf8_to_utf8 HEX
! 287: **
! 288: ** The argument is a UTF8 string represented in hexadecimal.
! 289: ** The UTF8 might not be well-formed. Run this string through
! 290: ** sqlite3Utf8to8() convert it back to hex and return the result.
! 291: */
! 292: static int utf8_to_utf8(
! 293: void * clientData,
! 294: Tcl_Interp *interp,
! 295: int objc,
! 296: Tcl_Obj *CONST objv[]
! 297: ){
! 298: #ifdef SQLITE_DEBUG
! 299: int n;
! 300: int nOut;
! 301: const unsigned char *zOrig;
! 302: unsigned char *z;
! 303: if( objc!=2 ){
! 304: Tcl_WrongNumArgs(interp, 1, objv, "HEX");
! 305: return TCL_ERROR;
! 306: }
! 307: zOrig = (unsigned char *)Tcl_GetStringFromObj(objv[1], &n);
! 308: z = sqlite3_malloc( n+3 );
! 309: n = sqlite3TestHexToBin(zOrig, n, z);
! 310: z[n] = 0;
! 311: nOut = sqlite3Utf8To8(z);
! 312: sqlite3TestBinToHex(z,nOut);
! 313: Tcl_AppendResult(interp, (char*)z, 0);
! 314: sqlite3_free(z);
! 315: return TCL_OK;
! 316: #else
! 317: Tcl_AppendResult(interp,
! 318: "[utf8_to_utf8] unavailable - SQLITE_DEBUG not defined", 0
! 319: );
! 320: return TCL_ERROR;
! 321: #endif
! 322: }
! 323:
! 324: static int getFts3Varint(const char *p, sqlite_int64 *v){
! 325: const unsigned char *q = (const unsigned char *) p;
! 326: sqlite_uint64 x = 0, y = 1;
! 327: while( (*q & 0x80) == 0x80 ){
! 328: x += y * (*q++ & 0x7f);
! 329: y <<= 7;
! 330: }
! 331: x += y * (*q++);
! 332: *v = (sqlite_int64) x;
! 333: return (int) (q - (unsigned char *)p);
! 334: }
! 335:
! 336:
! 337: /*
! 338: ** USAGE: read_fts3varint BLOB VARNAME
! 339: **
! 340: ** Read a varint from the start of BLOB. Set variable VARNAME to contain
! 341: ** the interpreted value. Return the number of bytes of BLOB consumed.
! 342: */
! 343: static int read_fts3varint(
! 344: void * clientData,
! 345: Tcl_Interp *interp,
! 346: int objc,
! 347: Tcl_Obj *CONST objv[]
! 348: ){
! 349: int nBlob;
! 350: unsigned char *zBlob;
! 351: sqlite3_int64 iVal;
! 352: int nVal;
! 353:
! 354: if( objc!=3 ){
! 355: Tcl_WrongNumArgs(interp, 1, objv, "BLOB VARNAME");
! 356: return TCL_ERROR;
! 357: }
! 358: zBlob = Tcl_GetByteArrayFromObj(objv[1], &nBlob);
! 359:
! 360: nVal = getFts3Varint((char*)zBlob, (sqlite3_int64 *)(&iVal));
! 361: Tcl_ObjSetVar2(interp, objv[2], 0, Tcl_NewWideIntObj(iVal), 0);
! 362: Tcl_SetObjResult(interp, Tcl_NewIntObj(nVal));
! 363: return TCL_OK;
! 364: }
! 365:
! 366:
! 367: /*
! 368: ** Register commands with the TCL interpreter.
! 369: */
! 370: int Sqlitetest_hexio_Init(Tcl_Interp *interp){
! 371: static struct {
! 372: char *zName;
! 373: Tcl_ObjCmdProc *xProc;
! 374: } aObjCmd[] = {
! 375: { "hexio_read", hexio_read },
! 376: { "hexio_write", hexio_write },
! 377: { "hexio_get_int", hexio_get_int },
! 378: { "hexio_render_int16", hexio_render_int16 },
! 379: { "hexio_render_int32", hexio_render_int32 },
! 380: { "utf8_to_utf8", utf8_to_utf8 },
! 381: { "read_fts3varint", read_fts3varint },
! 382: };
! 383: int i;
! 384: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
! 385: Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
! 386: }
! 387: return TCL_OK;
! 388: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_hexio.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src