Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- /*=========================================================================*\
- * MIME support functions
- * LuaSocket toolkit
- *
- * RCS ID: $Id: mime.c,v 1.28 2005/11/20 07:20:23 diego Exp $
- \*=========================================================================*/
- #include <string.h>
- #include "lua.h"
- #include "lauxlib.h"
- #if !defined(LUA_VERSION_NUM) || (LUA_VERSION_NUM < 501)
- #include "compat-5.1.h"
- #endif
- #include "mime.h"
- /*=========================================================================*\
- * Don't want to trust escape character constants
- \*=========================================================================*/
- typedef unsigned char UC;
- static const char CRLF[] = "\r\n";
- static const char EQCRLF[] = "=\r\n";
- /*=========================================================================*\
- * Internal function prototypes.
- \*=========================================================================*/
- static int mime_global_wrp(lua_State *L);
- static int mime_global_b64(lua_State *L);
- static int mime_global_unb64(lua_State *L);
- static int mime_global_qp(lua_State *L);
- static int mime_global_unqp(lua_State *L);
- static int mime_global_qpwrp(lua_State *L);
- static int mime_global_eol(lua_State *L);
- static int mime_global_dot(lua_State *L);
- static size_t dot(int c, size_t state, luaL_Buffer *buffer);
- static void b64setup(UC *b64unbase);
- static size_t b64encode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
- static size_t b64pad(const UC *input, size_t size, luaL_Buffer *buffer);
- static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
- static void qpsetup(UC *qpclass, UC *qpunbase);
- static void qpquote(UC c, luaL_Buffer *buffer);
- static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
- static size_t qpencode(UC c, UC *input, size_t size,
- const char *marker, luaL_Buffer *buffer);
- static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer);
- /* code support functions */
- static luaL_reg func[] = {
- { "dot", mime_global_dot },
- { "b64", mime_global_b64 },
- { "eol", mime_global_eol },
- { "qp", mime_global_qp },
- { "qpwrp", mime_global_qpwrp },
- { "unb64", mime_global_unb64 },
- { "unqp", mime_global_unqp },
- { "wrp", mime_global_wrp },
- { NULL, NULL }
- };
- /*-------------------------------------------------------------------------*\
- * Quoted-printable globals
- \*-------------------------------------------------------------------------*/
- static UC qpclass[256];
- static UC qpbase[] = "0123456789ABCDEF";
- static UC qpunbase[256];
- enum {QP_PLAIN, QP_QUOTED, QP_CR, QP_IF_LAST};
- /*-------------------------------------------------------------------------*\
- * Base64 globals
- \*-------------------------------------------------------------------------*/
- static const UC b64base[] =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
- static UC b64unbase[256];
- /*=========================================================================*\
- * Exported functions
- \*=========================================================================*/
- /*-------------------------------------------------------------------------*\
- * Initializes module
- \*-------------------------------------------------------------------------*/
- MIME_API int luaopen_mime_core(lua_State *L)
- {
- luaL_openlib(L, "mime", func, 0);
- /* make version string available to scripts */
- lua_pushstring(L, "_VERSION");
- lua_pushstring(L, MIME_VERSION);
- lua_rawset(L, -3);
- /* initialize lookup tables */
- qpsetup(qpclass, qpunbase);
- b64setup(b64unbase);
- return 1;
- }
- /*=========================================================================*\
- * Global Lua functions
- \*=========================================================================*/
- /*-------------------------------------------------------------------------*\
- * Incrementaly breaks a string into lines. The string can have CRLF breaks.
- * A, n = wrp(l, B, length)
- * A is a copy of B, broken into lines of at most 'length' bytes.
- * 'l' is how many bytes are left for the first line of B.
- * 'n' is the number of bytes left in the last line of A.
- \*-------------------------------------------------------------------------*/
- static int mime_global_wrp(lua_State *L)
- {
- size_t size = 0;
- int left = (int) luaL_checknumber(L, 1);
- const UC *input = (UC *) luaL_optlstring(L, 2, NULL, &size);
- const UC *last = input + size;
- int length = (int) luaL_optnumber(L, 3, 76);
- luaL_Buffer buffer;
- /* end of input black-hole */
- if (!input) {
- /* if last line has not been terminated, add a line break */
- if (left < length) lua_pushstring(L, CRLF);
- /* otherwise, we are done */
- else lua_pushnil(L);
- lua_pushnumber(L, length);
- return 2;
- }
- luaL_buffinit(L, &buffer);
- while (input < last) {
- switch (*input) {
- case '\r':
- break;
- case '\n':
- luaL_addstring(&buffer, CRLF);
- left = length;
- break;
- default:
- if (left <= 0) {
- left = length;
- luaL_addstring(&buffer, CRLF);
- }
- luaL_putchar(&buffer, *input);
- left--;
- break;
- }
- input++;
- }
- luaL_pushresult(&buffer);
- lua_pushnumber(L, left);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Fill base64 decode map.
- \*-------------------------------------------------------------------------*/
- static void b64setup(UC *b64unbase)
- {
- int i;
- for (i = 0; i <= 255; i++) b64unbase[i] = (UC) 255;
- for (i = 0; i < 64; i++) b64unbase[b64base[i]] = (UC) i;
- b64unbase['='] = 0;
- }
- /*-------------------------------------------------------------------------*\
- * Acumulates bytes in input buffer until 3 bytes are available.
- * Translate the 3 bytes into Base64 form and append to buffer.
- * Returns new number of bytes in buffer.
- \*-------------------------------------------------------------------------*/
- static size_t b64encode(UC c, UC *input, size_t size,
- luaL_Buffer *buffer)
- {
- input[size++] = c;
- if (size == 3) {
- UC code[4];
- unsigned long value = 0;
- value += input[0]; value <<= 8;
- value += input[1]; value <<= 8;
- value += input[2];
- code[3] = b64base[value & 0x3f]; value >>= 6;
- code[2] = b64base[value & 0x3f]; value >>= 6;
- code[1] = b64base[value & 0x3f]; value >>= 6;
- code[0] = b64base[value];
- luaL_addlstring(buffer, (char *) code, 4);
- size = 0;
- }
- return size;
- }
- /*-------------------------------------------------------------------------*\
- * Encodes the Base64 last 1 or 2 bytes and adds padding '='
- * Result, if any, is appended to buffer.
- * Returns 0.
- \*-------------------------------------------------------------------------*/
- static size_t b64pad(const UC *input, size_t size,
- luaL_Buffer *buffer)
- {
- unsigned long value = 0;
- UC code[4] = {'=', '=', '=', '='};
- switch (size) {
- case 1:
- value = input[0] << 4;
- code[1] = b64base[value & 0x3f]; value >>= 6;
- code[0] = b64base[value];
- luaL_addlstring(buffer, (char *) code, 4);
- break;
- case 2:
- value = input[0]; value <<= 8;
- value |= input[1]; value <<= 2;
- code[2] = b64base[value & 0x3f]; value >>= 6;
- code[1] = b64base[value & 0x3f]; value >>= 6;
- code[0] = b64base[value];
- luaL_addlstring(buffer, (char *) code, 4);
- break;
- default:
- break;
- }
- return 0;
- }
- /*-------------------------------------------------------------------------*\
- * Acumulates bytes in input buffer until 4 bytes are available.
- * Translate the 4 bytes from Base64 form and append to buffer.
- * Returns new number of bytes in buffer.
- \*-------------------------------------------------------------------------*/
- static size_t b64decode(UC c, UC *input, size_t size,
- luaL_Buffer *buffer)
- {
- /* ignore invalid characters */
- if (b64unbase[c] > 64) return size;
- input[size++] = c;
- /* decode atom */
- if (size == 4) {
- UC decoded[3];
- int valid, value = 0;
- value = b64unbase[input[0]]; value <<= 6;
- value |= b64unbase[input[1]]; value <<= 6;
- value |= b64unbase[input[2]]; value <<= 6;
- value |= b64unbase[input[3]];
- decoded[2] = (UC) (value & 0xff); value >>= 8;
- decoded[1] = (UC) (value & 0xff); value >>= 8;
- decoded[0] = (UC) value;
- /* take care of paddding */
- valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3;
- luaL_addlstring(buffer, (char *) decoded, valid);
- return 0;
- /* need more data */
- } else return size;
- }
- /*-------------------------------------------------------------------------*\
- * Incrementally applies the Base64 transfer content encoding to a string
- * A, B = b64(C, D)
- * A is the encoded version of the largest prefix of C .. D that is
- * divisible by 3. B has the remaining bytes of C .. D, *without* encoding.
- * The easiest thing would be to concatenate the two strings and
- * encode the result, but we can't afford that or Lua would dupplicate
- * every chunk we received.
- \*-------------------------------------------------------------------------*/
- static int mime_global_b64(lua_State *L)
- {
- UC atom[3];
- size_t isize = 0, asize = 0;
- const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
- const UC *last = input + isize;
- luaL_Buffer buffer;
- /* end-of-input blackhole */
- if (!input) {
- lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* process first part of the input */
- luaL_buffinit(L, &buffer);
- while (input < last)
- asize = b64encode(*input++, atom, asize, &buffer);
- input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
- /* if second part is nil, we are done */
- if (!input) {
- asize = b64pad(atom, asize, &buffer);
- luaL_pushresult(&buffer);
- if (!(*lua_tostring(L, -1))) lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* otherwise process the second part */
- last = input + isize;
- while (input < last)
- asize = b64encode(*input++, atom, asize, &buffer);
- luaL_pushresult(&buffer);
- lua_pushlstring(L, (char *) atom, asize);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Incrementally removes the Base64 transfer content encoding from a string
- * A, B = b64(C, D)
- * A is the encoded version of the largest prefix of C .. D that is
- * divisible by 4. B has the remaining bytes of C .. D, *without* encoding.
- \*-------------------------------------------------------------------------*/
- static int mime_global_unb64(lua_State *L)
- {
- UC atom[4];
- size_t isize = 0, asize = 0;
- const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
- const UC *last = input + isize;
- luaL_Buffer buffer;
- /* end-of-input blackhole */
- if (!input) {
- lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* process first part of the input */
- luaL_buffinit(L, &buffer);
- while (input < last)
- asize = b64decode(*input++, atom, asize, &buffer);
- input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
- /* if second is nil, we are done */
- if (!input) {
- luaL_pushresult(&buffer);
- if (!(*lua_tostring(L, -1))) lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* otherwise, process the rest of the input */
- last = input + isize;
- while (input < last)
- asize = b64decode(*input++, atom, asize, &buffer);
- luaL_pushresult(&buffer);
- lua_pushlstring(L, (char *) atom, asize);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Quoted-printable encoding scheme
- * all (except CRLF in text) can be =XX
- * CLRL in not text must be =XX=XX
- * 33 through 60 inclusive can be plain
- * 62 through 126 inclusive can be plain
- * 9 and 32 can be plain, unless in the end of a line, where must be =XX
- * encoded lines must be no longer than 76 not counting CRLF
- * soft line-break are =CRLF
- * To encode one byte, we need to see the next two.
- * Worst case is when we see a space, and wonder if a CRLF is comming
- \*-------------------------------------------------------------------------*/
- /*-------------------------------------------------------------------------*\
- * Split quoted-printable characters into classes
- * Precompute reverse map for encoding
- \*-------------------------------------------------------------------------*/
- static void qpsetup(UC *qpclass, UC *qpunbase)
- {
- int i;
- for (i = 0; i < 256; i++) qpclass[i] = QP_QUOTED;
- for (i = 33; i <= 60; i++) qpclass[i] = QP_PLAIN;
- for (i = 62; i <= 126; i++) qpclass[i] = QP_PLAIN;
- qpclass['\t'] = QP_IF_LAST;
- qpclass[' '] = QP_IF_LAST;
- qpclass['\r'] = QP_CR;
- for (i = 0; i < 256; i++) qpunbase[i] = 255;
- qpunbase['0'] = 0; qpunbase['1'] = 1; qpunbase['2'] = 2;
- qpunbase['3'] = 3; qpunbase['4'] = 4; qpunbase['5'] = 5;
- qpunbase['6'] = 6; qpunbase['7'] = 7; qpunbase['8'] = 8;
- qpunbase['9'] = 9; qpunbase['A'] = 10; qpunbase['a'] = 10;
- qpunbase['B'] = 11; qpunbase['b'] = 11; qpunbase['C'] = 12;
- qpunbase['c'] = 12; qpunbase['D'] = 13; qpunbase['d'] = 13;
- qpunbase['E'] = 14; qpunbase['e'] = 14; qpunbase['F'] = 15;
- qpunbase['f'] = 15;
- }
- /*-------------------------------------------------------------------------*\
- * Output one character in form =XX
- \*-------------------------------------------------------------------------*/
- static void qpquote(UC c, luaL_Buffer *buffer)
- {
- luaL_putchar(buffer, '=');
- luaL_putchar(buffer, qpbase[c >> 4]);
- luaL_putchar(buffer, qpbase[c & 0x0F]);
- }
- /*-------------------------------------------------------------------------*\
- * Accumulate characters until we are sure about how to deal with them.
- * Once we are sure, output to the buffer, in the correct form.
- \*-------------------------------------------------------------------------*/
- static size_t qpencode(UC c, UC *input, size_t size,
- const char *marker, luaL_Buffer *buffer)
- {
- input[size++] = c;
- /* deal with all characters we can have */
- while (size > 0) {
- switch (qpclass[input[0]]) {
- /* might be the CR of a CRLF sequence */
- case QP_CR:
- if (size < 2) return size;
- if (input[1] == '\n') {
- luaL_addstring(buffer, marker);
- return 0;
- } else qpquote(input[0], buffer);
- break;
- /* might be a space and that has to be quoted if last in line */
- case QP_IF_LAST:
- if (size < 3) return size;
- /* if it is the last, quote it and we are done */
- if (input[1] == '\r' && input[2] == '\n') {
- qpquote(input[0], buffer);
- luaL_addstring(buffer, marker);
- return 0;
- } else luaL_putchar(buffer, input[0]);
- break;
- /* might have to be quoted always */
- case QP_QUOTED:
- qpquote(input[0], buffer);
- break;
- /* might never have to be quoted */
- default:
- luaL_putchar(buffer, input[0]);
- break;
- }
- input[0] = input[1]; input[1] = input[2];
- size--;
- }
- return 0;
- }
- /*-------------------------------------------------------------------------*\
- * Deal with the final characters
- \*-------------------------------------------------------------------------*/
- static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
- {
- size_t i;
- for (i = 0; i < size; i++) {
- if (qpclass[input[i]] == QP_PLAIN) luaL_putchar(buffer, input[i]);
- else qpquote(input[i], buffer);
- }
- if (size > 0) luaL_addstring(buffer, EQCRLF);
- return 0;
- }
- /*-------------------------------------------------------------------------*\
- * Incrementally converts a string to quoted-printable
- * A, B = qp(C, D, marker)
- * Marker is the text to be used to replace CRLF sequences found in A.
- * A is the encoded version of the largest prefix of C .. D that
- * can be encoded without doubts.
- * B has the remaining bytes of C .. D, *without* encoding.
- \*-------------------------------------------------------------------------*/
- static int mime_global_qp(lua_State *L)
- {
- size_t asize = 0, isize = 0;
- UC atom[3];
- const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
- const UC *last = input + isize;
- const char *marker = luaL_optstring(L, 3, CRLF);
- luaL_Buffer buffer;
- /* end-of-input blackhole */
- if (!input) {
- lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* process first part of input */
- luaL_buffinit(L, &buffer);
- while (input < last)
- asize = qpencode(*input++, atom, asize, marker, &buffer);
- input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
- /* if second part is nil, we are done */
- if (!input) {
- asize = qppad(atom, asize, &buffer);
- luaL_pushresult(&buffer);
- if (!(*lua_tostring(L, -1))) lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* otherwise process rest of input */
- last = input + isize;
- while (input < last)
- asize = qpencode(*input++, atom, asize, marker, &buffer);
- luaL_pushresult(&buffer);
- lua_pushlstring(L, (char *) atom, asize);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Accumulate characters until we are sure about how to deal with them.
- * Once we are sure, output the to the buffer, in the correct form.
- \*-------------------------------------------------------------------------*/
- static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
- int d;
- input[size++] = c;
- /* deal with all characters we can deal */
- switch (input[0]) {
- /* if we have an escape character */
- case '=':
- if (size < 3) return size;
- /* eliminate soft line break */
- if (input[1] == '\r' && input[2] == '\n') return 0;
- /* decode quoted representation */
- c = qpunbase[input[1]]; d = qpunbase[input[2]];
- /* if it is an invalid, do not decode */
- if (c > 15 || d > 15) luaL_addlstring(buffer, (char *)input, 3);
- else luaL_putchar(buffer, (c << 4) + d);
- return 0;
- case '\r':
- if (size < 2) return size;
- if (input[1] == '\n') luaL_addlstring(buffer, (char *)input, 2);
- return 0;
- default:
- if (input[0] == '\t' || (input[0] > 31 && input[0] < 127))
- luaL_putchar(buffer, input[0]);
- return 0;
- }
- }
- /*-------------------------------------------------------------------------*\
- * Incrementally decodes a string in quoted-printable
- * A, B = qp(C, D)
- * A is the decoded version of the largest prefix of C .. D that
- * can be decoded without doubts.
- * B has the remaining bytes of C .. D, *without* decoding.
- \*-------------------------------------------------------------------------*/
- static int mime_global_unqp(lua_State *L)
- {
- size_t asize = 0, isize = 0;
- UC atom[3];
- const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
- const UC *last = input + isize;
- luaL_Buffer buffer;
- /* end-of-input blackhole */
- if (!input) {
- lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* process first part of input */
- luaL_buffinit(L, &buffer);
- while (input < last)
- asize = qpdecode(*input++, atom, asize, &buffer);
- input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
- /* if second part is nil, we are done */
- if (!input) {
- luaL_pushresult(&buffer);
- if (!(*lua_tostring(L, -1))) lua_pushnil(L);
- lua_pushnil(L);
- return 2;
- }
- /* otherwise process rest of input */
- last = input + isize;
- while (input < last)
- asize = qpdecode(*input++, atom, asize, &buffer);
- luaL_pushresult(&buffer);
- lua_pushlstring(L, (char *) atom, asize);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Incrementally breaks a quoted-printed string into lines
- * A, n = qpwrp(l, B, length)
- * A is a copy of B, broken into lines of at most 'length' bytes.
- * 'l' is how many bytes are left for the first line of B.
- * 'n' is the number of bytes left in the last line of A.
- * There are two complications: lines can't be broken in the middle
- * of an encoded =XX, and there might be line breaks already
- \*-------------------------------------------------------------------------*/
- static int mime_global_qpwrp(lua_State *L)
- {
- size_t size = 0;
- int left = (int) luaL_checknumber(L, 1);
- const UC *input = (UC *) luaL_optlstring(L, 2, NULL, &size);
- const UC *last = input + size;
- int length = (int) luaL_optnumber(L, 3, 76);
- luaL_Buffer buffer;
- /* end-of-input blackhole */
- if (!input) {
- if (left < length) lua_pushstring(L, EQCRLF);
- else lua_pushnil(L);
- lua_pushnumber(L, length);
- return 2;
- }
- /* process all input */
- luaL_buffinit(L, &buffer);
- while (input < last) {
- switch (*input) {
- case '\r':
- break;
- case '\n':
- left = length;
- luaL_addstring(&buffer, CRLF);
- break;
- case '=':
- if (left <= 3) {
- left = length;
- luaL_addstring(&buffer, EQCRLF);
- }
- luaL_putchar(&buffer, *input);
- left--;
- break;
- default:
- if (left <= 1) {
- left = length;
- luaL_addstring(&buffer, EQCRLF);
- }
- luaL_putchar(&buffer, *input);
- left--;
- break;
- }
- input++;
- }
- luaL_pushresult(&buffer);
- lua_pushnumber(L, left);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Here is what we do: \n, and \r are considered candidates for line
- * break. We issue *one* new line marker if any of them is seen alone, or
- * followed by a different one. That is, \n\n and \r\r will issue two
- * end of line markers each, but \r\n, \n\r etc will only issue *one*
- * marker. This covers Mac OS, Mac OS X, VMS, Unix and DOS, as well as
- * probably other more obscure conventions.
- *
- * c is the current character being processed
- * last is the previous character
- \*-------------------------------------------------------------------------*/
- #define eolcandidate(c) (c == '\r' || c == '\n')
- static int eolprocess(int c, int last, const char *marker,
- luaL_Buffer *buffer)
- {
- if (eolcandidate(c)) {
- if (eolcandidate(last)) {
- if (c == last) luaL_addstring(buffer, marker);
- return 0;
- } else {
- luaL_addstring(buffer, marker);
- return c;
- }
- } else {
- luaL_putchar(buffer, c);
- return 0;
- }
- }
- /*-------------------------------------------------------------------------*\
- * Converts a string to uniform EOL convention.
- * A, n = eol(o, B, marker)
- * A is the converted version of the largest prefix of B that can be
- * converted unambiguously. 'o' is the context returned by the previous
- * call. 'n' is the new context.
- \*-------------------------------------------------------------------------*/
- static int mime_global_eol(lua_State *L)
- {
- int ctx = luaL_checkint(L, 1);
- size_t isize = 0;
- const char *input = luaL_optlstring(L, 2, NULL, &isize);
- const char *last = input + isize;
- const char *marker = luaL_optstring(L, 3, CRLF);
- luaL_Buffer buffer;
- luaL_buffinit(L, &buffer);
- /* end of input blackhole */
- if (!input) {
- lua_pushnil(L);
- lua_pushnumber(L, 0);
- return 2;
- }
- /* process all input */
- while (input < last)
- ctx = eolprocess(*input++, ctx, marker, &buffer);
- luaL_pushresult(&buffer);
- lua_pushnumber(L, ctx);
- return 2;
- }
- /*-------------------------------------------------------------------------*\
- * Takes one byte and stuff it if needed.
- \*-------------------------------------------------------------------------*/
- static size_t dot(int c, size_t state, luaL_Buffer *buffer)
- {
- luaL_putchar(buffer, c);
- switch (c) {
- case '\r':
- return 1;
- case '\n':
- return (state == 1)? 2: 0;
- case '.':
- if (state == 2)
- luaL_putchar(buffer, '.');
- default:
- return 0;
- }
- }
- /*-------------------------------------------------------------------------*\
- * Incrementally applies smtp stuffing to a string
- * A, n = dot(l, D)
- \*-------------------------------------------------------------------------*/
- static int mime_global_dot(lua_State *L)
- {
- size_t isize = 0, state = (size_t) luaL_checknumber(L, 1);
- const char *input = luaL_optlstring(L, 2, NULL, &isize);
- const char *last = input + isize;
- luaL_Buffer buffer;
- /* end-of-input blackhole */
- if (!input) {
- lua_pushnil(L);
- lua_pushnumber(L, 2);
- return 2;
- }
- /* process all input */
- luaL_buffinit(L, &buffer);
- while (input < last)
- state = dot(*input++, state, &buffer);
- luaL_pushresult(&buffer);
- lua_pushnumber(L, state);
- return 2;
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement