deps/lua/src/lua_cmsgpack.c

   1 #include <math.h>
   2 #include <stdlib.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include <assert.h>
   6
   7 #include "lua.h"
   8 #include "lauxlib.h"
   9
  10 #define LUACMSGPACK_VERSION     "lua-cmsgpack 0.3.0"
  11 #define LUACMSGPACK_COPYRIGHT   "Copyright (C) 2012, Salvatore Sanfilippo"
  12 #define LUACMSGPACK_DESCRIPTION "MessagePack C implementation for Lua"
  13
  14 #define LUACMSGPACK_MAX_NESTING  16 /* Max tables nesting. */
  15
  16 /* ==============================================================================
  17  * MessagePack implementation and bindings for Lua 5.1.
  18  * Copyright(C) 2012 Salvatore Sanfilippo <antirez@gmail.com>
  19  *
  20  * http://github.com/antirez/lua-cmsgpack
  21  *
  22  * For MessagePack specification check the following web site:
  23  * http://wiki.msgpack.org/display/MSGPACK/Format+specification
  24  *
  25  * See Copyright Notice at the end of this file.
  26  *
  27  * CHANGELOG:
  28  * 19-Feb-2012 (ver 0.1.0): Initial release.
  29  * 20-Feb-2012 (ver 0.2.0): Tables encoding improved.
  30  * 20-Feb-2012 (ver 0.2.1): Minor bug fixing.
  31  * 20-Feb-2012 (ver 0.3.0): Module renamed lua-cmsgpack (was lua-msgpack).
  32  * ============================================================================ */
  33
  34 /* --------------------------- Endian conversion --------------------------------
  35  * We use it only for floats and doubles, all the other conversions are performed
  36  * in an endian independent fashion. So the only thing we need is a function
  37  * that swaps a binary string if the arch is little endian (and left it untouched
  38  * otherwise). */
  39
  40 /* Reverse memory bytes if arch is little endian. Given the conceptual
  41  * simplicity of the Lua build system we prefer to check for endianess at runtime.
  42  * The performance difference should be acceptable. */
  43 static void memrevifle(void *ptr, size_t len) {
  44     unsigned char *p = ptr, *e = p+len-1, aux;
  45     int test = 1;
  46     unsigned char *testp = (unsigned char*) &test;
  47
  48     if (testp[0] == 0) return; /* Big endian, nothign to do. */
  49     len /= 2;
  50     while(len--) {
  51         aux = *p;
  52         *p = *e;
  53         *e = aux;
  54         p++;
  55         e--;
  56     }
  57 }
  58
  59 /* ----------------------------- String buffer ----------------------------------
  60  * This is a simple implementation of string buffers. The only opereation
  61  * supported is creating empty buffers and appending bytes to it.
  62  * The string buffer uses 2x preallocation on every realloc for O(N) append
  63  * behavior.  */
  64
  65 typedef struct mp_buf {
  66     unsigned char *b;
  67     size_t len, free;
  68 } mp_buf;
  69
  70 static mp_buf *mp_buf_new(void) {
  71     mp_buf *buf = malloc(sizeof(*buf));
  72
  73     buf->b = NULL;
  74     buf->len = buf->free = 0;
  75     return buf;
  76 }
  77
  78 void mp_buf_append(mp_buf *buf, const unsigned char *s, size_t len) {
  79     if (buf->free < len) {
  80         size_t newlen = buf->len+len;
  81
  82         buf->b = realloc(buf->b,newlen*2);
  83         buf->free = newlen;
  84     }
  85     memcpy(buf->b+buf->len,s,len);
  86     buf->len += len;
  87     buf->free -= len;
  88 }
  89
  90 void mp_buf_free(mp_buf *buf) {
  91     free(buf->b);
  92     free(buf);
  93 }
  94
  95 /* ------------------------------ String cursor ----------------------------------
  96  * This simple data structure is used for parsing. Basically you create a cursor
  97  * using a string pointer and a length, then it is possible to access the
  98  * current string position with cursor->p, check the remaining length
  99  * in cursor->left, and finally consume more string using
 100  * mp_cur_consume(cursor,len), to advance 'p' and subtract 'left'.
 101  * An additional field cursor->error is set to zero on initialization and can
 102  * be used to report errors. */
 103
 104 #define MP_CUR_ERROR_NONE   0
 105 #define MP_CUR_ERROR_EOF    1   /* Not enough data to complete the opereation. */
 106 #define MP_CUR_ERROR_BADFMT 2   /* Bad data format */
 107
 108 typedef struct mp_cur {
 109     const unsigned char *p;
 110     size_t left;
 111     int err;
 112 } mp_cur;
 113
 114 static mp_cur *mp_cur_new(const unsigned char *s, size_t len) {
 115     mp_cur *cursor = malloc(sizeof(*cursor));
 116
 117     cursor->p = s;
 118     cursor->left = len;
 119     cursor->err = MP_CUR_ERROR_NONE;
 120     return cursor;
 121 }
 122
 123 static void mp_cur_free(mp_cur *cursor) {
 124     free(cursor);
 125 }
 126
 127 #define mp_cur_consume(_c,_len) do { _c->p += _len; _c->left -= _len; } while(0)
 128
 129 /* When there is not enough room we set an error in the cursor and return, this
 130  * is very common across the code so we have a macro to make the code look
 131  * a bit simpler. */
 132 #define mp_cur_need(_c,_len) do { \
 133     if (_c->left < _len) { \
 134         _c->err = MP_CUR_ERROR_EOF; \
 135         return; \
 136     } \
 137 } while(0)
 138
 139 /* --------------------------- Low level MP encoding -------------------------- */
 140
 141 static void mp_encode_bytes(mp_buf *buf, const unsigned char *s, size_t len) {
 142     unsigned char hdr[5];
 143     int hdrlen;
 144
 145     if (len < 32) {
 146         hdr[0] = 0xa0 | (len&0xff); /* fix raw */
 147         hdrlen = 1;
 148     } else if (len <= 0xffff) {
 149         hdr[0] = 0xda;
 150         hdr[1] = (len&0xff00)>>8;
 151         hdr[2] = len&0xff;
 152         hdrlen = 3;
 153     } else {
 154         hdr[0] = 0xdb;
 155         hdr[1] = (len&0xff000000)>>24;
 156         hdr[2] = (len&0xff0000)>>16;
 157         hdr[3] = (len&0xff00)>>8;
 158         hdr[4] = len&0xff;
 159         hdrlen = 5;
 160     }
 161     mp_buf_append(buf,hdr,hdrlen);
 162     mp_buf_append(buf,s,len);
 163 }
 164
 165 /* we assume IEEE 754 internal format for single and double precision floats. */
 166 static void mp_encode_double(mp_buf *buf, double d) {
 167     unsigned char b[9];
 168     float f = d;
 169
 170     assert(sizeof(f) == 4 && sizeof(d) == 8);
 171     if (d == (double)f) {
 172         b[0] = 0xca;    /* float IEEE 754 */
 173         memcpy(b+1,&f,4);
 174         memrevifle(b+1,4);
 175         mp_buf_append(buf,b,5);
 176     } else if (sizeof(d) == 8) {
 177         b[0] = 0xcb;    /* double IEEE 754 */
 178         memcpy(b+1,&d,8);
 179         memrevifle(b+1,8);
 180         mp_buf_append(buf,b,9);
 181     }
 182 }
 183
 184 static void mp_encode_int(mp_buf *buf, int64_t n) {
 185     unsigned char b[9];
 186     int enclen;
 187
 188     if (n >= 0) {
 189         if (n <= 127) {
 190             b[0] = n & 0x7f;    /* positive fixnum */
 191             enclen = 1;
 192         } else if (n <= 0xff) {
 193             b[0] = 0xcc;        /* uint 8 */
 194             b[1] = n & 0xff;
 195             enclen = 2;
 196         } else if (n <= 0xffff) {
 197             b[0] = 0xcd;        /* uint 16 */
 198             b[1] = (n & 0xff00) >> 8;
 199             b[2] = n & 0xff;
 200             enclen = 3;
 201         } else if (n <= 0xffffffffLL) {
 202             b[0] = 0xce;        /* uint 32 */
 203             b[1] = (n & 0xff000000) >> 24;
 204             b[2] = (n & 0xff0000) >> 16;
 205             b[3] = (n & 0xff00) >> 8;
 206             b[4] = n & 0xff;
 207             enclen = 5;
 208         } else {
 209             b[0] = 0xcf;        /* uint 64 */
 210             b[1] = (n & 0xff00000000000000LL) >> 56;
 211             b[2] = (n & 0xff000000000000LL) >> 48;
 212             b[3] = (n & 0xff0000000000LL) >> 40;
 213             b[4] = (n & 0xff00000000LL) >> 32;
 214             b[5] = (n & 0xff000000) >> 24;
 215             b[6] = (n & 0xff0000) >> 16;
 216             b[7] = (n & 0xff00) >> 8;
 217             b[8] = n & 0xff;
 218             enclen = 9;
 219         }
 220     } else {
 221         if (n >= -32) {
 222             b[0] = ((char)n);   /* negative fixnum */
 223             enclen = 1;
 224         } else if (n >= -128) {
 225             b[0] = 0xd0;        /* int 8 */
 226             b[1] = n & 0xff;
 227             enclen = 2;
 228         } else if (n >= -32768) {
 229             b[0] = 0xd1;        /* int 16 */
 230             b[1] = (n & 0xff00) >> 8;
 231             b[2] = n & 0xff;
 232             enclen = 3;
 233         } else if (n >= -2147483648LL) {
 234             b[0] = 0xd2;        /* int 32 */
 235             b[1] = (n & 0xff000000) >> 24;
 236             b[2] = (n & 0xff0000) >> 16;
 237             b[3] = (n & 0xff00) >> 8;
 238             b[4] = n & 0xff;
 239             enclen = 5;
 240         } else {
 241             b[0] = 0xd3;        /* int 64 */
 242             b[1] = (n & 0xff00000000000000LL) >> 56;
 243             b[2] = (n & 0xff000000000000LL) >> 48;
 244             b[3] = (n & 0xff0000000000LL) >> 40;
 245             b[4] = (n & 0xff00000000LL) >> 32;
 246             b[5] = (n & 0xff000000) >> 24;
 247             b[6] = (n & 0xff0000) >> 16;
 248             b[7] = (n & 0xff00) >> 8;
 249             b[8] = n & 0xff;
 250             enclen = 9;
 251         }
 252     }
 253     mp_buf_append(buf,b,enclen);
 254 }
 255
 256 static void mp_encode_array(mp_buf *buf, int64_t n) {
 257     unsigned char b[5];
 258     int enclen;
 259
 260     if (n <= 15) {
 261         b[0] = 0x90 | (n & 0xf);    /* fix array */
 262         enclen = 1;
 263     } else if (n <= 65535) {
 264         b[0] = 0xdc;                /* array 16 */
 265         b[1] = (n & 0xff00) >> 8;
 266         b[2] = n & 0xff;
 267         enclen = 3;
 268     } else {
 269         b[0] = 0xdd;                /* array 32 */
 270         b[1] = (n & 0xff000000) >> 24;
 271         b[2] = (n & 0xff0000) >> 16;
 272         b[3] = (n & 0xff00) >> 8;
 273         b[4] = n & 0xff;
 274         enclen = 5;
 275     }
 276     mp_buf_append(buf,b,enclen);
 277 }
 278
 279 static void mp_encode_map(mp_buf *buf, int64_t n) {
 280     unsigned char b[5];
 281     int enclen;
 282
 283     if (n <= 15) {
 284         b[0] = 0x80 | (n & 0xf);    /* fix map */
 285         enclen = 1;
 286     } else if (n <= 65535) {
 287         b[0] = 0xde;                /* map 16 */
 288         b[1] = (n & 0xff00) >> 8;
 289         b[2] = n & 0xff;
 290         enclen = 3;
 291     } else {
 292         b[0] = 0xdf;                /* map 32 */
 293         b[1] = (n & 0xff000000) >> 24;
 294         b[2] = (n & 0xff0000) >> 16;
 295         b[3] = (n & 0xff00) >> 8;
 296         b[4] = n & 0xff;
 297         enclen = 5;
 298     }
 299     mp_buf_append(buf,b,enclen);
 300 }
 301
 302 /* ----------------------------- Lua types encoding --------------------------- */
 303
 304 static void mp_encode_lua_string(lua_State *L, mp_buf *buf) {
 305     size_t len;
 306     const char *s;
 307
 308     s = lua_tolstring(L,-1,&len);
 309     mp_encode_bytes(buf,(const unsigned char*)s,len);
 310 }
 311
 312 static void mp_encode_lua_bool(lua_State *L, mp_buf *buf) {
 313     unsigned char b = lua_toboolean(L,-1) ? 0xc3 : 0xc2;
 314     mp_buf_append(buf,&b,1);
 315 }
 316
 317 static void mp_encode_lua_number(lua_State *L, mp_buf *buf) {
 318     lua_Number n = lua_tonumber(L,-1);
 319
 320     if (floor(n) != n) {
 321         mp_encode_double(buf,(double)n);
 322     } else {
 323         mp_encode_int(buf,(int64_t)n);
 324     }
 325 }
 326
 327 static void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level);
 328
 329 /* Convert a lua table into a message pack list. */
 330 static void mp_encode_lua_table_as_array(lua_State *L, mp_buf *buf, int level) {
 331     size_t len = lua_objlen(L,-1), j;
 332
 333     mp_encode_array(buf,len);
 334     for (j = 1; j <= len; j++) {
 335         lua_pushnumber(L,j);
 336         lua_gettable(L,-2);
 337         mp_encode_lua_type(L,buf,level+1);
 338     }
 339 }
 340
 341 /* Convert a lua table into a message pack key-value map. */
 342 static void mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {
 343     size_t len = 0;
 344
 345     /* First step: count keys into table. No other way to do it with the
 346      * Lua API, we need to iterate a first time. Note that an alternative
 347      * would be to do a single run, and then hack the buffer to insert the
 348      * map opcodes for message pack. Too hachish for this lib. */
 349     lua_pushnil(L);
 350     while(lua_next(L,-2)) {
 351         lua_pop(L,1); /* remove value, keep key for next iteration. */
 352         len++;
 353     }
 354
 355     /* Step two: actually encoding of the map. */
 356     mp_encode_map(buf,len);
 357     lua_pushnil(L);
 358     while(lua_next(L,-2)) {
 359         /* Stack: ... key value */
 360         lua_pushvalue(L,-2); /* Stack: ... key value key */
 361         mp_encode_lua_type(L,buf,level+1); /* encode key */
 362         mp_encode_lua_type(L,buf,level+1); /* encode val */
 363     }
 364 }
 365
 366 /* Returns true if the Lua table on top of the stack is exclusively composed
 367  * of keys from numerical keys from 1 up to N, with N being the total number
 368  * of elements, without any hole in the middle. */
 369 static int table_is_an_array(lua_State *L) {
 370     long count = 0, max = 0, idx = 0;
 371     lua_Number n;
 372
 373     lua_pushnil(L);
 374     while(lua_next(L,-2)) {
 375         /* Stack: ... key value */
 376         lua_pop(L,1); /* Stack: ... key */
 377         if (!lua_isnumber(L,-1)) goto not_array;
 378         n = lua_tonumber(L,-1);
 379         idx = n;
 380         if (idx != n || idx < 1) goto not_array;
 381         count++;
 382         max = idx;
 383     }
 384     /* We have the total number of elements in "count". Also we have
 385      * the max index encountered in "idx". We can't reach this code
 386      * if there are indexes <= 0. If you also note that there can not be
 387      * repeated keys into a table, you have that if idx==count you are sure
 388      * that there are all the keys form 1 to count (both included). */
 389     return idx == count;
 390
 391 not_array:
 392     lua_pop(L,1);
 393     return 0;
 394 }
 395
 396 /* If the length operator returns non-zero, that is, there is at least
 397  * an object at key '1', we serialize to message pack list. Otherwise
 398  * we use a map. */
 399 static void mp_encode_lua_table(lua_State *L, mp_buf *buf, int level) {
 400     if (table_is_an_array(L))
 401         mp_encode_lua_table_as_array(L,buf,level);
 402     else
 403         mp_encode_lua_table_as_map(L,buf,level);
 404 }
 405
 406 static void mp_encode_lua_null(lua_State *L, mp_buf *buf) {
 407     unsigned char b[1];
 408
 409     b[0] = 0xc0;
 410     mp_buf_append(buf,b,1);
 411 }
 412
 413 static void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level) {
 414     int t = lua_type(L,-1);
 415
 416     /* Limit the encoding of nested tables to a specfiied maximum depth, so that
 417      * we survive when called against circular references in tables. */
 418     if (t == LUA_TTABLE && level == LUACMSGPACK_MAX_NESTING) t = LUA_TNIL;
 419     switch(t) {
 420     case LUA_TSTRING: mp_encode_lua_string(L,buf); break;
 421     case LUA_TBOOLEAN: mp_encode_lua_bool(L,buf); break;
 422     case LUA_TNUMBER: mp_encode_lua_number(L,buf); break;
 423     case LUA_TTABLE: mp_encode_lua_table(L,buf,level); break;
 424     default: mp_encode_lua_null(L,buf); break;
 425     }
 426     lua_pop(L,1);
 427 }
 428
 429 static int mp_pack(lua_State *L) {
 430     mp_buf *buf = mp_buf_new();
 431
 432     mp_encode_lua_type(L,buf,0);
 433     lua_pushlstring(L,(char*)buf->b,buf->len);
 434     mp_buf_free(buf);
 435     return 1;
 436 }
 437
 438 /* --------------------------------- Decoding --------------------------------- */
 439
 440 void mp_decode_to_lua_type(lua_State *L, mp_cur *c);
 441
 442 void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
 443     int index = 1;
 444
 445     lua_newtable(L);
 446     while(len--) {
 447         lua_pushnumber(L,index++);
 448         mp_decode_to_lua_type(L,c);
 449         if (c->err) return;
 450         lua_settable(L,-3);
 451     }
 452 }
 453
 454 void mp_decode_to_lua_hash(lua_State *L, mp_cur *c, size_t len) {
 455     lua_newtable(L);
 456     while(len--) {
 457         mp_decode_to_lua_type(L,c); /* key */
 458         if (c->err) return;
 459         mp_decode_to_lua_type(L,c); /* value */
 460         if (c->err) return;
 461         lua_settable(L,-3);
 462     }
 463 }
 464
 465 /* Decode a Message Pack raw object pointed by the string cursor 'c' to
 466  * a Lua type, that is left as the only result on the stack. */
 467 void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
 468     mp_cur_need(c,1);
 469     switch(c->p[0]) {
 470     case 0xcc:  /* uint 8 */
 471         mp_cur_need(c,2);
 472         lua_pushnumber(L,c->p[1]);
 473         mp_cur_consume(c,2);
 474         break;
 475     case 0xd0:  /* int 8 */
 476         mp_cur_need(c,2);
 477         lua_pushnumber(L,(char)c->p[1]);
 478         mp_cur_consume(c,2);
 479         break;
 480     case 0xcd:  /* uint 16 */
 481         mp_cur_need(c,3);
 482         lua_pushnumber(L,
 483             (c->p[1] << 8) |
 484              c->p[2]);
 485         mp_cur_consume(c,3);
 486         break;
 487     case 0xd1:  /* int 16 */
 488         mp_cur_need(c,3);
 489         lua_pushnumber(L,(int16_t)
 490             (c->p[1] << 8) |
 491              c->p[2]);
 492         mp_cur_consume(c,3);
 493         break;
 494     case 0xce:  /* uint 32 */
 495         mp_cur_need(c,5);
 496         lua_pushnumber(L,
 497             ((uint32_t)c->p[1] << 24) |
 498             ((uint32_t)c->p[2] << 16) |
 499             ((uint32_t)c->p[3] << 8) |
 500              (uint32_t)c->p[4]);
 501         mp_cur_consume(c,5);
 502         break;
 503     case 0xd2:  /* int 32 */
 504         mp_cur_need(c,5);
 505         lua_pushnumber(L,
 506             ((int32_t)c->p[1] << 24) |
 507             ((int32_t)c->p[2] << 16) |
 508             ((int32_t)c->p[3] << 8) |
 509              (int32_t)c->p[4]);
 510         mp_cur_consume(c,5);
 511         break;
 512     case 0xcf:  /* uint 64 */
 513         mp_cur_need(c,9);
 514         lua_pushnumber(L,
 515             ((uint64_t)c->p[1] << 56) |
 516             ((uint64_t)c->p[2] << 48) |
 517             ((uint64_t)c->p[3] << 40) |
 518             ((uint64_t)c->p[4] << 32) |
 519             ((uint64_t)c->p[5] << 24) |
 520             ((uint64_t)c->p[6] << 16) |
 521             ((uint64_t)c->p[7] << 8) |
 522              (uint64_t)c->p[8]);
 523         mp_cur_consume(c,9);
 524         break;
 525     case 0xd3:  /* int 64 */
 526         mp_cur_need(c,9);
 527         lua_pushnumber(L,
 528             ((int64_t)c->p[1] << 56) |
 529             ((int64_t)c->p[2] << 48) |
 530             ((int64_t)c->p[3] << 40) |
 531             ((int64_t)c->p[4] << 32) |
 532             ((int64_t)c->p[5] << 24) |
 533             ((int64_t)c->p[6] << 16) |
 534             ((int64_t)c->p[7] << 8) |
 535              (int64_t)c->p[8]);
 536         mp_cur_consume(c,9);
 537         break;
 538     case 0xc0:  /* nil */
 539         lua_pushnil(L);
 540         mp_cur_consume(c,1);
 541         break;
 542     case 0xc3:  /* true */
 543         lua_pushboolean(L,1);
 544         mp_cur_consume(c,1);
 545         break;
 546     case 0xc2:  /* false */
 547         lua_pushboolean(L,0);
 548         mp_cur_consume(c,1);
 549         break;
 550     case 0xca:  /* float */
 551         mp_cur_need(c,5);
 552         assert(sizeof(float) == 4);
 553         {
 554             float f;
 555             memcpy(&f,c->p+1,4);
 556             memrevifle(&f,4);
 557             lua_pushnumber(L,f);
 558             mp_cur_consume(c,5);
 559         }
 560         break;
 561     case 0xcb:  /* double */
 562         mp_cur_need(c,9);
 563         assert(sizeof(double) == 8);
 564         {
 565             double d;
 566             memcpy(&d,c->p+1,8);
 567             memrevifle(&d,8);
 568             lua_pushnumber(L,d);
 569             mp_cur_consume(c,9);
 570         }
 571         break;
 572     case 0xda:  /* raw 16 */
 573         mp_cur_need(c,3);
 574         {
 575             size_t l = (c->p[1] << 8) | c->p[2];
 576             mp_cur_need(c,3+l);
 577             lua_pushlstring(L,(char*)c->p+3,l);
 578             mp_cur_consume(c,3+l);
 579         }
 580         break;
 581     case 0xdb:  /* raw 32 */
 582         mp_cur_need(c,5);
 583         {
 584             size_t l = (c->p[1] << 24) |
 585                        (c->p[2] << 16) |
 586                        (c->p[3] << 8) |
 587                        c->p[4];
 588             mp_cur_need(c,5+l);
 589             lua_pushlstring(L,(char*)c->p+5,l);
 590             mp_cur_consume(c,5+l);
 591         }
 592         break;
 593     case 0xdc:  /* array 16 */
 594         mp_cur_need(c,3);
 595         {
 596             size_t l = (c->p[1] << 8) | c->p[2];
 597             mp_cur_consume(c,3);
 598             mp_decode_to_lua_array(L,c,l);
 599         }
 600         break;
 601     case 0xdd:  /* array 32 */
 602         mp_cur_need(c,5);
 603         {
 604             size_t l = (c->p[1] << 24) |
 605                        (c->p[2] << 16) |
 606                        (c->p[3] << 8) |
 607                        c->p[4];
 608             mp_cur_consume(c,5);
 609             mp_decode_to_lua_array(L,c,l);
 610         }
 611         break;
 612     case 0xde:  /* map 16 */
 613         mp_cur_need(c,3);
 614         {
 615             size_t l = (c->p[1] << 8) | c->p[2];
 616             mp_cur_consume(c,3);
 617             mp_decode_to_lua_hash(L,c,l);
 618         }
 619         break;
 620     case 0xdf:  /* map 32 */
 621         mp_cur_need(c,5);
 622         {
 623             size_t l = (c->p[1] << 24) |
 624                        (c->p[2] << 16) |
 625                        (c->p[3] << 8) |
 626                        c->p[4];
 627             mp_cur_consume(c,5);
 628             mp_decode_to_lua_hash(L,c,l);
 629         }
 630         break;
 631     default:    /* types that can't be idenitified by first byte value. */
 632         if ((c->p[0] & 0x80) == 0) {   /* positive fixnum */
 633             lua_pushnumber(L,c->p[0]);
 634             mp_cur_consume(c,1);
 635         } else if ((c->p[0] & 0xe0) == 0xe0) {  /* negative fixnum */
 636             lua_pushnumber(L,(signed char)c->p[0]);
 637             mp_cur_consume(c,1);
 638         } else if ((c->p[0] & 0xe0) == 0xa0) {  /* fix raw */
 639             size_t l = c->p[0] & 0x1f;
 640             mp_cur_need(c,1+l);
 641             lua_pushlstring(L,(char*)c->p+1,l);
 642             mp_cur_consume(c,1+l);
 643         } else if ((c->p[0] & 0xf0) == 0x90) {  /* fix map */
 644             size_t l = c->p[0] & 0xf;
 645             mp_cur_consume(c,1);
 646             mp_decode_to_lua_array(L,c,l);
 647         } else if ((c->p[0] & 0xf0) == 0x80) {  /* fix map */
 648             size_t l = c->p[0] & 0xf;
 649             mp_cur_consume(c,1);
 650             mp_decode_to_lua_hash(L,c,l);
 651         } else {
 652             c->err = MP_CUR_ERROR_BADFMT;
 653         }
 654     }
 655 }
 656
 657 static int mp_unpack(lua_State *L) {
 658     size_t len;
 659     const unsigned char *s;
 660     mp_cur *c;
 661
 662     if (!lua_isstring(L,-1)) {
 663         lua_pushstring(L,"MessagePack decoding needs a string as input.");
 664         lua_error(L);
 665     }
 666
 667     s = (const unsigned char*) lua_tolstring(L,-1,&len);
 668     c = mp_cur_new(s,len);
 669     mp_decode_to_lua_type(L,c);
 670
 671     if (c->err == MP_CUR_ERROR_EOF) {
 672         mp_cur_free(c);
 673         lua_pushstring(L,"Missing bytes in input.");
 674         lua_error(L);
 675     } else if (c->err == MP_CUR_ERROR_BADFMT) {
 676         mp_cur_free(c);
 677         lua_pushstring(L,"Bad data format in input.");
 678         lua_error(L);
 679     } else if (c->left != 0) {
 680         mp_cur_free(c);
 681         lua_pushstring(L,"Extra bytes in input.");
 682         lua_error(L);
 683     }
 684     mp_cur_free(c);
 685     return 1;
 686 }
 687
 688 /* ---------------------------------------------------------------------------- */
 689
 690 static const struct luaL_reg thislib[] = {
 691     {"pack", mp_pack},
 692     {"unpack", mp_unpack},
 693     {NULL, NULL}
 694 };
 695
 696 LUALIB_API int luaopen_cmsgpack (lua_State *L) {
 697     luaL_register(L, "cmsgpack", thislib);
 698
 699     lua_pushliteral(L, LUACMSGPACK_VERSION);
 700     lua_setfield(L, -2, "_VERSION");
 701     lua_pushliteral(L, LUACMSGPACK_COPYRIGHT);
 702     lua_setfield(L, -2, "_COPYRIGHT");
 703     lua_pushliteral(L, LUACMSGPACK_DESCRIPTION);
 704     lua_setfield(L, -2, "_DESCRIPTION");
 705     return 1;
 706 }
 707
 708 /******************************************************************************
 709 * Copyright (C) 2012 Salvatore Sanfilippo.  All rights reserved.
 710 *
 711 * Permission is hereby granted, free of charge, to any person obtaining
 712 * a copy of this software and associated documentation files (the
 713 * "Software"), to deal in the Software without restriction, including
 714 * without limitation the rights to use, copy, modify, merge, publish,
 715 * distribute, sublicense, and/or sell copies of the Software, and to
 716 * permit persons to whom the Software is furnished to do so, subject to
 717 * the following conditions:
 718 *
 719 * The above copyright notice and this permission notice shall be
 720 * included in all copies or substantial portions of the Software.
 721 *
 722 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 723 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 724 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 725 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 726 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 727 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 728 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 729 ******************************************************************************/