static void add_s (lua_State *L, luaL_Buffer *b, struct Capture *cap) { if (lua_isstring(L, 3)) { const char *news = lua_tostring(L, 3); size_t l = lua_strlen(L, 3); size_t i; for (i=0; i<l; i++) { if (news[i] != ESC) luaL_putchar(b, news[i]); else { i++; /* skip ESC */ if (!isdigit((unsigned char)news[i])) luaL_putchar(b, news[i]); else { int level = check_capture(L, news[i], cap); luaL_addlstring(b, cap->capture[level].init, cap->capture[level].len); } } } } else { /* is a function */ int n; lua_pushvalue(L, 3); n = push_captures(L, cap); lua_rawcall(L, n, 1); if (lua_isstring(L, -1)) luaL_addvalue(b); /* add return to accumulated result */ else lua_pop(L, 1); /* function result is not a string: pop it */ } }
static int l_rpc_create(lua_State *l) { int nargs = lua_gettop(l) - 1; luaL_Buffer b; luaL_buffinit(l, &b); if (nargs < 0 || nargs > 0xff) { luaL_error(l, "Too many arguments provided (%d)", nargs); } luaL_putchar(&b, nargs); for (int i = 1; i < nargs + 1; ++i) { size_t len; const char *str = lua_tolstring(l, i, &len); if (len > 0xffff) { luaL_error(l, "Argument %d is longer than %d bytes", i, 0xffff); } // Store the length of the argument as a 16-bit little-endian integer. luaL_putchar(&b, (len >> 0) & 0xff); luaL_putchar(&b, (len >> 8) & 0xff); for (size_t j = 0; j < len; ++j) { luaL_putchar(&b, str[j]); } } luaL_pushresult(&b); return 1; }
static void add_s (MatchState *ms, luaL_Buffer *b, const char *s, const char *e) { lua_State *L = ms->L; if (lua_isstring(L, 3)) { const char *news = lua_tostring(L, 3); size_t l = lua_strlen(L, 3); size_t i; for (i=0; i<l; i++) { if (news[i] != ESC) luaL_putchar(b, news[i]); else { i++; /* skip ESC */ if (!isdigit(uchar(news[i]))) luaL_putchar(b, news[i]); else { int level = check_capture(ms, news[i]); push_onecapture(ms, level); luaL_addvalue(b); /* add capture to accumulated result */ } } } } else { /* is a function */ int n; lua_pushvalue(L, 3); n = push_captures(ms, s, e); lua_call(L, n, 1); if (lua_isstring(L, -1)) luaL_addvalue(b); /* add return to accumulated result */ else lua_pop(L, 1); /* function result is not a string: pop it */ } }
static void luaI_addquoted(lua_State * L, luaL_Buffer * b, int arg) { size_t l; const char *s = luaL_checklstring(L, arg, &l); luaL_putchar(b, '"'); while (l--) { switch (*s) { case '"': case '\\': case '\n': { luaL_putchar(b, '\\'); luaL_putchar(b, *s); break; } case '\0': { luaL_addlstring(b, "\\000", 4); break; } default: { luaL_putchar(b, *s); break; } } s++; } luaL_putchar(b, '"'); }
static int read_pattern (lua_State *L, FILE *f, const char *p) { int inskip = 0; /* {skip} level */ int c = NEED_OTHER; luaL_Buffer b; luaL_buffinit(L, &b); while (*p != '\0') { switch (*p) { case '{': inskip++; p++; continue; case '}': if (!inskip) lua_error(L, "unbalanced braces in read pattern"); inskip--; p++; continue; default: { const char *ep = luaI_classend(L, p); /* get what is next */ int m; /* match result */ if (c == NEED_OTHER) c = getc(f); m = (c==EOF) ? 0 : luaI_singlematch(c, p, ep); if (m) { if (!inskip) luaL_putchar(&b, c); c = NEED_OTHER; } switch (*ep) { case '+': /* repetition (1 or more) */ if (!m) goto break_while; /* pattern fails? */ /* else go through */ case '*': /* repetition (0 or more) */ while (m) { /* reads the same item until it fails */ c = getc(f); m = (c==EOF) ? 0 : luaI_singlematch(c, p, ep); if (m && !inskip) luaL_putchar(&b, c); } /* go through to continue reading the pattern */ case '?': /* optional */ p = ep+1; /* continues reading the pattern */ continue; default: if (!m) goto break_while; /* pattern fails? */ p = ep; /* else continues reading the pattern */ } } } } break_while: if (c != NEED_OTHER) ungetc(c, f); luaL_pushresult(&b); /* close buffer */ return (*p == '\0'); }
static int l_build_packet(lua_State *l) { size_t tidlen, sealedlen; const char *tid = lua_tolstring(l, 1, &tidlen); char *nonce = lua_touserdata(l, 2); char *publickey = lua_touserdata(l, 3); char *puzzle = lua_touserdata(l, 4); const char *sealed = lua_tolstring(l, 5, &sealedlen); luaL_argcheck(l, tid != NULL, 1, "TID expected"); luaL_argcheck(l, tidlen == TID_SIZE, 1, "TID is wrong size"); luaL_argcheck(l, nonce != NULL, 2, "Nonce expected"); luaL_argcheck(l, puzzle == NULL, 4, "Puzzles not supported"); luaL_argcheck(l, sealed != NULL, 5, "Sealed data expected"); luaL_Buffer b; luaL_buffinit(l, &b); char tidFlagByte = tid[0]; if (publickey) { tidFlagByte |= PUBLICKEY_FLAG; } luaL_putchar(&b, tidFlagByte); for (size_t i = 1; i < TID_SIZE; ++i) { luaL_putchar(&b, tid[i]); } for (size_t i = 0; i < crypto_box_NONCEBYTES; ++i) { luaL_putchar(&b, nonce[i]); } if (publickey) { for (size_t i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) { luaL_putchar(&b, publickey[i]); } } for (size_t i = 0; i < sealedlen; ++i) { luaL_putchar(&b, sealed[i]); } luaL_pushresult(&b); return 1; }
static int l_cipher_seal(lua_State *l) { size_t messagelen; void *cipher = lua_touserdata(l, 1); const char *message = lua_tolstring(l, 2, &messagelen); void *nonce = lua_touserdata(l, 3); luaL_argcheck(l, cipher != NULL, 1, "Public key expected"); luaL_argcheck(l, message != NULL, 2, "Message expected"); luaL_argcheck(l, nonce != NULL, 3, "Nonce expected"); uint8_t buffer[crypto_box_ZEROBYTES + messagelen]; memset(buffer, 0, crypto_box_ZEROBYTES); memcpy(buffer, &message[crypto_box_ZEROBYTES], messagelen); crypto_box_afternm(buffer, buffer, sizeof buffer, nonce, cipher); luaL_Buffer b; luaL_buffinit(l, &b); for (size_t i = 0; i < sizeof buffer - crypto_box_BOXZEROBYTES; ++i) { luaL_putchar(&b, buffer[i + crypto_box_BOXZEROBYTES]); } luaL_pushresult(&b); return 1; }
int lk::Socket::recvLine(lua_State *L) { luaL_Buffer buffer; luaL_buffinit(L, &buffer); while (true) { while (buffer_i_ < buffer_length_) { char c = buffer_[buffer_i_++]; // printf("recvLine (%c)\n", c); if (c == '\n') { // found end of line // push string luaL_pushresult(&buffer); return 1; } else if (c != '\r') { // ignore \r // add char to lua buffer luaL_putchar(&buffer, c); } } // read more data buffer_length_ = ::recv(socket_fd_, buffer_, MAX_BUFF_SIZE, 0); if (buffer_length_ == 0) { // connection closed return 0; } else if (buffer_length_ < 0) { buffer_length_ = 0; throw dub::Exception("Could not receive (%s).", strerror(errno)); } buffer_i_ = 0; } return 0; }
static int str_gsub (lua_State *L) { size_t srcl; const char *src = luaL_check_lstr(L, 1, &srcl); const char *p = luaL_check_string(L, 2); int max_s = luaL_opt_int(L, 4, srcl+1); int anchor = (*p == '^') ? (p++, 1) : 0; int n = 0; struct Capture cap; luaL_Buffer b; luaL_arg_check(L, lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)), 3, "string or function expected"); luaL_buffinit(L, &b); cap.src_end = src+srcl; while (n < max_s) { const char *e; cap.level = 0; e = match(L, src, p, &cap); if (e) { n++; add_s(L, &b, &cap); } if (e && e>src) /* non empty match? */ src = e; /* skip it */ else if (src < cap.src_end) luaL_putchar(&b, *src++); else break; if (anchor) break; } luaL_addlstring(&b, src, cap.src_end-src); luaL_pushresult(&b); lua_pushnumber(L, n); /* number of substitutions */ return 2; }
static int str_upper (lua_State *L) { size_t l; size_t i; luaL_Buffer b; const char *s = luaL_checklstring(L, 1, &l); luaL_buffinit(L, &b); for (i=0; i<l; i++) luaL_putchar(&b, toupper(uchar(s[i]))); luaL_pushresult(&b); return 1; }
static int str_lower (lua_State *L) { size_t l; size_t i; luaL_Buffer b; const char *s = luaL_check_lstr(L, 1, &l); luaL_buffinit(L, &b); for (i=0; i<l; i++) luaL_putchar(&b, tolower((unsigned char)(s[i]))); luaL_pushresult(&b); return 1; }
static int luaB_tostring (lua_State *L) { char buff[128]; luaL_checkany(L, 1); if (luaL_callmeta(L, 1, "__tostring")) /* is there a metafield? */ return 1; /* use its value */ switch (lua_type(L, 1)) { case LUA_TNUMBER: lua_pushstring(L, lua_tostring(L, 1)); return 1; case LUA_TSTRING: lua_pushvalue(L, 1); return 1; case LUA_TWSTRING: { luaL_Buffer b; size_t l; size_t i; const lua_WChar *s = lua_towstring(L, 1); l = lua_strlen(L, 1); if (l == 0) { lua_pushstring(L, ""); } else { luaL_buffinit(L, &b); for (i=0; i<l; i++) luaL_putchar(&b, (unsigned char)(s[i])); luaL_pushresult(&b); } return 1; } case LUA_TBOOLEAN: lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false")); return 1; case LUA_TTABLE: sprintf(buff, "table: %p", lua_topointer(L, 1)); break; case LUA_TFUNCTION: sprintf(buff, "function: %p", lua_topointer(L, 1)); break; case LUA_TUSERDATA: case LUA_TLIGHTUSERDATA: sprintf(buff, "userdata: %p", lua_touserdata(L, 1)); break; case LUA_TTHREAD: sprintf(buff, "thread: %p", (void *)lua_tothread(L, 1)); break; case LUA_TNIL: lua_pushliteral(L, "nil"); return 1; } lua_pushstring(L, buff); return 1; }
/** * X-Or. Does a bit-a-bit exclusive-or of two strings. * @param s1: arbitrary binary string. * @param s2: arbitrary binary string with same length as s1. * @return a binary string with same length as s1 and s2, * where each bit is the exclusive-or of the corresponding bits in s1-s2. */ static int ex_or (lua_State *L) { size_t l1, l2; const char *s1 = luaL_checklstring(L, 1, &l1); const char *s2 = luaL_checklstring(L, 2, &l2); luaL_Buffer b; luaL_argcheck( L, l1 == l2, 2, "lengths must be equal" ); luaL_buffinit(L, &b); while (l1--) luaL_putchar(&b, (*s1++)^(*s2++)); luaL_pushresult(&b); return 1; }
extern int str_upper(lua_State *L) { size_t l = 0; luaL_Buffer b; const char *s = luaL_checklstring(L, 1, &l); //从Lua栈中取出字符串 luaL_buffinit(L, &b); //分配一块与取出字符串同样大小的缓冲区 //luaL_addstring(&b, s); for (size_t i = 0; i < l; i++) luaL_putchar(&b, toupper((unsigned char)(s[i]))); luaL_pushresult(&b); //把缓冲区结果转换为字符串 return 1; }
static int read_word (lua_State *L, FILE *f) { int c; luaL_Buffer b; luaL_buffinit(L, &b); do { c = fgetc(f); } while (isspace(c)); /* skip spaces */ while (c != EOF && !isspace(c)) { luaL_putchar(&b, c); c = fgetc(f); } ungetc(c, f); luaL_pushresult(&b); /* close buffer */ return (lua_strlen(L, -1) > 0); }
static int str_char (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ int i; luaL_Buffer b; luaL_buffinit(L, &b); for (i=1; i<=n; i++) { int c = luaL_checkint(L, i); luaL_argcheck(L, uchar(c) == c, i, "invalid value"); luaL_putchar(&b, uchar(c)); } luaL_pushresult(&b); return 1; }
static int Puname(lua_State *L) /** uname([string]) */ { struct utsname u; luaL_Buffer b; const char *s; if (uname(&u) == -1) return pusherror(L, NULL); luaL_buffinit(L, &b); for (s=luaL_optstring(L, 1, "%s %n %r %v %m"); *s; s++) if (*s!='%') luaL_putchar(&b, *s); else switch (*++s) { case '%': luaL_putchar(&b, *s); break; case 'm': luaL_addstring(&b,u.machine); break; case 'n': luaL_addstring(&b,u.nodename); break; case 'r': luaL_addstring(&b,u.release); break; case 's': luaL_addstring(&b,u.sysname); break; case 'v': luaL_addstring(&b,u.version); break; default: badoption(L, 2, "format", *s); break; } luaL_pushresult(&b); return 1; }
static int pushchar(int c, int last, const char *marker, luaL_Buffer *buffer) { if (candidate(c)) { if (candidate(last)) { if (c == last) luaL_addstring(buffer, marker); return 0; } else { luaL_addstring(buffer, marker); return c; } } else { luaL_putchar(buffer, c); return 0; } }
static int l_tid_create(lua_State *l) { uint8_t tid[TID_SIZE]; randombytes(tid, sizeof tid); tid[0] &= ~TID_FLAGS; luaL_Buffer b; luaL_buffinit(l, &b); for (size_t i = 0; i < sizeof tid; ++i) { luaL_putchar(&b, tid[i]); } luaL_pushresult(&b); return 1; }
static int l_rpc_parse(lua_State *l) { size_t messagelen; const uint8_t *message = (const uint8_t*)lua_tolstring(l, 1, &messagelen); lua_newtable(l); if (messagelen < 1) { luaL_error(l, "No header"); } int nargs = message[0]; size_t index = 1; int i = 1; while (1) { uint_fast16_t len = (message[index+0] << 0) | (message[index+1] << 8); index += 2; luaL_Buffer b; luaL_buffinit(l, &b); size_t end = index + len; for (; index < end; ++index) { luaL_putchar(&b, message[index]); } lua_pushnumber(l, i); luaL_pushresult(&b); lua_settable(l, -3); if (i == nargs) { break; } } lua_pushnumber(l, index); return 2; }
/*-------------------------------------------------------------------------*\ * Reads a line terminated by a CR LF pair or just by a LF. The CR and LF * are not returned by the function and are discarded from the buffer \*-------------------------------------------------------------------------*/ static int recvline(p_buf buf, luaL_Buffer *b) { int err = IO_DONE; while (err == IO_DONE) { size_t count, pos; const char *data; err = buf_get(buf, &data, &count); pos = 0; while (pos < count && data[pos] != '\n') { /* we ignore all \r's */ if (data[pos] != '\r') luaL_putchar(b, data[pos]); pos++; } if (pos < count) { /* found '\n' */ buf_skip(buf, pos+1); /* skip '\n' too */ break; /* we are done */ } else /* reached the end of the buffer */ buf_skip(buf, pos); } return err; }
static int luaB_tostring (lua_State *L) { luaL_checkany(L, 1); if (luaL_callmeta(L, 1, "__tostring")) /* is there a metafield? */ return 1; /* use its value */ switch (lua_type(L, 1)) { case LUA_TNUMBER: lua_pushstring(L, lua_tostring(L, 1)); break; case LUA_TSTRING: lua_pushvalue(L, 1); break; case LUA_TWSTRING: { luaL_Buffer b; size_t l; size_t i; const lua_WChar *s = lua_towstring(L, 1); l = lua_strlen(L, 1); if (l == 0) { lua_pushstring(L, ""); } else { luaL_buffinit(L, &b); for (i=0; i<l; i++) luaL_putchar(&b, (unsigned char)(s[i])); luaL_pushresult(&b); } return 1; } case LUA_TBOOLEAN: lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false")); break; case LUA_TNIL: lua_pushliteral(L, "nil"); break; default: lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1)); break; } return 1; }
static int l_random_bytes(lua_State *l) { int n = luaL_checkint(l, 1); luaL_argcheck(l, n >= 1, 1, "Number of bytes is too small."); uint8_t buffer[n]; randombytes(buffer, sizeof buffer); luaL_Buffer b; luaL_buffinit(l, &b); for (size_t i = 0; i < sizeof buffer; ++i) { luaL_putchar(&b, buffer[i]); } luaL_pushresult(&b); return 1; }
/*-------------------------------------------------------------------------*\ * 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; }
/* ** Fails with error message from ODBC ** Inputs: ** type: type of handle used in operation ** handle: handle used in operation */ static int fail(lua_State *L, const SQLSMALLINT type, const SQLHANDLE handle) { SQLCHAR State[6]; SQLINTEGER NativeError; SQLSMALLINT MsgSize, i; SQLRETURN ret; char Msg[SQL_MAX_MESSAGE_LENGTH]; luaL_Buffer b; lua_pushnil(L); luaL_buffinit(L, &b); i = 1; while (1) { ret = SQLGetDiagRec(type, handle, i, State, &NativeError, Msg, sizeof(Msg), &MsgSize); if (ret == SQL_NO_DATA) break; luaL_addlstring(&b, Msg, MsgSize); luaL_putchar(&b, '\n'); i++; } luaL_pushresult(&b); return 2; }
static int str_lualex(lua_State *L) { size_t l = 0; const char *str = luaL_checklstring(L, 1, &l); int isWide = luaL_checkint(L, 2) != 0; size_t i; luaL_Buffer b; luaL_buffinit(L, &b); for (i = 0; i < l; ++i) { int needWideZero = 1; switch (str[i]) { case '\\': ++i; switch (str[i]) { case 'a': luaL_putchar(&b, '\a'); break; case 'b': luaL_putchar(&b, '\b'); break; case 'f': luaL_putchar(&b, '\f'); break; case 'n': luaL_putchar(&b, '\n'); break; case 'r': luaL_putchar(&b, '\r'); break; case 't': luaL_putchar(&b, '\t'); break; case 'v': luaL_putchar(&b, '\v'); break; case 'x': { int ch; ++i; ch = tolower(str[i]); if (!isdigit(ch) && !(ch >= 'a' && ch <= 'f') ) { --i; luaL_putchar(&b, 'x'); } else { /* \xxx */ int c = 0; int i = 0; int numDigits = isWide ? 4 : 2; do { ch = tolower(str[i]); if (isdigit(ch)) c = 16*c + (ch-'0'); else if (ch >= 'a' && ch <= 'f') c = 16*c + (ch-'a') + 10; ++i; ch = tolower(str[i]); } while (++i<numDigits && isdigit(ch) || (ch >= 'a' && ch <= 'f')); luaL_putchar(&b, (c & 0xff)); luaL_putchar(&b, ((c >> 8) & 0xff)); needWideZero = 0; } break; } default: { if (!isdigit(str[i])) luaL_putchar(&b, str[i]); else { /* \xxx */ int c = 0; int count = 0; do { c = 10*c + (str[i]-'0'); ++i; } while (++count<3 && isdigit(str[i])); luaL_putchar(&b, c); } } } break; default: luaL_putchar(&b, str[i]); } if (isWide && needWideZero) luaL_putchar(&b, str[i]); } luaL_pushresult(&b); return 1; }
LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { while (l--) luaL_putchar(B, *s++); }
static int str_format (lua_State *L) { int arg = 1; size_t sfl; const char *strfrmt = luaL_checklstring(L, arg, &sfl); const char *strfrmt_end = strfrmt+sfl; luaL_Buffer b; luaL_buffinit(L, &b); while (strfrmt < strfrmt_end) { if (*strfrmt != '%') luaL_putchar(&b, *strfrmt++); else if (*++strfrmt == '%') luaL_putchar(&b, *strfrmt++); /* %% */ else { /* format item */ char form[MAX_FORMAT]; /* to store the format (`%...') */ char buff[MAX_ITEM]; /* to store the formatted item */ int hasprecision = 0; if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == '$') return luaL_error(L, "obsolete option (d$) to `format'"); arg++; strfrmt = scanformat(L, strfrmt, form, &hasprecision); switch (*strfrmt++) { case 'c': case 'd': case 'i': { sprintf(buff, form, luaL_checkint(L, arg)); break; } case 'o': case 'u': case 'x': case 'X': { sprintf(buff, form, (unsigned int)(luaL_checknumber(L, arg))); break; } case 'e': case 'E': case 'f': case 'g': case 'G': { sprintf(buff, form, luaL_checknumber(L, arg)); break; } case 'q': { luaI_addquoted(L, &b, arg); continue; /* skip the `addsize' at the end */ } case 's': { size_t l; const char *s = luaL_checklstring(L, arg, &l); if (!hasprecision && l >= 100) { /* no precision and string is too long to be formatted; keep original string */ lua_pushvalue(L, arg); luaL_addvalue(&b); continue; /* skip the `addsize' at the end */ } else { sprintf(buff, form, s); break; } } default: { /* also treat cases `pnLlh' */ return luaL_error(L, "invalid option to `format'"); } } luaL_addlstring(&b, buff, strlen(buff)); } } luaL_pushresult(&b); return 1; }
// Lua: uart.read( id, format, [timeout], [timer_id] ) static int uart_read( lua_State* L ) { int id, res, mode, issign; unsigned timer_id = PLATFORM_TIMER_SYS_ID; s32 maxsize = 0, count = 0; const char *fmt; luaL_Buffer b; char cres; timer_data_type timeout = PLATFORM_TIMER_INF_TIMEOUT; id = luaL_checkinteger( L, 1 ); MOD_CHECK_ID( uart, id ); // Check format if( lua_isnumber( L, 2 ) ) { if( ( maxsize = ( s32 )lua_tointeger( L, 2 ) ) < 0 ) return luaL_error( L, "invalid max size" ); mode = UART_READ_MODE_MAXSIZE; } else { fmt = luaL_checkstring( L, 2 ); if( !strcmp( fmt, "*l" ) ) mode = UART_READ_MODE_LINE; else if( !strcmp( fmt, "*n" ) ) mode = UART_READ_MODE_NUMBER; else if( !strcmp( fmt, "*s" ) ) mode = UART_READ_MODE_SPACE; else return luaL_error( L, "invalid format" ); } // Check timeout and timer id uart_get_timeout_data( L, 3, &timeout, &timer_id ); // Read data luaL_buffinit( L, &b ); while( 1 ) { if( ( res = platform_uart_recv( id, timer_id, timeout ) ) == -1 ) break; cres = ( char )res; count ++; issign = ( count == 1 ) && ( ( res == '-' ) || ( res == '+' ) ); // [TODO] this only works for lines that actually end with '\n', other line endings // are not supported. if( ( cres == '\n' ) && ( mode == UART_READ_MODE_LINE ) ) break; if( !isdigit( (unsigned char) cres ) && !issign && ( mode == UART_READ_MODE_NUMBER ) ) break; if( isspace( (unsigned char) cres ) && ( mode == UART_READ_MODE_SPACE ) ) break; luaL_putchar( &b, cres ); if( ( count == maxsize ) && ( mode == UART_READ_MODE_MAXSIZE ) ) break; } luaL_pushresult( &b ); // Return an integer if needed if( mode == UART_READ_MODE_NUMBER ) { res = lua_tointeger( L, -1 ); lua_pop( L, 1 ); lua_pushinteger( L, res ); } return 1; }
int str_format_helper (luaL_Buffer* b, lua_State *L, int arg) { size_t sfl; const char *strfrmt = luaL_checklstring(L, arg, &sfl); const char *strfrmt_end = strfrmt+sfl; luaL_buffinit(L, b); while (strfrmt < strfrmt_end) { if (*strfrmt != '%') luaL_putchar(b, *strfrmt++); else if (*++strfrmt == '%') luaL_putchar(b, *strfrmt++); /* %% */ else { /* format item */ char form[MAX_FORMAT]; /* to store the format (`%...') */ char buff[MAX_ITEM]; /* to store the formatted item */ int hasprecision = 0; if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == '$') return luaL_error(L, "obsolete option (d$) to `format'"); arg++; strfrmt = scanformat(L, strfrmt, form, &hasprecision); switch (*strfrmt++) { case 'c': case 'd': case 'i': { sprintf(buff, form, luaL_checkint(L, arg)); break; } case 'o': case 'u': case 'x': case 'X': { sprintf(buff, form, (unsigned int)(luaL_checknumber(L, arg))); break; } case 'e': case 'E': case 'f': case 'g': case 'G': { sprintf(buff, form, luaL_checknumber(L, arg)); break; } case 'q': { luaI_addquoted(L, b, arg); continue; /* skip the `addsize' at the end */ } case 'Q': { luaI_addquotedbinary(L, b, arg); continue; /* skip the `addsize' at the end */ } case 's': { size_t l; const char *s = luaL_checklstring(L, arg, &l); if (!hasprecision && l >= 100) { /* no precision and string is too long to be formatted; keep original string */ lua_pushvalue(L, arg); luaL_addvalue(b); continue; /* skip the `addsize' at the end */ } else { sprintf(buff, form, s); break; } } case 'b': { buff[1] = buff[2] = buff[3] = buff[4] = buff[5] = buff[6] = buff[7] = buff[8] = 0; switch (*strfrmt++) { case 'b': { unsigned int num = (unsigned int)luaL_checkint(L, arg); buff[0] = (unsigned char)num; luaL_addlstring(b, buff, 1); break; } case 'd': { unsigned int num = (unsigned int)luaL_checkint(L, arg); *(unsigned int*)(&buff) = num; luaL_addlstring(b, buff, 4); break; } case 'w': { unsigned int num = (unsigned int)luaL_checkint(L, arg); *(unsigned short*)(&buff) = (unsigned short)num; luaL_addlstring(b, buff, 2); break; } case 'f': { float numF = (float)luaL_checknumber(L, arg); *(float*)(&buff) = numF; luaL_addlstring(b, buff, 4); break; } case 'F': { double numD = (double)luaL_checknumber(L, arg); *(double*)(&buff) = numD; luaL_addlstring(b, buff, 8); break; } default: break; } buff[0] = 0; break; } default: { /* also treat cases `pnLlh' */ return luaL_error(L, "invalid option to `format'"); } } luaL_addlstring(b, buff, strlen(buff)); } } return 1; }