diff options
Diffstat (limited to 'Build/source/texk/web2c/luatexdir/luasocket/src/mime.c')
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luasocket/src/mime.c | 130 |
1 files changed, 64 insertions, 66 deletions
diff --git a/Build/source/texk/web2c/luatexdir/luasocket/src/mime.c b/Build/source/texk/web2c/luatexdir/luasocket/src/mime.c index dddd3d66ea0..ed441046f0f 100644 --- a/Build/source/texk/web2c/luatexdir/luasocket/src/mime.c +++ b/Build/source/texk/web2c/luatexdir/luasocket/src/mime.c @@ -6,10 +6,7 @@ #include "lua.h" #include "lauxlib.h" - -#if !defined(LUA_VERSION_NUM) || (LUA_VERSION_NUM < 501) -#include "compat-5.1.h" -#endif +#include "compat.h" #include "mime.h" @@ -41,7 +38,7 @@ static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer); static void qpsetup(UC *class, UC *unbase); 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, +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); @@ -81,7 +78,8 @@ static UC b64unbase[256]; \*-------------------------------------------------------------------------*/ MIME_API int luaopen_mime_core(lua_State *L) { - luaL_openlib(L, "mime", func, 0); + lua_newtable(L); + luaL_setfuncs(L, func, 0); /* make version string available to scripts */ lua_pushstring(L, "_VERSION"); lua_pushstring(L, MIME_VERSION); @@ -98,15 +96,15 @@ MIME_API int luaopen_mime_core(lua_State *L) /*-------------------------------------------------------------------------*\ * 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. +* 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 *input = (const UC *) luaL_optlstring(L, 2, NULL, &size); const UC *last = input + size; int length = (int) luaL_optnumber(L, 3, 76); luaL_Buffer buffer; @@ -118,7 +116,7 @@ static int mime_global_wrp(lua_State *L) else lua_pushnil(L); lua_pushnumber(L, length); return 2; - } + } luaL_buffinit(L, &buffer); while (input < last) { switch (*input) { @@ -145,9 +143,9 @@ static int mime_global_wrp(lua_State *L) } /*-------------------------------------------------------------------------*\ -* Fill base64 decode map. +* Fill base64 decode map. \*-------------------------------------------------------------------------*/ -static void b64setup(UC *unbase) +static void b64setup(UC *unbase) { int i; for (i = 0; i <= 255; i++) unbase[i] = (UC) 255; @@ -156,11 +154,11 @@ static void b64setup(UC *unbase) } /*-------------------------------------------------------------------------*\ -* Acumulates bytes in input buffer until 3 bytes are available. +* 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, +static size_t b64encode(UC c, UC *input, size_t size, luaL_Buffer *buffer) { input[size++] = c; @@ -169,7 +167,7 @@ static size_t b64encode(UC c, UC *input, size_t size, unsigned long value = 0; value += input[0]; value <<= 8; value += input[1]; value <<= 8; - value += input[2]; + value += input[2]; code[3] = b64base[value & 0x3f]; value >>= 6; code[2] = b64base[value & 0x3f]; value >>= 6; code[1] = b64base[value & 0x3f]; value >>= 6; @@ -181,11 +179,11 @@ static size_t b64encode(UC c, UC *input, size_t size, } /*-------------------------------------------------------------------------*\ -* Encodes the Base64 last 1 or 2 bytes and adds padding '=' +* 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, +static size_t b64pad(const UC *input, size_t size, luaL_Buffer *buffer) { unsigned long value = 0; @@ -198,7 +196,7 @@ static size_t b64pad(const UC *input, size_t size, luaL_addlstring(buffer, (char *) code, 4); break; case 2: - value = input[0]; value <<= 8; + value = input[0]; value <<= 8; value |= input[1]; value <<= 2; code[2] = b64base[value & 0x3f]; value >>= 6; code[1] = b64base[value & 0x3f]; value >>= 6; @@ -212,11 +210,11 @@ static size_t b64pad(const UC *input, size_t size, } /*-------------------------------------------------------------------------*\ -* Acumulates bytes in input buffer until 4 bytes are available. +* 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, +static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer) { /* ignore invalid characters */ @@ -234,7 +232,7 @@ static size_t b64decode(UC c, UC *input, size_t size, decoded[1] = (UC) (value & 0xff); value >>= 8; decoded[0] = (UC) value; /* take care of paddding */ - valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3; + valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3; luaL_addlstring(buffer, (char *) decoded, valid); return 0; /* need more data */ @@ -246,7 +244,7 @@ static size_t b64decode(UC c, UC *input, size_t size, * 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 +* 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. \*-------------------------------------------------------------------------*/ @@ -254,7 +252,7 @@ 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 *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize); const UC *last = input + isize; luaL_Buffer buffer; /* end-of-input blackhole */ @@ -267,9 +265,9 @@ static int mime_global_b64(lua_State *L) lua_settop(L, 2); /* process first part of the input */ luaL_buffinit(L, &buffer); - while (input < last) + while (input < last) asize = b64encode(*input++, atom, asize, &buffer); - input = (UC *) luaL_optlstring(L, 2, NULL, &isize); + input = (const UC *) luaL_optlstring(L, 2, NULL, &isize); /* if second part is nil, we are done */ if (!input) { size_t osize = 0; @@ -283,7 +281,7 @@ static int mime_global_b64(lua_State *L) } /* otherwise process the second part */ last = input + isize; - while (input < last) + while (input < last) asize = b64encode(*input++, atom, asize, &buffer); luaL_pushresult(&buffer); lua_pushlstring(L, (char *) atom, asize); @@ -300,7 +298,7 @@ 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 *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize); const UC *last = input + isize; luaL_Buffer buffer; /* end-of-input blackhole */ @@ -313,9 +311,9 @@ static int mime_global_unb64(lua_State *L) lua_settop(L, 2); /* process first part of the input */ luaL_buffinit(L, &buffer); - while (input < last) + while (input < last) asize = b64decode(*input++, atom, asize, &buffer); - input = (UC *) luaL_optlstring(L, 2, NULL, &isize); + input = (const UC *) luaL_optlstring(L, 2, NULL, &isize); /* if second is nil, we are done */ if (!input) { size_t osize = 0; @@ -328,7 +326,7 @@ static int mime_global_unb64(lua_State *L) } /* otherwise, process the rest of the input */ last = input + isize; - while (input < last) + while (input < last) asize = b64decode(*input++, atom, asize, &buffer); luaL_pushresult(&buffer); lua_pushlstring(L, (char *) atom, asize); @@ -344,7 +342,7 @@ static int mime_global_unb64(lua_State *L) * 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. +* 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 \*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*\ @@ -357,7 +355,7 @@ static void qpsetup(UC *cl, UC *unbase) for (i = 0; i < 256; i++) cl[i] = QP_QUOTED; for (i = 33; i <= 60; i++) cl[i] = QP_PLAIN; for (i = 62; i <= 126; i++) cl[i] = QP_PLAIN; - cl['\t'] = QP_IF_LAST; + cl['\t'] = QP_IF_LAST; cl[' '] = QP_IF_LAST; cl['\r'] = QP_CR; for (i = 0; i < 256; i++) unbase[i] = 255; @@ -383,9 +381,9 @@ static void qpquote(UC c, luaL_Buffer *buffer) /*-------------------------------------------------------------------------*\ * Accumulate characters until we are sure about how to deal with them. -* Once we are sure, output to the buffer, in the correct form. +* Once we are sure, output to the buffer, in the correct form. \*-------------------------------------------------------------------------*/ -static size_t qpencode(UC c, UC *input, size_t size, +static size_t qpencode(UC c, UC *input, size_t size, const char *marker, luaL_Buffer *buffer) { input[size++] = c; @@ -426,7 +424,7 @@ static size_t qpencode(UC c, UC *input, size_t size, } /*-------------------------------------------------------------------------*\ -* Deal with the final characters +* Deal with the final characters \*-------------------------------------------------------------------------*/ static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer) { @@ -443,8 +441,8 @@ static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer) * 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. +* 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) @@ -452,7 +450,7 @@ 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 *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize); const UC *last = input + isize; const char *marker = luaL_optstring(L, 3, CRLF); luaL_Buffer buffer; @@ -468,7 +466,7 @@ static int mime_global_qp(lua_State *L) luaL_buffinit(L, &buffer); while (input < last) asize = qpencode(*input++, atom, asize, marker, &buffer); - input = (UC *) luaL_optlstring(L, 2, NULL, &isize); + input = (const UC *) luaL_optlstring(L, 2, NULL, &isize); /* if second part is nil, we are done */ if (!input) { asize = qppad(atom, asize, &buffer); @@ -488,7 +486,7 @@ static int mime_global_qp(lua_State *L) /*-------------------------------------------------------------------------*\ * 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. +* 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; @@ -496,8 +494,8 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) { /* deal with all characters we can deal */ switch (input[0]) { /* if we have an escape character */ - case '=': - if (size < 3) return size; + case '=': + if (size < 3) return size; /* eliminate soft line break */ if (input[1] == '\r' && input[2] == '\n') return 0; /* decode quoted representation */ @@ -507,7 +505,7 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) { else luaL_addchar(buffer, (char) ((c << 4) + d)); return 0; case '\r': - if (size < 2) return size; + if (size < 2) return size; if (input[1] == '\n') luaL_addlstring(buffer, (char *)input, 2); return 0; default: @@ -520,15 +518,15 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) { /*-------------------------------------------------------------------------*\ * 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. +* 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 *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize); const UC *last = input + isize; luaL_Buffer buffer; /* end-of-input blackhole */ @@ -543,14 +541,14 @@ static int mime_global_unqp(lua_State *L) luaL_buffinit(L, &buffer); while (input < last) asize = qpdecode(*input++, atom, asize, &buffer); - input = (UC *) luaL_optlstring(L, 2, NULL, &isize); + input = (const 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) @@ -563,9 +561,9 @@ static int mime_global_unqp(lua_State *L) /*-------------------------------------------------------------------------*\ * 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. +* 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 \*-------------------------------------------------------------------------*/ @@ -573,7 +571,7 @@ 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 *input = (const UC *) luaL_optlstring(L, 2, NULL, &size); const UC *last = input + size; int length = (int) luaL_optnumber(L, 3, 76); luaL_Buffer buffer; @@ -598,11 +596,11 @@ static int mime_global_qpwrp(lua_State *L) if (left <= 3) { left = length; luaL_addstring(&buffer, EQCRLF); - } + } luaL_addchar(&buffer, *input); left--; break; - default: + default: if (left <= 1) { left = length; luaL_addstring(&buffer, EQCRLF); @@ -630,7 +628,7 @@ static int mime_global_qpwrp(lua_State *L) * last is the previous character \*-------------------------------------------------------------------------*/ #define eolcandidate(c) (c == '\r' || c == '\n') -static int eolprocess(int c, int last, const char *marker, +static int eolprocess(int c, int last, const char *marker, luaL_Buffer *buffer) { if (eolcandidate(c)) { @@ -648,15 +646,15 @@ static int eolprocess(int c, int last, const char *marker, } /*-------------------------------------------------------------------------*\ -* Converts a string to uniform EOL convention. +* 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 +* 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); + int ctx = luaL_checkinteger(L, 1); size_t isize = 0; const char *input = luaL_optlstring(L, 2, NULL, &isize); const char *last = input + isize; @@ -678,18 +676,18 @@ static int mime_global_eol(lua_State *L) } /*-------------------------------------------------------------------------*\ -* Takes one byte and stuff it if needed. +* Takes one byte and stuff it if needed. \*-------------------------------------------------------------------------*/ static size_t dot(int c, size_t state, luaL_Buffer *buffer) { luaL_addchar(buffer, (char) c); switch (c) { - case '\r': + case '\r': return 1; - case '\n': - return (state == 1)? 2: 0; - case '.': - if (state == 2) + case '\n': + return (state == 1)? 2: 0; + case '.': + if (state == 2) luaL_addchar(buffer, '.'); default: return 0; @@ -714,7 +712,7 @@ static int mime_global_dot(lua_State *L) } /* process all input */ luaL_buffinit(L, &buffer); - while (input < last) + while (input < last) state = dot(*input++, state, &buffer); luaL_pushresult(&buffer); lua_pushnumber(L, (lua_Number) state); |