/src/testdir/build/lua-master/source/lstrlib.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | ** $Id: lstrlib.c $ |
3 | | ** Standard library for string operations and pattern-matching |
4 | | ** See Copyright Notice in lua.h |
5 | | */ |
6 | | |
7 | | #define lstrlib_c |
8 | | #define LUA_LIB |
9 | | |
10 | | #include "lprefix.h" |
11 | | |
12 | | |
13 | | #include <ctype.h> |
14 | | #include <float.h> |
15 | | #include <limits.h> |
16 | | #include <locale.h> |
17 | | #include <math.h> |
18 | | #include <stddef.h> |
19 | | #include <stdio.h> |
20 | | #include <stdlib.h> |
21 | | #include <string.h> |
22 | | |
23 | | #include "lua.h" |
24 | | |
25 | | #include "lauxlib.h" |
26 | | #include "lualib.h" |
27 | | |
28 | | |
29 | | /* |
30 | | ** maximum number of captures that a pattern can do during |
31 | | ** pattern-matching. This limit is arbitrary, but must fit in |
32 | | ** an unsigned char. |
33 | | */ |
34 | | #if !defined(LUA_MAXCAPTURES) |
35 | 2.30M | #define LUA_MAXCAPTURES 32 |
36 | | #endif |
37 | | |
38 | | |
39 | | /* macro to 'unsign' a character */ |
40 | 498M | #define uchar(c) ((unsigned char)(c)) |
41 | | |
42 | | |
43 | | /* |
44 | | ** Some sizes are better limited to fit in 'int', but must also fit in |
45 | | ** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.) |
46 | | */ |
47 | 0 | #define MAX_SIZET ((size_t)(~(size_t)0)) |
48 | | |
49 | | #define MAXSIZE \ |
50 | 108k | (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX)) |
51 | | |
52 | | |
53 | | |
54 | | |
55 | 28 | static int str_len (lua_State *L) { |
56 | 28 | size_t l; |
57 | 28 | luaL_checklstring(L, 1, &l); |
58 | 28 | lua_pushinteger(L, (lua_Integer)l); |
59 | 28 | return 1; |
60 | 28 | } |
61 | | |
62 | | |
63 | | /* |
64 | | ** translate a relative initial string position |
65 | | ** (negative means back from end): clip result to [1, inf). |
66 | | ** The length of any string in Lua must fit in a lua_Integer, |
67 | | ** so there are no overflows in the casts. |
68 | | ** The inverted comparison avoids a possible overflow |
69 | | ** computing '-pos'. |
70 | | */ |
71 | 20.8k | static size_t posrelatI (lua_Integer pos, size_t len) { |
72 | 20.8k | if (pos > 0) |
73 | 17.4k | return (size_t)pos; |
74 | 3.30k | else if (pos == 0) |
75 | 2.61k | return 1; |
76 | 691 | else if (pos < -(lua_Integer)len) /* inverted comparison */ |
77 | 569 | return 1; /* clip to 1 */ |
78 | 122 | else return len + (size_t)pos + 1; |
79 | 20.8k | } |
80 | | |
81 | | |
82 | | /* |
83 | | ** Gets an optional ending string position from argument 'arg', |
84 | | ** with default value 'def'. |
85 | | ** Negative means back from end: clip result to [0, len] |
86 | | */ |
87 | | static size_t getendpos (lua_State *L, int arg, lua_Integer def, |
88 | 12.1k | size_t len) { |
89 | 12.1k | lua_Integer pos = luaL_optinteger(L, arg, def); |
90 | 12.1k | if (pos > (lua_Integer)len) |
91 | 201 | return len; |
92 | 11.9k | else if (pos >= 0) |
93 | 1.20k | return (size_t)pos; |
94 | 10.7k | else if (pos < -(lua_Integer)len) |
95 | 2.58k | return 0; |
96 | 8.18k | else return len + (size_t)pos + 1; |
97 | 12.1k | } |
98 | | |
99 | | |
100 | 823 | static int str_sub (lua_State *L) { |
101 | 823 | size_t l; |
102 | 823 | const char *s = luaL_checklstring(L, 1, &l); |
103 | 823 | size_t start = posrelatI(luaL_checkinteger(L, 2), l); |
104 | 823 | size_t end = getendpos(L, 3, -1, l); |
105 | 823 | if (start <= end) |
106 | 197 | lua_pushlstring(L, s + start - 1, (end - start) + 1); |
107 | 626 | else lua_pushliteral(L, ""); |
108 | 823 | return 1; |
109 | 823 | } |
110 | | |
111 | | |
112 | 4.88k | static int str_reverse (lua_State *L) { |
113 | 4.88k | size_t l, i; |
114 | 4.88k | luaL_Buffer b; |
115 | 4.88k | const char *s = luaL_checklstring(L, 1, &l); |
116 | 4.88k | char *p = luaL_buffinitsize(L, &b, l); |
117 | 3.94M | for (i = 0; i < l; i++) |
118 | 3.93M | p[i] = s[l - i - 1]; |
119 | 4.88k | luaL_pushresultsize(&b, l); |
120 | 4.88k | return 1; |
121 | 4.88k | } |
122 | | |
123 | | |
124 | 957 | static int str_lower (lua_State *L) { |
125 | 957 | size_t l; |
126 | 957 | size_t i; |
127 | 957 | luaL_Buffer b; |
128 | 957 | const char *s = luaL_checklstring(L, 1, &l); |
129 | 957 | char *p = luaL_buffinitsize(L, &b, l); |
130 | 260k | for (i=0; i<l; i++) |
131 | 259k | p[i] = tolower(uchar(s[i])); |
132 | 957 | luaL_pushresultsize(&b, l); |
133 | 957 | return 1; |
134 | 957 | } |
135 | | |
136 | | |
137 | 62 | static int str_upper (lua_State *L) { |
138 | 62 | size_t l; |
139 | 62 | size_t i; |
140 | 62 | luaL_Buffer b; |
141 | 62 | const char *s = luaL_checklstring(L, 1, &l); |
142 | 62 | char *p = luaL_buffinitsize(L, &b, l); |
143 | 287k | for (i=0; i<l; i++) |
144 | 287k | p[i] = toupper(uchar(s[i])); |
145 | 62 | luaL_pushresultsize(&b, l); |
146 | 62 | return 1; |
147 | 62 | } |
148 | | |
149 | | |
150 | 17.1k | static int str_rep (lua_State *L) { |
151 | 17.1k | size_t l, lsep; |
152 | 17.1k | const char *s = luaL_checklstring(L, 1, &l); |
153 | 17.1k | lua_Integer n = luaL_checkinteger(L, 2); |
154 | 17.1k | const char *sep = luaL_optlstring(L, 3, "", &lsep); |
155 | 17.1k | if (n <= 0) |
156 | 131 | lua_pushliteral(L, ""); |
157 | 17.0k | else if (l_unlikely(l + lsep < l || l + lsep > MAXSIZE / n)) |
158 | 3 | return luaL_error(L, "resulting string too large"); |
159 | 17.0k | else { |
160 | 17.0k | size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep; |
161 | 17.0k | luaL_Buffer b; |
162 | 17.0k | char *p = luaL_buffinitsize(L, &b, totallen); |
163 | 29.1M | while (n-- > 1) { /* first n-1 copies (followed by separator) */ |
164 | 29.0M | memcpy(p, s, l * sizeof(char)); p += l; |
165 | 29.0M | if (lsep > 0) { /* empty 'memcpy' is not that cheap */ |
166 | 16.3M | memcpy(p, sep, lsep * sizeof(char)); |
167 | 16.3M | p += lsep; |
168 | 16.3M | } |
169 | 29.0M | } |
170 | 17.0k | memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */ |
171 | 17.0k | luaL_pushresultsize(&b, totallen); |
172 | 17.0k | } |
173 | 17.1k | return 1; |
174 | 17.1k | } |
175 | | |
176 | | |
177 | 11.3k | static int str_byte (lua_State *L) { |
178 | 11.3k | size_t l; |
179 | 11.3k | const char *s = luaL_checklstring(L, 1, &l); |
180 | 11.3k | lua_Integer pi = luaL_optinteger(L, 2, 1); |
181 | 11.3k | size_t posi = posrelatI(pi, l); |
182 | 11.3k | size_t pose = getendpos(L, 3, pi, l); |
183 | 11.3k | int n, i; |
184 | 11.3k | if (posi > pose) return 0; /* empty interval; return no values */ |
185 | 8.40k | if (l_unlikely(pose - posi >= (size_t)INT_MAX)) /* arithmetic overflow? */ |
186 | 0 | return luaL_error(L, "string slice too long"); |
187 | 8.40k | n = (int)(pose - posi) + 1; |
188 | 8.40k | luaL_checkstack(L, n, "string slice too long"); |
189 | 430M | for (i=0; i<n; i++) |
190 | 430M | lua_pushinteger(L, uchar(s[posi+i-1])); |
191 | 8.40k | return n; |
192 | 8.40k | } |
193 | | |
194 | | |
195 | 68 | static int str_char (lua_State *L) { |
196 | 68 | int n = lua_gettop(L); /* number of arguments */ |
197 | 68 | int i; |
198 | 68 | luaL_Buffer b; |
199 | 68 | char *p = luaL_buffinitsize(L, &b, n); |
200 | 136 | for (i=1; i<=n; i++) { |
201 | 68 | lua_Unsigned c = (lua_Unsigned)luaL_checkinteger(L, i); |
202 | 68 | luaL_argcheck(L, c <= (lua_Unsigned)UCHAR_MAX, i, "value out of range"); |
203 | 68 | p[i - 1] = uchar(c); |
204 | 68 | } |
205 | 68 | luaL_pushresultsize(&b, n); |
206 | 68 | return 1; |
207 | 68 | } |
208 | | |
209 | | |
210 | | /* |
211 | | ** Buffer to store the result of 'string.dump'. It must be initialized |
212 | | ** after the call to 'lua_dump', to ensure that the function is on the |
213 | | ** top of the stack when 'lua_dump' is called. ('luaL_buffinit' might |
214 | | ** push stuff.) |
215 | | */ |
216 | | struct str_Writer { |
217 | | int init; /* true iff buffer has been initialized */ |
218 | | luaL_Buffer B; |
219 | | }; |
220 | | |
221 | | |
222 | 1.83M | static int writer (lua_State *L, const void *b, size_t size, void *ud) { |
223 | 1.83M | struct str_Writer *state = (struct str_Writer *)ud; |
224 | 1.83M | if (!state->init) { |
225 | 2.42k | state->init = 1; |
226 | 2.42k | luaL_buffinit(L, &state->B); |
227 | 2.42k | } |
228 | 1.83M | luaL_addlstring(&state->B, (const char *)b, size); |
229 | 1.83M | return 0; |
230 | 1.83M | } |
231 | | |
232 | | |
233 | 2.42k | static int str_dump (lua_State *L) { |
234 | 2.42k | struct str_Writer state; |
235 | 2.42k | int strip = lua_toboolean(L, 2); |
236 | 2.42k | luaL_checktype(L, 1, LUA_TFUNCTION); |
237 | 2.42k | lua_settop(L, 1); /* ensure function is on the top of the stack */ |
238 | 2.42k | state.init = 0; |
239 | 2.42k | if (l_unlikely(lua_dump(L, writer, &state, strip) != 0)) |
240 | 0 | return luaL_error(L, "unable to dump given function"); |
241 | 2.42k | luaL_pushresult(&state.B); |
242 | 2.42k | return 1; |
243 | 2.42k | } |
244 | | |
245 | | |
246 | | |
247 | | /* |
248 | | ** {====================================================== |
249 | | ** METAMETHODS |
250 | | ** ======================================================= |
251 | | */ |
252 | | |
253 | | #if defined(LUA_NOCVTS2N) /* { */ |
254 | | |
255 | | /* no coercion from strings to numbers */ |
256 | | |
257 | | static const luaL_Reg stringmetamethods[] = { |
258 | | {"__index", NULL}, /* placeholder */ |
259 | | {NULL, NULL} |
260 | | }; |
261 | | |
262 | | #else /* }{ */ |
263 | | |
264 | 2.05M | static int tonum (lua_State *L, int arg) { |
265 | 2.05M | if (lua_type(L, arg) == LUA_TNUMBER) { /* already a number? */ |
266 | 1.02M | lua_pushvalue(L, arg); |
267 | 1.02M | return 1; |
268 | 1.02M | } |
269 | 1.02M | else { /* check whether it is a numerical string */ |
270 | 1.02M | size_t len; |
271 | 1.02M | const char *s = lua_tolstring(L, arg, &len); |
272 | 1.02M | return (s != NULL && lua_stringtonumber(L, s) == len + 1); |
273 | 1.02M | } |
274 | 2.05M | } |
275 | | |
276 | | |
277 | 100 | static void trymt (lua_State *L, const char *mtname) { |
278 | 100 | lua_settop(L, 2); /* back to the original arguments */ |
279 | 100 | if (l_unlikely(lua_type(L, 2) == LUA_TSTRING || |
280 | 100 | !luaL_getmetafield(L, 2, mtname))) |
281 | 100 | luaL_error(L, "attempt to %s a '%s' with a '%s'", mtname + 2, |
282 | 100 | luaL_typename(L, -2), luaL_typename(L, -1)); |
283 | 100 | lua_insert(L, -3); /* put metamethod before arguments */ |
284 | 100 | lua_call(L, 2, 1); /* call metamethod */ |
285 | 100 | } |
286 | | |
287 | | |
288 | 1.02M | static int arith (lua_State *L, int op, const char *mtname) { |
289 | 1.02M | if (tonum(L, 1) && tonum(L, 2)) |
290 | 1.02M | lua_arith(L, op); /* result will be on the top */ |
291 | 100 | else |
292 | 100 | trymt(L, mtname); |
293 | 1.02M | return 1; |
294 | 1.02M | } |
295 | | |
296 | | |
297 | 3.57k | static int arith_add (lua_State *L) { |
298 | 3.57k | return arith(L, LUA_OPADD, "__add"); |
299 | 3.57k | } |
300 | | |
301 | 2.49k | static int arith_sub (lua_State *L) { |
302 | 2.49k | return arith(L, LUA_OPSUB, "__sub"); |
303 | 2.49k | } |
304 | | |
305 | 1.77k | static int arith_mul (lua_State *L) { |
306 | 1.77k | return arith(L, LUA_OPMUL, "__mul"); |
307 | 1.77k | } |
308 | | |
309 | 1.55k | static int arith_mod (lua_State *L) { |
310 | 1.55k | return arith(L, LUA_OPMOD, "__mod"); |
311 | 1.55k | } |
312 | | |
313 | 1.01M | static int arith_pow (lua_State *L) { |
314 | 1.01M | return arith(L, LUA_OPPOW, "__pow"); |
315 | 1.01M | } |
316 | | |
317 | 85 | static int arith_div (lua_State *L) { |
318 | 85 | return arith(L, LUA_OPDIV, "__div"); |
319 | 85 | } |
320 | | |
321 | 383 | static int arith_idiv (lua_State *L) { |
322 | 383 | return arith(L, LUA_OPIDIV, "__idiv"); |
323 | 383 | } |
324 | | |
325 | 317 | static int arith_unm (lua_State *L) { |
326 | 317 | return arith(L, LUA_OPUNM, "__unm"); |
327 | 317 | } |
328 | | |
329 | | |
330 | | static const luaL_Reg stringmetamethods[] = { |
331 | | {"__add", arith_add}, |
332 | | {"__sub", arith_sub}, |
333 | | {"__mul", arith_mul}, |
334 | | {"__mod", arith_mod}, |
335 | | {"__pow", arith_pow}, |
336 | | {"__div", arith_div}, |
337 | | {"__idiv", arith_idiv}, |
338 | | {"__unm", arith_unm}, |
339 | | {"__index", NULL}, /* placeholder */ |
340 | | {NULL, NULL} |
341 | | }; |
342 | | |
343 | | #endif /* } */ |
344 | | |
345 | | /* }====================================================== */ |
346 | | |
347 | | /* |
348 | | ** {====================================================== |
349 | | ** PATTERN MATCHING |
350 | | ** ======================================================= |
351 | | */ |
352 | | |
353 | | |
354 | 3.71M | #define CAP_UNFINISHED (-1) |
355 | 465k | #define CAP_POSITION (-2) |
356 | | |
357 | | |
358 | | typedef struct MatchState { |
359 | | const char *src_init; /* init of source string */ |
360 | | const char *src_end; /* end ('\0') of source string */ |
361 | | const char *p_end; /* end ('\0') of pattern */ |
362 | | lua_State *L; |
363 | | int matchdepth; /* control for recursive depth (to avoid C stack overflow) */ |
364 | | unsigned char level; /* total number of captures (finished or unfinished) */ |
365 | | struct { |
366 | | const char *init; |
367 | | ptrdiff_t len; |
368 | | } capture[LUA_MAXCAPTURES]; |
369 | | } MatchState; |
370 | | |
371 | | |
372 | | /* recursive function */ |
373 | | static const char *match (MatchState *ms, const char *s, const char *p); |
374 | | |
375 | | |
376 | | /* maximum recursion depth for 'match' */ |
377 | | #if !defined(MAXCCALLS) |
378 | 5.57k | #define MAXCCALLS 200 |
379 | | #endif |
380 | | |
381 | | |
382 | 219M | #define L_ESC '%' |
383 | 39.4k | #define SPECIALS "^$*+?.([%-" |
384 | | |
385 | | |
386 | 428k | static int check_capture (MatchState *ms, int l) { |
387 | 428k | l -= '1'; |
388 | 428k | if (l_unlikely(l < 0 || l >= ms->level || |
389 | 428k | ms->capture[l].len == CAP_UNFINISHED)) |
390 | 0 | return luaL_error(ms->L, "invalid capture index %%%d", l + 1); |
391 | 428k | return l; |
392 | 428k | } |
393 | | |
394 | | |
395 | 637k | static int capture_to_close (MatchState *ms) { |
396 | 637k | int level = ms->level; |
397 | 1.22M | for (level--; level>=0; level--) |
398 | 1.22M | if (ms->capture[level].len == CAP_UNFINISHED) return level; |
399 | 0 | return luaL_error(ms->L, "invalid pattern capture"); |
400 | 637k | } |
401 | | |
402 | | |
403 | 31.5M | static const char *classend (MatchState *ms, const char *p) { |
404 | 31.5M | switch (*p++) { |
405 | 1.22k | case L_ESC: { |
406 | 1.22k | if (l_unlikely(p == ms->p_end)) |
407 | 0 | luaL_error(ms->L, "malformed pattern (ends with '%%')"); |
408 | 1.22k | return p+1; |
409 | 0 | } |
410 | 526k | case '[': { |
411 | 526k | if (*p == '^') p++; |
412 | 106M | do { /* look for a ']' */ |
413 | 106M | if (l_unlikely(p == ms->p_end)) |
414 | 7 | luaL_error(ms->L, "malformed pattern (missing ']')"); |
415 | 106M | if (*(p++) == L_ESC && p < ms->p_end) |
416 | 31.8k | p++; /* skip escapes (e.g. '%]') */ |
417 | 106M | } while (*p != ']'); |
418 | 526k | return p+1; |
419 | 0 | } |
420 | 31.0M | default: { |
421 | 31.0M | return p; |
422 | 0 | } |
423 | 31.5M | } |
424 | 31.5M | } |
425 | | |
426 | | |
427 | 17.8k | static int match_class (int c, int cl) { |
428 | 17.8k | int res; |
429 | 17.8k | switch (tolower(cl)) { |
430 | 0 | case 'a' : res = isalpha(c); break; |
431 | 0 | case 'c' : res = iscntrl(c); break; |
432 | 0 | case 'd' : res = isdigit(c); break; |
433 | 0 | case 'g' : res = isgraph(c); break; |
434 | 0 | case 'l' : res = islower(c); break; |
435 | 0 | case 'p' : res = ispunct(c); break; |
436 | 0 | case 's' : res = isspace(c); break; |
437 | 126 | case 'u' : res = isupper(c); break; |
438 | 1.08k | case 'w' : res = isalnum(c); break; |
439 | 0 | case 'x' : res = isxdigit(c); break; |
440 | 0 | case 'z' : res = (c == 0); break; /* deprecated option */ |
441 | 16.6k | default: return (cl == c); |
442 | 17.8k | } |
443 | 1.21k | return (islower(cl) ? res : !res); |
444 | 17.8k | } |
445 | | |
446 | | |
447 | 534k | static int matchbracketclass (int c, const char *p, const char *ec) { |
448 | 534k | int sig = 1; |
449 | 534k | if (*(p+1) == '^') { |
450 | 69.8k | sig = 0; |
451 | 69.8k | p++; /* skip the '^' */ |
452 | 69.8k | } |
453 | 5.33M | while (++p < ec) { |
454 | 5.28M | if (*p == L_ESC) { |
455 | 16.3k | p++; |
456 | 16.3k | if (match_class(c, uchar(*p))) |
457 | 3.03k | return sig; |
458 | 16.3k | } |
459 | 5.26M | else if ((*(p+1) == '-') && (p+2 < ec)) { |
460 | 492k | p+=2; |
461 | 492k | if (uchar(*(p-2)) <= c && c <= uchar(*p)) |
462 | 402k | return sig; |
463 | 492k | } |
464 | 4.77M | else if (uchar(*p) == c) return sig; |
465 | 5.28M | } |
466 | 56.8k | return !sig; |
467 | 534k | } |
468 | | |
469 | | |
470 | | static int singlematch (MatchState *ms, const char *s, const char *p, |
471 | 32.1M | const char *ep) { |
472 | 32.1M | if (s >= ms->src_end) |
473 | 130k | return 0; |
474 | 31.9M | else { |
475 | 31.9M | int c = uchar(*s); |
476 | 31.9M | switch (*p) { |
477 | 1.34M | case '.': return 1; /* matches any char */ |
478 | 1.46k | case L_ESC: return match_class(c, uchar(*(p+1))); |
479 | 525k | case '[': return matchbracketclass(c, p, ep-1); |
480 | 30.1M | default: return (uchar(*p) == c); |
481 | 31.9M | } |
482 | 31.9M | } |
483 | 32.1M | } |
484 | | |
485 | | |
486 | | static const char *matchbalance (MatchState *ms, const char *s, |
487 | 77.2k | const char *p) { |
488 | 77.2k | if (l_unlikely(p >= ms->p_end - 1)) |
489 | 0 | luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')"); |
490 | 77.2k | if (*s != *p) return NULL; |
491 | 15.7k | else { |
492 | 15.7k | int b = *p; |
493 | 15.7k | int e = *(p+1); |
494 | 15.7k | int cont = 1; |
495 | 285M | while (++s < ms->src_end) { |
496 | 285M | if (*s == e) { |
497 | 15.6k | if (--cont == 0) return s+1; |
498 | 15.6k | } |
499 | 285M | else if (*s == b) cont++; |
500 | 285M | } |
501 | 15.7k | } |
502 | 15.7k | return NULL; /* string ends out of balance */ |
503 | 77.2k | } |
504 | | |
505 | | |
506 | | static const char *max_expand (MatchState *ms, const char *s, |
507 | 2.67k | const char *p, const char *ep) { |
508 | 2.67k | ptrdiff_t i = 0; /* counts maximum expand for item */ |
509 | 118k | while (singlematch(ms, s + i, p, ep)) |
510 | 115k | i++; |
511 | | /* keeps trying to match with the maximum repetitions */ |
512 | 117k | while (i>=0) { |
513 | 116k | const char *res = match(ms, (s+i), ep+1); |
514 | 116k | if (res) return res; |
515 | 114k | i--; /* else didn't match; reduce 1 repetition to try again */ |
516 | 114k | } |
517 | 864 | return NULL; |
518 | 2.67k | } |
519 | | |
520 | | |
521 | | static const char *min_expand (MatchState *ms, const char *s, |
522 | 59.0k | const char *p, const char *ep) { |
523 | 473k | for (;;) { |
524 | 473k | const char *res = match(ms, s, ep+1); |
525 | 473k | if (res != NULL) |
526 | 136 | return res; |
527 | 473k | else if (singlematch(ms, s, p, ep)) |
528 | 414k | s++; /* try with one more repetition */ |
529 | 58.9k | else return NULL; |
530 | 473k | } |
531 | 59.0k | } |
532 | | |
533 | | |
534 | | static const char *start_capture (MatchState *ms, const char *s, |
535 | 2.30M | const char *p, int what) { |
536 | 2.30M | const char *res; |
537 | 2.30M | int level = ms->level; |
538 | 2.30M | if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures"); |
539 | 2.30M | ms->capture[level].init = s; |
540 | 2.30M | ms->capture[level].len = what; |
541 | 2.30M | ms->level = level+1; |
542 | 2.30M | if ((res=match(ms, s, p)) == NULL) /* match failed? */ |
543 | 2.30M | ms->level--; /* undo capture */ |
544 | 2.30M | return res; |
545 | 2.30M | } |
546 | | |
547 | | |
548 | | static const char *end_capture (MatchState *ms, const char *s, |
549 | 637k | const char *p) { |
550 | 637k | int l = capture_to_close(ms); |
551 | 637k | const char *res; |
552 | 637k | ms->capture[l].len = s - ms->capture[l].init; /* close capture */ |
553 | 637k | if ((res = match(ms, s, p)) == NULL) /* match failed? */ |
554 | 636k | ms->capture[l].len = CAP_UNFINISHED; /* undo capture */ |
555 | 637k | return res; |
556 | 637k | } |
557 | | |
558 | | |
559 | 428k | static const char *match_capture (MatchState *ms, const char *s, int l) { |
560 | 428k | size_t len; |
561 | 428k | l = check_capture(ms, l); |
562 | 428k | len = ms->capture[l].len; |
563 | 428k | if ((size_t)(ms->src_end-s) >= len && |
564 | 428k | memcmp(ms->capture[l].init, s, len) == 0) |
565 | 19.0k | return s+len; |
566 | 409k | else return NULL; |
567 | 428k | } |
568 | | |
569 | | |
570 | 5.99M | static const char *match (MatchState *ms, const char *s, const char *p) { |
571 | 5.99M | if (l_unlikely(ms->matchdepth-- == 0)) |
572 | 0 | luaL_error(ms->L, "pattern too complex"); |
573 | 35.0M | init: /* using goto to optimize tail recursion */ |
574 | 35.0M | if (p != ms->p_end) { /* end of pattern? */ |
575 | 34.9M | switch (*p) { |
576 | 2.30M | case '(': { /* start capture */ |
577 | 2.30M | if (*(p + 1) == ')') /* position capture? */ |
578 | 460k | s = start_capture(ms, s, p + 2, CAP_POSITION); |
579 | 1.84M | else |
580 | 1.84M | s = start_capture(ms, s, p + 1, CAP_UNFINISHED); |
581 | 2.30M | break; |
582 | 0 | } |
583 | 637k | case ')': { /* end capture */ |
584 | 637k | s = end_capture(ms, s, p + 1); |
585 | 637k | break; |
586 | 0 | } |
587 | 13.9k | case '$': { |
588 | 13.9k | if ((p + 1) != ms->p_end) /* is the '$' the last char in pattern? */ |
589 | 5.88k | goto dflt; /* no; go to default */ |
590 | 8.03k | s = (s == ms->src_end) ? s : NULL; /* check end of string */ |
591 | 8.03k | break; |
592 | 13.9k | } |
593 | 514k | case L_ESC: { /* escaped sequences not in the format class[*+?-]? */ |
594 | 514k | switch (*(p + 1)) { |
595 | 77.2k | case 'b': { /* balanced string? */ |
596 | 77.2k | s = matchbalance(ms, s, p + 2); |
597 | 77.2k | if (s != NULL) { |
598 | 14 | p += 4; goto init; /* return match(ms, s, p + 4); */ |
599 | 14 | } /* else fail (s == NULL) */ |
600 | 77.2k | break; |
601 | 77.2k | } |
602 | 77.2k | case 'f': { /* frontier? */ |
603 | 7.34k | const char *ep; char previous; |
604 | 7.34k | p += 2; |
605 | 7.34k | if (l_unlikely(*p != '[')) |
606 | 0 | luaL_error(ms->L, "missing '[' after '%%f' in pattern"); |
607 | 7.34k | ep = classend(ms, p); /* points to what is next */ |
608 | 7.34k | previous = (s == ms->src_init) ? '\0' : *(s - 1); |
609 | 7.34k | if (!matchbracketclass(uchar(previous), p, ep - 1) && |
610 | 7.34k | matchbracketclass(uchar(*s), p, ep - 1)) { |
611 | 819 | p = ep; goto init; /* return match(ms, s, ep); */ |
612 | 819 | } |
613 | 6.53k | s = NULL; /* match failed */ |
614 | 6.53k | break; |
615 | 7.34k | } |
616 | 19.0k | case '0': case '1': case '2': case '3': |
617 | 428k | case '4': case '5': case '6': case '7': |
618 | 428k | case '8': case '9': { /* capture results (%0-%9)? */ |
619 | 428k | s = match_capture(ms, s, uchar(*(p + 1))); |
620 | 428k | if (s != NULL) { |
621 | 19.0k | p += 2; goto init; /* return match(ms, s, p + 2) */ |
622 | 19.0k | } |
623 | 409k | break; |
624 | 428k | } |
625 | 409k | default: goto dflt; |
626 | 514k | } |
627 | 493k | break; |
628 | 514k | } |
629 | 31.5M | default: dflt: { /* pattern class plus optional suffix */ |
630 | 31.5M | const char *ep = classend(ms, p); /* points to optional suffix */ |
631 | | /* does not match at least once? */ |
632 | 31.5M | if (!singlematch(ms, s, p, ep)) { |
633 | 2.88M | if (*ep == '*' || *ep == '?' || *ep == '-') { /* accept empty? */ |
634 | 403k | p = ep + 1; goto init; /* return match(ms, s, ep + 1); */ |
635 | 403k | } |
636 | 2.48M | else /* '+' or no suffix */ |
637 | 2.48M | s = NULL; /* fail */ |
638 | 2.88M | } |
639 | 28.6M | else { /* matched once */ |
640 | 28.6M | switch (*ep) { /* handle optional suffix */ |
641 | 0 | case '?': { /* optional */ |
642 | 0 | const char *res; |
643 | 0 | if ((res = match(ms, s + 1, ep + 1)) != NULL) |
644 | 0 | s = res; |
645 | 0 | else { |
646 | 0 | p = ep + 1; goto init; /* else return match(ms, s, ep + 1); */ |
647 | 0 | } |
648 | 0 | break; |
649 | 0 | } |
650 | 1.81k | case '+': /* 1 or more repetitions */ |
651 | 1.81k | s++; /* 1 match already done */ |
652 | | /* FALLTHROUGH */ |
653 | 2.67k | case '*': /* 0 or more repetitions */ |
654 | 2.67k | s = max_expand(ms, s, p, ep); |
655 | 2.67k | break; |
656 | 59.0k | case '-': /* 0 or more repetitions (minimum) */ |
657 | 59.0k | s = min_expand(ms, s, p, ep); |
658 | 59.0k | break; |
659 | 28.5M | default: /* no suffix */ |
660 | 28.5M | s++; p = ep; goto init; /* return match(ms, s + 1, ep); */ |
661 | 28.6M | } |
662 | 28.6M | } |
663 | 2.54M | break; |
664 | 31.5M | } |
665 | 34.9M | } |
666 | 34.9M | } |
667 | 5.99M | ms->matchdepth++; |
668 | 5.99M | return s; |
669 | 35.0M | } |
670 | | |
671 | | |
672 | | |
673 | | static const char *lmemfind (const char *s1, size_t l1, |
674 | 3.12k | const char *s2, size_t l2) { |
675 | 3.12k | if (l2 == 0) return s1; /* empty strings are everywhere */ |
676 | 3.08k | else if (l2 > l1) return NULL; /* avoids a negative 'l1' */ |
677 | 1.31k | else { |
678 | 1.31k | const char *init; /* to search for a '*s2' inside 's1' */ |
679 | 1.31k | l2--; /* 1st char will be checked by 'memchr' */ |
680 | 1.31k | l1 = l1-l2; /* 's2' cannot be found after that */ |
681 | 79.1k | while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { |
682 | 78.0k | init++; /* 1st char is already checked */ |
683 | 78.0k | if (memcmp(init, s2+1, l2) == 0) |
684 | 286 | return init-1; |
685 | 77.7k | else { /* correct 'l1' and 's1' to try again */ |
686 | 77.7k | l1 -= init-s1; |
687 | 77.7k | s1 = init; |
688 | 77.7k | } |
689 | 78.0k | } |
690 | 1.03k | return NULL; /* not found */ |
691 | 1.31k | } |
692 | 3.12k | } |
693 | | |
694 | | |
695 | | /* |
696 | | ** get information about the i-th capture. If there are no captures |
697 | | ** and 'i==0', return information about the whole match, which |
698 | | ** is the range 's'..'e'. If the capture is a string, return |
699 | | ** its length and put its address in '*cap'. If it is an integer |
700 | | ** (a position), push it on the stack and return CAP_POSITION. |
701 | | */ |
702 | | static size_t get_onecapture (MatchState *ms, int i, const char *s, |
703 | 3.70k | const char *e, const char **cap) { |
704 | 3.70k | if (i >= ms->level) { |
705 | 3.09k | if (l_unlikely(i != 0)) |
706 | 0 | luaL_error(ms->L, "invalid capture index %%%d", i + 1); |
707 | 3.09k | *cap = s; |
708 | 3.09k | return e - s; |
709 | 3.09k | } |
710 | 610 | else { |
711 | 610 | ptrdiff_t capl = ms->capture[i].len; |
712 | 610 | *cap = ms->capture[i].init; |
713 | 610 | if (l_unlikely(capl == CAP_UNFINISHED)) |
714 | 3 | luaL_error(ms->L, "unfinished capture"); |
715 | 607 | else if (capl == CAP_POSITION) |
716 | 334 | lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1); |
717 | 610 | return capl; |
718 | 610 | } |
719 | 3.70k | } |
720 | | |
721 | | |
722 | | /* |
723 | | ** Push the i-th capture on the stack. |
724 | | */ |
725 | | static void push_onecapture (MatchState *ms, int i, const char *s, |
726 | 3.70k | const char *e) { |
727 | 3.70k | const char *cap; |
728 | 3.70k | ptrdiff_t l = get_onecapture(ms, i, s, e, &cap); |
729 | 3.70k | if (l != CAP_POSITION) |
730 | 3.36k | lua_pushlstring(ms->L, cap, l); |
731 | | /* else position was already pushed */ |
732 | 3.70k | } |
733 | | |
734 | | |
735 | 6.41k | static int push_captures (MatchState *ms, const char *s, const char *e) { |
736 | 6.41k | int i; |
737 | 6.41k | int nlevels = (ms->level == 0 && s) ? 1 : ms->level; |
738 | 6.41k | luaL_checkstack(ms->L, nlevels, "too many captures"); |
739 | 10.0k | for (i = 0; i < nlevels; i++) |
740 | 3.67k | push_onecapture(ms, i, s, e); |
741 | 6.41k | return nlevels; /* number of strings pushed */ |
742 | 6.41k | } |
743 | | |
744 | | |
745 | | /* check whether pattern has no special characters */ |
746 | 7.83k | static int nospecials (const char *p, size_t l) { |
747 | 7.83k | size_t upto = 0; |
748 | 39.4k | do { |
749 | 39.4k | if (strpbrk(p + upto, SPECIALS)) |
750 | 4.79k | return 0; /* pattern has a special character */ |
751 | 34.6k | upto += strlen(p + upto) + 1; /* may have more after \0 */ |
752 | 34.6k | } while (upto <= l); |
753 | 3.03k | return 1; /* no special chars found */ |
754 | 7.83k | } |
755 | | |
756 | | |
757 | | static void prepstate (MatchState *ms, lua_State *L, |
758 | 5.57k | const char *s, size_t ls, const char *p, size_t lp) { |
759 | 5.57k | ms->L = L; |
760 | 5.57k | ms->matchdepth = MAXCCALLS; |
761 | 5.57k | ms->src_init = s; |
762 | 5.57k | ms->src_end = s + ls; |
763 | 5.57k | ms->p_end = p + lp; |
764 | 5.57k | } |
765 | | |
766 | | |
767 | 2.46M | static void reprepstate (MatchState *ms) { |
768 | 2.46M | ms->level = 0; |
769 | 2.46M | lua_assert(ms->matchdepth == MAXCCALLS); |
770 | 2.46M | } |
771 | | |
772 | | |
773 | 7.91k | static int str_find_aux (lua_State *L, int find) { |
774 | 7.91k | size_t ls, lp; |
775 | 7.91k | const char *s = luaL_checklstring(L, 1, &ls); |
776 | 7.91k | const char *p = luaL_checklstring(L, 2, &lp); |
777 | 7.91k | size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1; |
778 | 7.91k | if (init > ls) { /* start after string's end? */ |
779 | 0 | luaL_pushfail(L); /* cannot find anything */ |
780 | 0 | return 1; |
781 | 0 | } |
782 | | /* explicit request or no special characters? */ |
783 | 7.91k | if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) { |
784 | | /* do a plain search */ |
785 | 3.12k | const char *s2 = lmemfind(s + init, ls - init, p, lp); |
786 | 3.12k | if (s2) { |
787 | 328 | lua_pushinteger(L, (s2 - s) + 1); |
788 | 328 | lua_pushinteger(L, (s2 - s) + lp); |
789 | 328 | return 2; |
790 | 328 | } |
791 | 3.12k | } |
792 | 4.79k | else { |
793 | 4.79k | MatchState ms; |
794 | 4.79k | const char *s1 = s + init; |
795 | 4.79k | int anchor = (*p == '^'); |
796 | 4.79k | if (anchor) { |
797 | 136 | p++; lp--; /* skip anchor character */ |
798 | 136 | } |
799 | 4.79k | prepstate(&ms, L, s, ls, p, lp); |
800 | 1.99M | do { |
801 | 1.99M | const char *res; |
802 | 1.99M | reprepstate(&ms); |
803 | 1.99M | if ((res=match(&ms, s1, p)) != NULL) { |
804 | 3.34k | if (find) { |
805 | 3.34k | lua_pushinteger(L, (s1 - s) + 1); /* start */ |
806 | 3.34k | lua_pushinteger(L, res - s); /* end */ |
807 | 3.34k | return push_captures(&ms, NULL, 0) + 2; |
808 | 3.34k | } |
809 | 0 | else |
810 | 0 | return push_captures(&ms, s1, res); |
811 | 3.34k | } |
812 | 1.99M | } while (s1++ < ms.src_end && !anchor); |
813 | 4.79k | } |
814 | 4.24k | luaL_pushfail(L); /* not found */ |
815 | 4.24k | return 1; |
816 | 7.91k | } |
817 | | |
818 | | |
819 | 7.91k | static int str_find (lua_State *L) { |
820 | 7.91k | return str_find_aux(L, 1); |
821 | 7.91k | } |
822 | | |
823 | | |
824 | 0 | static int str_match (lua_State *L) { |
825 | 0 | return str_find_aux(L, 0); |
826 | 0 | } |
827 | | |
828 | | |
829 | | /* state for 'gmatch' */ |
830 | | typedef struct GMatchState { |
831 | | const char *src; /* current position */ |
832 | | const char *p; /* pattern */ |
833 | | const char *lastmatch; /* end of last match */ |
834 | | MatchState ms; /* match state */ |
835 | | } GMatchState; |
836 | | |
837 | | |
838 | 3.05k | static int gmatch_aux (lua_State *L) { |
839 | 3.05k | GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3)); |
840 | 3.05k | const char *src; |
841 | 3.05k | gm->ms.L = L; |
842 | 6.12k | for (src = gm->src; src <= gm->ms.src_end; src++) { |
843 | 3.08k | const char *e; |
844 | 3.08k | reprepstate(&gm->ms); |
845 | 3.08k | if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) { |
846 | 13 | gm->src = gm->lastmatch = e; |
847 | 13 | return push_captures(&gm->ms, src, e); |
848 | 13 | } |
849 | 3.08k | } |
850 | 3.04k | return 0; /* not found */ |
851 | 3.05k | } |
852 | | |
853 | | |
854 | 682 | static int gmatch (lua_State *L) { |
855 | 682 | size_t ls, lp; |
856 | 682 | const char *s = luaL_checklstring(L, 1, &ls); |
857 | 682 | const char *p = luaL_checklstring(L, 2, &lp); |
858 | 682 | size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1; |
859 | 682 | GMatchState *gm; |
860 | 682 | lua_settop(L, 2); /* keep strings on closure to avoid being collected */ |
861 | 682 | gm = (GMatchState *)lua_newuserdatauv(L, sizeof(GMatchState), 0); |
862 | 682 | if (init > ls) /* start after string's end? */ |
863 | 32 | init = ls + 1; /* avoid overflows in 's + init' */ |
864 | 682 | prepstate(&gm->ms, L, s, ls, p, lp); |
865 | 682 | gm->src = s + init; gm->p = p; gm->lastmatch = NULL; |
866 | 682 | lua_pushcclosure(L, gmatch_aux, 3); |
867 | 682 | return 1; |
868 | 682 | } |
869 | | |
870 | | |
871 | | static void add_s (MatchState *ms, luaL_Buffer *b, const char *s, |
872 | 0 | const char *e) { |
873 | 0 | size_t l; |
874 | 0 | lua_State *L = ms->L; |
875 | 0 | const char *news = lua_tolstring(L, 3, &l); |
876 | 0 | const char *p; |
877 | 0 | while ((p = (char *)memchr(news, L_ESC, l)) != NULL) { |
878 | 0 | luaL_addlstring(b, news, p - news); |
879 | 0 | p++; /* skip ESC */ |
880 | 0 | if (*p == L_ESC) /* '%%' */ |
881 | 0 | luaL_addchar(b, *p); |
882 | 0 | else if (*p == '0') /* '%0' */ |
883 | 0 | luaL_addlstring(b, s, e - s); |
884 | 0 | else if (isdigit(uchar(*p))) { /* '%n' */ |
885 | 0 | const char *cap; |
886 | 0 | ptrdiff_t resl = get_onecapture(ms, *p - '1', s, e, &cap); |
887 | 0 | if (resl == CAP_POSITION) |
888 | 0 | luaL_addvalue(b); /* add position to accumulated result */ |
889 | 0 | else |
890 | 0 | luaL_addlstring(b, cap, resl); |
891 | 0 | } |
892 | 0 | else |
893 | 0 | luaL_error(L, "invalid use of '%c' in replacement string", L_ESC); |
894 | 0 | l -= p + 1 - news; |
895 | 0 | news = p + 1; |
896 | 0 | } |
897 | 0 | luaL_addlstring(b, news, l); |
898 | 0 | } |
899 | | |
900 | | |
901 | | /* |
902 | | ** Add the replacement value to the string buffer 'b'. |
903 | | ** Return true if the original string was changed. (Function calls and |
904 | | ** table indexing resulting in nil or false do not change the subject.) |
905 | | */ |
906 | | static int add_value (MatchState *ms, luaL_Buffer *b, const char *s, |
907 | 3.07k | const char *e, int tr) { |
908 | 3.07k | lua_State *L = ms->L; |
909 | 3.07k | switch (tr) { |
910 | 3.05k | case LUA_TFUNCTION: { /* call the function */ |
911 | 3.05k | int n; |
912 | 3.05k | lua_pushvalue(L, 3); /* push the function */ |
913 | 3.05k | n = push_captures(ms, s, e); /* all captures as arguments */ |
914 | 3.05k | lua_call(L, n, 1); /* call it */ |
915 | 3.05k | break; |
916 | 0 | } |
917 | 25 | case LUA_TTABLE: { /* index the table */ |
918 | 25 | push_onecapture(ms, 0, s, e); /* first capture is the index */ |
919 | 25 | lua_gettable(L, 3); |
920 | 25 | break; |
921 | 0 | } |
922 | 0 | default: { /* LUA_TNUMBER or LUA_TSTRING */ |
923 | 0 | add_s(ms, b, s, e); /* add value to the buffer */ |
924 | 0 | return 1; /* something changed */ |
925 | 0 | } |
926 | 3.07k | } |
927 | 3.07k | if (!lua_toboolean(L, -1)) { /* nil or false? */ |
928 | 3.07k | lua_pop(L, 1); /* remove value */ |
929 | 3.07k | luaL_addlstring(b, s, e - s); /* keep original text */ |
930 | 3.07k | return 0; /* no changes */ |
931 | 3.07k | } |
932 | 1 | else if (l_unlikely(!lua_isstring(L, -1))) |
933 | 0 | return luaL_error(L, "invalid replacement value (a %s)", |
934 | 0 | luaL_typename(L, -1)); |
935 | 1 | else { |
936 | 1 | luaL_addvalue(b); /* add result to accumulator */ |
937 | 1 | return 1; /* something changed */ |
938 | 1 | } |
939 | 3.07k | } |
940 | | |
941 | | |
942 | 98 | static int str_gsub (lua_State *L) { |
943 | 98 | size_t srcl, lp; |
944 | 98 | const char *src = luaL_checklstring(L, 1, &srcl); /* subject */ |
945 | 98 | const char *p = luaL_checklstring(L, 2, &lp); /* pattern */ |
946 | 98 | const char *lastmatch = NULL; /* end of last match */ |
947 | 98 | int tr = lua_type(L, 3); /* replacement type */ |
948 | 98 | lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1); /* max replacements */ |
949 | 98 | int anchor = (*p == '^'); |
950 | 98 | lua_Integer n = 0; /* replacement count */ |
951 | 98 | int changed = 0; /* change flag */ |
952 | 98 | MatchState ms; |
953 | 98 | luaL_Buffer b; |
954 | 98 | luaL_argexpected(L, tr == LUA_TNUMBER || tr == LUA_TSTRING || |
955 | 98 | tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3, |
956 | 98 | "string/function/table"); |
957 | 98 | luaL_buffinit(L, &b); |
958 | 98 | if (anchor) { |
959 | 0 | p++; lp--; /* skip anchor character */ |
960 | 0 | } |
961 | 98 | prepstate(&ms, L, src, srcl, p, lp); |
962 | 462k | while (n < max_s) { |
963 | 462k | const char *e; |
964 | 462k | reprepstate(&ms); /* (re)prepare state for new match */ |
965 | 462k | if ((e = match(&ms, src, p)) != NULL && e != lastmatch) { /* match? */ |
966 | 3.07k | n++; |
967 | 3.07k | changed = add_value(&ms, &b, src, e, tr) | changed; |
968 | 3.07k | src = lastmatch = e; |
969 | 3.07k | } |
970 | 459k | else if (src < ms.src_end) /* otherwise, skip one character */ |
971 | 459k | luaL_addchar(&b, *src++); |
972 | 90 | else break; /* end of subject */ |
973 | 462k | if (anchor) break; |
974 | 462k | } |
975 | 98 | if (!changed) /* no changes? */ |
976 | 89 | lua_pushvalue(L, 1); /* return original string */ |
977 | 9 | else { /* something changed */ |
978 | 9 | luaL_addlstring(&b, src, ms.src_end-src); |
979 | 9 | luaL_pushresult(&b); /* create and return new string */ |
980 | 9 | } |
981 | 98 | lua_pushinteger(L, n); /* number of substitutions */ |
982 | 98 | return 2; |
983 | 98 | } |
984 | | |
985 | | /* }====================================================== */ |
986 | | |
987 | | |
988 | | |
989 | | /* |
990 | | ** {====================================================== |
991 | | ** STRING FORMAT |
992 | | ** ======================================================= |
993 | | */ |
994 | | |
995 | | #if !defined(lua_number2strx) /* { */ |
996 | | |
997 | | /* |
998 | | ** Hexadecimal floating-point formatter |
999 | | */ |
1000 | | |
1001 | | #define SIZELENMOD (sizeof(LUA_NUMBER_FRMLEN)/sizeof(char)) |
1002 | | |
1003 | | |
1004 | | /* |
1005 | | ** Number of bits that goes into the first digit. It can be any value |
1006 | | ** between 1 and 4; the following definition tries to align the number |
1007 | | ** to nibble boundaries by making what is left after that first digit a |
1008 | | ** multiple of 4. |
1009 | | */ |
1010 | | #define L_NBFD ((l_floatatt(MANT_DIG) - 1)%4 + 1) |
1011 | | |
1012 | | |
1013 | | /* |
1014 | | ** Add integer part of 'x' to buffer and return new 'x' |
1015 | | */ |
1016 | | static lua_Number adddigit (char *buff, int n, lua_Number x) { |
1017 | | lua_Number dd = l_mathop(floor)(x); /* get integer part from 'x' */ |
1018 | | int d = (int)dd; |
1019 | | buff[n] = (d < 10 ? d + '0' : d - 10 + 'a'); /* add to buffer */ |
1020 | | return x - dd; /* return what is left */ |
1021 | | } |
1022 | | |
1023 | | |
1024 | | static int num2straux (char *buff, int sz, lua_Number x) { |
1025 | | /* if 'inf' or 'NaN', format it like '%g' */ |
1026 | | if (x != x || x == (lua_Number)HUGE_VAL || x == -(lua_Number)HUGE_VAL) |
1027 | | return l_sprintf(buff, sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)x); |
1028 | | else if (x == 0) { /* can be -0... */ |
1029 | | /* create "0" or "-0" followed by exponent */ |
1030 | | return l_sprintf(buff, sz, LUA_NUMBER_FMT "x0p+0", (LUAI_UACNUMBER)x); |
1031 | | } |
1032 | | else { |
1033 | | int e; |
1034 | | lua_Number m = l_mathop(frexp)(x, &e); /* 'x' fraction and exponent */ |
1035 | | int n = 0; /* character count */ |
1036 | | if (m < 0) { /* is number negative? */ |
1037 | | buff[n++] = '-'; /* add sign */ |
1038 | | m = -m; /* make it positive */ |
1039 | | } |
1040 | | buff[n++] = '0'; buff[n++] = 'x'; /* add "0x" */ |
1041 | | m = adddigit(buff, n++, m * (1 << L_NBFD)); /* add first digit */ |
1042 | | e -= L_NBFD; /* this digit goes before the radix point */ |
1043 | | if (m > 0) { /* more digits? */ |
1044 | | buff[n++] = lua_getlocaledecpoint(); /* add radix point */ |
1045 | | do { /* add as many digits as needed */ |
1046 | | m = adddigit(buff, n++, m * 16); |
1047 | | } while (m > 0); |
1048 | | } |
1049 | | n += l_sprintf(buff + n, sz - n, "p%+d", e); /* add exponent */ |
1050 | | lua_assert(n < sz); |
1051 | | return n; |
1052 | | } |
1053 | | } |
1054 | | |
1055 | | |
1056 | | static int lua_number2strx (lua_State *L, char *buff, int sz, |
1057 | | const char *fmt, lua_Number x) { |
1058 | | int n = num2straux(buff, sz, x); |
1059 | | if (fmt[SIZELENMOD] == 'A') { |
1060 | | int i; |
1061 | | for (i = 0; i < n; i++) |
1062 | | buff[i] = toupper(uchar(buff[i])); |
1063 | | } |
1064 | | else if (l_unlikely(fmt[SIZELENMOD] != 'a')) |
1065 | | return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented"); |
1066 | | return n; |
1067 | | } |
1068 | | |
1069 | | #endif /* } */ |
1070 | | |
1071 | | |
1072 | | /* |
1073 | | ** Maximum size for items formatted with '%f'. This size is produced |
1074 | | ** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.', |
1075 | | ** and '\0') + number of decimal digits to represent maxfloat (which |
1076 | | ** is maximum exponent + 1). (99+3+1, adding some extra, 110) |
1077 | | */ |
1078 | 8 | #define MAX_ITEMF (110 + l_floatatt(MAX_10_EXP)) |
1079 | | |
1080 | | |
1081 | | /* |
1082 | | ** All formats except '%f' do not need that large limit. The other |
1083 | | ** float formats use exponents, so that they fit in the 99 limit for |
1084 | | ** significant digits; 's' for large strings and 'q' add items directly |
1085 | | ** to the buffer; all integer formats also fit in the 99 limit. The |
1086 | | ** worst case are floats: they may need 99 significant digits, plus |
1087 | | ** '0x', '-', '.', 'e+XXXX', and '\0'. Adding some extra, 120. |
1088 | | */ |
1089 | 70 | #define MAX_ITEM 120 |
1090 | | |
1091 | | |
1092 | | /* valid flags in a format specification */ |
1093 | | #if !defined(L_FMTFLAGSF) |
1094 | | |
1095 | | /* valid flags for a, A, e, E, f, F, g, and G conversions */ |
1096 | 115 | #define L_FMTFLAGSF "-+#0 " |
1097 | | |
1098 | | /* valid flags for o, x, and X conversions */ |
1099 | 3 | #define L_FMTFLAGSX "-#0" |
1100 | | |
1101 | | /* valid flags for d and i conversions */ |
1102 | 2 | #define L_FMTFLAGSI "-+0 " |
1103 | | |
1104 | | /* valid flags for u conversions */ |
1105 | 2 | #define L_FMTFLAGSU "-0" |
1106 | | |
1107 | | /* valid flags for c, p, and s conversions */ |
1108 | 3 | #define L_FMTFLAGSC "-" |
1109 | | |
1110 | | #endif |
1111 | | |
1112 | | |
1113 | | /* |
1114 | | ** Maximum size of each format specification (such as "%-099.99d"): |
1115 | | ** Initial '%', flags (up to 5), width (2), period, precision (2), |
1116 | | ** length modifier (8), conversion specifier, and final '\0', plus some |
1117 | | ** extra. |
1118 | | */ |
1119 | 68 | #define MAX_FORMAT 32 |
1120 | | |
1121 | | |
1122 | 2 | static void addquoted (luaL_Buffer *b, const char *s, size_t len) { |
1123 | 2 | luaL_addchar(b, '"'); |
1124 | 10 | while (len--) { |
1125 | 8 | if (*s == '"' || *s == '\\' || *s == '\n') { |
1126 | 0 | luaL_addchar(b, '\\'); |
1127 | 0 | luaL_addchar(b, *s); |
1128 | 0 | } |
1129 | 8 | else if (iscntrl(uchar(*s))) { |
1130 | 0 | char buff[10]; |
1131 | 0 | if (!isdigit(uchar(*(s+1)))) |
1132 | 0 | l_sprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s)); |
1133 | 0 | else |
1134 | 0 | l_sprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s)); |
1135 | 0 | luaL_addstring(b, buff); |
1136 | 0 | } |
1137 | 8 | else |
1138 | 8 | luaL_addchar(b, *s); |
1139 | 8 | s++; |
1140 | 8 | } |
1141 | 2 | luaL_addchar(b, '"'); |
1142 | 2 | } |
1143 | | |
1144 | | |
1145 | | /* |
1146 | | ** Serialize a floating-point number in such a way that it can be |
1147 | | ** scanned back by Lua. Use hexadecimal format for "common" numbers |
1148 | | ** (to preserve precision); inf, -inf, and NaN are handled separately. |
1149 | | ** (NaN cannot be expressed as a numeral, so we write '(0/0)' for it.) |
1150 | | */ |
1151 | 1 | static int quotefloat (lua_State *L, char *buff, lua_Number n) { |
1152 | 1 | const char *s; /* for the fixed representations */ |
1153 | 1 | if (n == (lua_Number)HUGE_VAL) /* inf? */ |
1154 | 0 | s = "1e9999"; |
1155 | 1 | else if (n == -(lua_Number)HUGE_VAL) /* -inf? */ |
1156 | 0 | s = "-1e9999"; |
1157 | 1 | else if (n != n) /* NaN? */ |
1158 | 0 | s = "(0/0)"; |
1159 | 1 | else { /* format number as hexadecimal */ |
1160 | 1 | int nb = lua_number2strx(L, buff, MAX_ITEM, |
1161 | 1 | "%" LUA_NUMBER_FRMLEN "a", n); |
1162 | | /* ensures that 'buff' string uses a dot as the radix character */ |
1163 | 1 | if (memchr(buff, '.', nb) == NULL) { /* no dot? */ |
1164 | 0 | char point = lua_getlocaledecpoint(); /* try locale point */ |
1165 | 0 | char *ppoint = (char *)memchr(buff, point, nb); |
1166 | 0 | if (ppoint) *ppoint = '.'; /* change it to a dot */ |
1167 | 0 | } |
1168 | 1 | return nb; |
1169 | 1 | } |
1170 | | /* for the fixed representations */ |
1171 | 0 | return l_sprintf(buff, MAX_ITEM, "%s", s); |
1172 | 1 | } |
1173 | | |
1174 | | |
1175 | 4 | static void addliteral (lua_State *L, luaL_Buffer *b, int arg) { |
1176 | 4 | switch (lua_type(L, arg)) { |
1177 | 2 | case LUA_TSTRING: { |
1178 | 2 | size_t len; |
1179 | 2 | const char *s = lua_tolstring(L, arg, &len); |
1180 | 2 | addquoted(b, s, len); |
1181 | 2 | break; |
1182 | 0 | } |
1183 | 1 | case LUA_TNUMBER: { |
1184 | 1 | char *buff = luaL_prepbuffsize(b, MAX_ITEM); |
1185 | 1 | int nb; |
1186 | 1 | if (!lua_isinteger(L, arg)) /* float? */ |
1187 | 1 | nb = quotefloat(L, buff, lua_tonumber(L, arg)); |
1188 | 0 | else { /* integers */ |
1189 | 0 | lua_Integer n = lua_tointeger(L, arg); |
1190 | 0 | const char *format = (n == LUA_MININTEGER) /* corner case? */ |
1191 | 0 | ? "0x%" LUA_INTEGER_FRMLEN "x" /* use hex */ |
1192 | 0 | : LUA_INTEGER_FMT; /* else use default format */ |
1193 | 0 | nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n); |
1194 | 0 | } |
1195 | 1 | luaL_addsize(b, nb); |
1196 | 1 | break; |
1197 | 0 | } |
1198 | 0 | case LUA_TNIL: case LUA_TBOOLEAN: { |
1199 | 0 | luaL_tolstring(L, arg, NULL); |
1200 | 0 | luaL_addvalue(b); |
1201 | 0 | break; |
1202 | 0 | } |
1203 | 1 | default: { |
1204 | 1 | luaL_argerror(L, arg, "value has no literal form"); |
1205 | 1 | } |
1206 | 4 | } |
1207 | 4 | } |
1208 | | |
1209 | | |
1210 | 46 | static const char *get2digits (const char *s) { |
1211 | 46 | if (isdigit(uchar(*s))) { |
1212 | 0 | s++; |
1213 | 0 | if (isdigit(uchar(*s))) s++; /* (2 digits at most) */ |
1214 | 0 | } |
1215 | 46 | return s; |
1216 | 46 | } |
1217 | | |
1218 | | |
1219 | | /* |
1220 | | ** Check whether a conversion specification is valid. When called, |
1221 | | ** first character in 'form' must be '%' and last character must |
1222 | | ** be a valid conversion specifier. 'flags' are the accepted flags; |
1223 | | ** 'precision' signals whether to accept a precision. |
1224 | | */ |
1225 | | static void checkformat (lua_State *L, const char *form, const char *flags, |
1226 | 46 | int precision) { |
1227 | 46 | const char *spec = form + 1; /* skip '%' */ |
1228 | 46 | spec += strspn(spec, flags); /* skip flags */ |
1229 | 46 | if (*spec != '0') { /* a width cannot start with '0' */ |
1230 | 46 | spec = get2digits(spec); /* skip width */ |
1231 | 46 | if (*spec == '.' && precision) { |
1232 | 0 | spec++; |
1233 | 0 | spec = get2digits(spec); /* skip precision */ |
1234 | 0 | } |
1235 | 46 | } |
1236 | 46 | if (!isalpha(uchar(*spec))) /* did not go to the end? */ |
1237 | 0 | luaL_error(L, "invalid conversion specification: '%s'", form); |
1238 | 46 | } |
1239 | | |
1240 | | |
1241 | | /* |
1242 | | ** Get a conversion specification and copy it to 'form'. |
1243 | | ** Return the address of its last character. |
1244 | | */ |
1245 | | static const char *getformat (lua_State *L, const char *strfrmt, |
1246 | 68 | char *form) { |
1247 | | /* spans flags, width, and precision ('0' is included as a flag) */ |
1248 | 68 | size_t len = strspn(strfrmt, L_FMTFLAGSF "123456789."); |
1249 | 68 | len++; /* adds following character (should be the specifier) */ |
1250 | | /* still needs space for '%', '\0', plus a length modifier */ |
1251 | 68 | if (len >= MAX_FORMAT - 10) |
1252 | 0 | luaL_error(L, "invalid format (too long)"); |
1253 | 68 | *(form++) = '%'; |
1254 | 68 | memcpy(form, strfrmt, len * sizeof(char)); |
1255 | 68 | *(form + len) = '\0'; |
1256 | 68 | return strfrmt + len - 1; |
1257 | 68 | } |
1258 | | |
1259 | | |
1260 | | /* |
1261 | | ** add length modifier into formats |
1262 | | */ |
1263 | 43 | static void addlenmod (char *form, const char *lenmod) { |
1264 | 43 | size_t l = strlen(form); |
1265 | 43 | size_t lm = strlen(lenmod); |
1266 | 43 | char spec = form[l - 1]; |
1267 | 43 | strcpy(form + l - 1, lenmod); |
1268 | 43 | form[l + lm - 1] = spec; |
1269 | 43 | form[l + lm] = '\0'; |
1270 | 43 | } |
1271 | | |
1272 | | |
1273 | 89 | static int str_format (lua_State *L) { |
1274 | 89 | int top = lua_gettop(L); |
1275 | 89 | int arg = 1; |
1276 | 89 | size_t sfl; |
1277 | 89 | const char *strfrmt = luaL_checklstring(L, arg, &sfl); |
1278 | 89 | const char *strfrmt_end = strfrmt+sfl; |
1279 | 89 | const char *flags; |
1280 | 89 | luaL_Buffer b; |
1281 | 89 | luaL_buffinit(L, &b); |
1282 | 229k | while (strfrmt < strfrmt_end) { |
1283 | 229k | if (*strfrmt != L_ESC) |
1284 | 228k | luaL_addchar(&b, *strfrmt++); |
1285 | 119 | else if (*++strfrmt == L_ESC) |
1286 | 50 | luaL_addchar(&b, *strfrmt++); /* %% */ |
1287 | 69 | else { /* format item */ |
1288 | 69 | char form[MAX_FORMAT]; /* to store the format ('%...') */ |
1289 | 69 | int maxitem = MAX_ITEM; /* maximum length for the result */ |
1290 | 69 | char *buff = luaL_prepbuffsize(&b, maxitem); /* to put result */ |
1291 | 69 | int nb = 0; /* number of bytes in result */ |
1292 | 69 | if (++arg > top) |
1293 | 1 | return luaL_argerror(L, arg, "no value"); |
1294 | 68 | strfrmt = getformat(L, strfrmt, form); |
1295 | 68 | switch (*strfrmt++) { |
1296 | 1 | case 'c': { |
1297 | 1 | checkformat(L, form, L_FMTFLAGSC, 0); |
1298 | 1 | nb = l_sprintf(buff, maxitem, form, (int)luaL_checkinteger(L, arg)); |
1299 | 1 | break; |
1300 | 0 | } |
1301 | 2 | case 'd': case 'i': |
1302 | 2 | flags = L_FMTFLAGSI; |
1303 | 2 | goto intcase; |
1304 | 2 | case 'u': |
1305 | 2 | flags = L_FMTFLAGSU; |
1306 | 2 | goto intcase; |
1307 | 3 | case 'o': case 'x': case 'X': |
1308 | 3 | flags = L_FMTFLAGSX; |
1309 | 7 | intcase: { |
1310 | 7 | lua_Integer n = luaL_checkinteger(L, arg); |
1311 | 7 | checkformat(L, form, flags, 1); |
1312 | 7 | addlenmod(form, LUA_INTEGER_FRMLEN); |
1313 | 7 | nb = l_sprintf(buff, maxitem, form, (LUAI_UACINT)n); |
1314 | 7 | break; |
1315 | 3 | } |
1316 | 16 | case 'a': case 'A': |
1317 | 16 | checkformat(L, form, L_FMTFLAGSF, 1); |
1318 | 16 | addlenmod(form, LUA_NUMBER_FRMLEN); |
1319 | 16 | nb = lua_number2strx(L, buff, maxitem, form, |
1320 | 16 | luaL_checknumber(L, arg)); |
1321 | 16 | break; |
1322 | 8 | case 'f': |
1323 | 8 | maxitem = MAX_ITEMF; /* extra space for '%f' */ |
1324 | 8 | buff = luaL_prepbuffsize(&b, maxitem); |
1325 | | /* FALLTHROUGH */ |
1326 | 31 | case 'e': case 'E': case 'g': case 'G': { |
1327 | 31 | lua_Number n = luaL_checknumber(L, arg); |
1328 | 31 | checkformat(L, form, L_FMTFLAGSF, 1); |
1329 | 31 | addlenmod(form, LUA_NUMBER_FRMLEN); |
1330 | 31 | nb = l_sprintf(buff, maxitem, form, (LUAI_UACNUMBER)n); |
1331 | 31 | break; |
1332 | 24 | } |
1333 | 2 | case 'p': { |
1334 | 2 | const void *p = lua_topointer(L, arg); |
1335 | 2 | checkformat(L, form, L_FMTFLAGSC, 0); |
1336 | 2 | if (p == NULL) { /* avoid calling 'printf' with argument NULL */ |
1337 | 1 | p = "(null)"; /* result */ |
1338 | 1 | form[strlen(form) - 1] = 's'; /* format it as a string */ |
1339 | 1 | } |
1340 | 2 | nb = l_sprintf(buff, maxitem, form, p); |
1341 | 2 | break; |
1342 | 24 | } |
1343 | 4 | case 'q': { |
1344 | 4 | if (form[2] != '\0') /* modifiers? */ |
1345 | 0 | return luaL_error(L, "specifier '%%q' cannot have modifiers"); |
1346 | 4 | addliteral(L, &b, arg); |
1347 | 4 | break; |
1348 | 4 | } |
1349 | 3 | case 's': { |
1350 | 3 | size_t l; |
1351 | 3 | const char *s = luaL_tolstring(L, arg, &l); |
1352 | 3 | if (form[2] == '\0') /* no modifiers? */ |
1353 | 3 | luaL_addvalue(&b); /* keep entire string */ |
1354 | 0 | else { |
1355 | 0 | luaL_argcheck(L, l == strlen(s), arg, "string contains zeros"); |
1356 | 0 | checkformat(L, form, L_FMTFLAGSC, 1); |
1357 | 0 | if (strchr(form, '.') == NULL && l >= 100) { |
1358 | | /* no precision and string is too long to be formatted */ |
1359 | 0 | luaL_addvalue(&b); /* keep entire string */ |
1360 | 0 | } |
1361 | 0 | else { /* format the string into 'buff' */ |
1362 | 0 | nb = l_sprintf(buff, maxitem, form, s); |
1363 | 0 | lua_pop(L, 1); /* remove result from 'luaL_tolstring' */ |
1364 | 0 | } |
1365 | 0 | } |
1366 | 3 | break; |
1367 | 4 | } |
1368 | 4 | default: { /* also treat cases 'pnLlh' */ |
1369 | 4 | return luaL_error(L, "invalid conversion '%s' to 'format'", form); |
1370 | 4 | } |
1371 | 68 | } |
1372 | 49 | lua_assert(nb < maxitem); |
1373 | 49 | luaL_addsize(&b, nb); |
1374 | 49 | } |
1375 | 229k | } |
1376 | 69 | luaL_pushresult(&b); |
1377 | 69 | return 1; |
1378 | 89 | } |
1379 | | |
1380 | | /* }====================================================== */ |
1381 | | |
1382 | | |
1383 | | /* |
1384 | | ** {====================================================== |
1385 | | ** PACK/UNPACK |
1386 | | ** ======================================================= |
1387 | | */ |
1388 | | |
1389 | | |
1390 | | /* value used for padding */ |
1391 | | #if !defined(LUAL_PACKPADBYTE) |
1392 | | #define LUAL_PACKPADBYTE 0x00 |
1393 | | #endif |
1394 | | |
1395 | | /* maximum size for the binary representation of an integer */ |
1396 | 0 | #define MAXINTSIZE 16 |
1397 | | |
1398 | | /* number of bits in a character */ |
1399 | 58.2k | #define NB CHAR_BIT |
1400 | | |
1401 | | /* mask for one character (NB 1's) */ |
1402 | 32.1k | #define MC ((1 << NB) - 1) |
1403 | | |
1404 | | /* size of a lua_Integer */ |
1405 | 607 | #define SZINT ((int)sizeof(lua_Integer)) |
1406 | | |
1407 | | |
1408 | | /* dummy union to get native endianness */ |
1409 | | static const union { |
1410 | | int dummy; |
1411 | | char little; /* true iff machine is little endian */ |
1412 | | } nativeendian = {1}; |
1413 | | |
1414 | | |
1415 | | /* |
1416 | | ** information to pack/unpack stuff |
1417 | | */ |
1418 | | typedef struct Header { |
1419 | | lua_State *L; |
1420 | | int islittle; |
1421 | | int maxalign; |
1422 | | } Header; |
1423 | | |
1424 | | |
1425 | | /* |
1426 | | ** options for pack/unpack |
1427 | | */ |
1428 | | typedef enum KOption { |
1429 | | Kint, /* signed integers */ |
1430 | | Kuint, /* unsigned integers */ |
1431 | | Kfloat, /* single-precision floating-point numbers */ |
1432 | | Knumber, /* Lua "native" floating-point numbers */ |
1433 | | Kdouble, /* double-precision floating-point numbers */ |
1434 | | Kchar, /* fixed-length strings */ |
1435 | | Kstring, /* strings with prefixed length */ |
1436 | | Kzstr, /* zero-terminated strings */ |
1437 | | Kpadding, /* padding */ |
1438 | | Kpaddalign, /* padding for alignment */ |
1439 | | Knop /* no-op (configuration or spaces) */ |
1440 | | } KOption; |
1441 | | |
1442 | | |
1443 | | /* |
1444 | | ** Read an integer numeral from string 'fmt' or return 'df' if |
1445 | | ** there is no numeral |
1446 | | */ |
1447 | 224k | static int digit (int c) { return '0' <= c && c <= '9'; } |
1448 | | |
1449 | 69.0k | static int getnum (const char **fmt, int df) { |
1450 | 69.0k | if (!digit(**fmt)) /* no number? */ |
1451 | 22.1k | return df; /* return default value */ |
1452 | 46.9k | else { |
1453 | 46.9k | int a = 0; |
1454 | 155k | do { |
1455 | 155k | a = a*10 + (*((*fmt)++) - '0'); |
1456 | 155k | } while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10); |
1457 | 46.9k | return a; |
1458 | 46.9k | } |
1459 | 69.0k | } |
1460 | | |
1461 | | |
1462 | | /* |
1463 | | ** Read an integer numeral and raises an error if it is larger |
1464 | | ** than the maximum size for integers. |
1465 | | */ |
1466 | 28.2k | static int getnumlimit (Header *h, const char **fmt, int df) { |
1467 | 28.2k | int sz = getnum(fmt, df); |
1468 | 28.2k | if (l_unlikely(sz > MAXINTSIZE || sz <= 0)) |
1469 | 0 | return luaL_error(h->L, "integral size (%d) out of limits [1,%d]", |
1470 | 0 | sz, MAXINTSIZE); |
1471 | 28.2k | return sz; |
1472 | 28.2k | } |
1473 | | |
1474 | | |
1475 | | /* |
1476 | | ** Initialize Header |
1477 | | */ |
1478 | 35.8k | static void initheader (lua_State *L, Header *h) { |
1479 | 35.8k | h->L = L; |
1480 | 35.8k | h->islittle = nativeendian.little; |
1481 | 35.8k | h->maxalign = 1; |
1482 | 35.8k | } |
1483 | | |
1484 | | |
1485 | | /* |
1486 | | ** Read and classify next option. 'size' is filled with option's size. |
1487 | | */ |
1488 | 498k | static KOption getoption (Header *h, const char **fmt, int *size) { |
1489 | | /* dummy structure to get native alignment requirements */ |
1490 | 498k | struct cD { char c; union { LUAI_MAXALIGN; } u; }; |
1491 | 498k | int opt = *((*fmt)++); |
1492 | 498k | *size = 0; /* default */ |
1493 | 498k | switch (opt) { |
1494 | 38 | case 'b': *size = sizeof(char); return Kint; |
1495 | 1.35k | case 'B': *size = sizeof(char); return Kuint; |
1496 | 253 | case 'h': *size = sizeof(short); return Kint; |
1497 | 234 | case 'H': *size = sizeof(short); return Kuint; |
1498 | 434 | case 'l': *size = sizeof(long); return Kint; |
1499 | 0 | case 'L': *size = sizeof(long); return Kuint; |
1500 | 2.31k | case 'j': *size = sizeof(lua_Integer); return Kint; |
1501 | 1 | case 'J': *size = sizeof(lua_Integer); return Kuint; |
1502 | 4.65k | case 'T': *size = sizeof(size_t); return Kuint; |
1503 | 1.77k | case 'f': *size = sizeof(float); return Kfloat; |
1504 | 86 | case 'n': *size = sizeof(lua_Number); return Knumber; |
1505 | 38 | case 'd': *size = sizeof(double); return Kdouble; |
1506 | 1.55k | case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint; |
1507 | 4.69k | case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint; |
1508 | 5.89k | case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring; |
1509 | 40.8k | case 'c': |
1510 | 40.8k | *size = getnum(fmt, -1); |
1511 | 40.8k | if (l_unlikely(*size == -1)) |
1512 | 1 | luaL_error(h->L, "missing size for format option 'c'"); |
1513 | 40.8k | return Kchar; |
1514 | 138 | case 'z': return Kzstr; |
1515 | 11.7k | case 'x': *size = 1; return Kpadding; |
1516 | 2.51k | case 'X': return Kpaddalign; |
1517 | 422 | case ' ': break; |
1518 | 379k | case '<': h->islittle = 1; break; |
1519 | 20.7k | case '>': h->islittle = 0; break; |
1520 | 3.22k | case '=': h->islittle = nativeendian.little; break; |
1521 | 16.0k | case '!': { |
1522 | 16.0k | const int maxalign = offsetof(struct cD, u); |
1523 | 16.0k | h->maxalign = getnumlimit(h, fmt, maxalign); |
1524 | 16.0k | break; |
1525 | 0 | } |
1526 | 8 | default: luaL_error(h->L, "invalid format option '%c'", opt); |
1527 | 498k | } |
1528 | 419k | return Knop; |
1529 | 498k | } |
1530 | | |
1531 | | |
1532 | | /* |
1533 | | ** Read, classify, and fill other details about the next option. |
1534 | | ** 'psize' is filled with option's size, 'notoalign' with its |
1535 | | ** alignment requirements. |
1536 | | ** Local variable 'size' gets the size to be aligned. (Kpadal option |
1537 | | ** always gets its full alignment, other options are limited by |
1538 | | ** the maximum alignment ('maxalign'). Kchar option needs no alignment |
1539 | | ** despite its size. |
1540 | | */ |
1541 | | static KOption getdetails (Header *h, size_t totalsize, |
1542 | 495k | const char **fmt, int *psize, int *ntoalign) { |
1543 | 495k | KOption opt = getoption(h, fmt, psize); |
1544 | 495k | int align = *psize; /* usually, alignment follows size */ |
1545 | 495k | if (opt == Kpaddalign) { /* 'X' gets alignment from following option */ |
1546 | 2.51k | if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0) |
1547 | 0 | luaL_argerror(h->L, 1, "invalid next option for option 'X'"); |
1548 | 2.51k | } |
1549 | 495k | if (align <= 1 || opt == Kchar) /* need no alignment? */ |
1550 | 473k | *ntoalign = 0; |
1551 | 21.7k | else { |
1552 | 21.7k | if (align > h->maxalign) /* enforce maximum alignment */ |
1553 | 10.8k | align = h->maxalign; |
1554 | 21.7k | if (l_unlikely((align & (align - 1)) != 0)) /* not a power of 2? */ |
1555 | 0 | luaL_argerror(h->L, 1, "format asks for alignment not power of 2"); |
1556 | 21.7k | *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1); |
1557 | 21.7k | } |
1558 | 495k | return opt; |
1559 | 495k | } |
1560 | | |
1561 | | |
1562 | | /* |
1563 | | ** Pack integer 'n' with 'size' bytes and 'islittle' endianness. |
1564 | | ** The final 'if' handles the case when 'size' is larger than |
1565 | | ** the size of a Lua integer, correcting the extra sign-extension |
1566 | | ** bytes if necessary (by default they would be zeros). |
1567 | | */ |
1568 | | static void packint (luaL_Buffer *b, lua_Unsigned n, |
1569 | 6.41k | int islittle, int size, int neg) { |
1570 | 6.41k | char *buff = luaL_prepbuffsize(b, size); |
1571 | 6.41k | int i; |
1572 | 6.41k | buff[islittle ? 0 : size - 1] = (char)(n & MC); /* first byte */ |
1573 | 32.1k | for (i = 1; i < size; i++) { |
1574 | 25.7k | n >>= NB; |
1575 | 25.7k | buff[islittle ? i : size - 1 - i] = (char)(n & MC); |
1576 | 25.7k | } |
1577 | 6.41k | if (neg && size > SZINT) { /* negative number need sign extension? */ |
1578 | 0 | for (i = SZINT; i < size; i++) /* correct extra bytes */ |
1579 | 0 | buff[islittle ? i : size - 1 - i] = (char)MC; |
1580 | 0 | } |
1581 | 6.41k | luaL_addsize(b, size); /* add result to buffer */ |
1582 | 6.41k | } |
1583 | | |
1584 | | |
1585 | | /* |
1586 | | ** Copy 'size' bytes from 'src' to 'dest', correcting endianness if |
1587 | | ** given 'islittle' is different from native endianness. |
1588 | | */ |
1589 | | static void copywithendian (char *dest, const char *src, |
1590 | 59 | int size, int islittle) { |
1591 | 59 | if (islittle == nativeendian.little) |
1592 | 59 | memcpy(dest, src, size); |
1593 | 0 | else { |
1594 | 0 | dest += size - 1; |
1595 | 0 | while (size-- != 0) |
1596 | 0 | *(dest--) = *(src++); |
1597 | 0 | } |
1598 | 59 | } |
1599 | | |
1600 | | |
1601 | 35.1k | static int str_pack (lua_State *L) { |
1602 | 35.1k | luaL_Buffer b; |
1603 | 35.1k | Header h; |
1604 | 35.1k | const char *fmt = luaL_checkstring(L, 1); /* format string */ |
1605 | 35.1k | int arg = 1; /* current argument to pack */ |
1606 | 35.1k | size_t totalsize = 0; /* accumulate total size of result */ |
1607 | 35.1k | initheader(L, &h); |
1608 | 35.1k | lua_pushnil(L); /* mark to separate arguments from string buffer */ |
1609 | 35.1k | luaL_buffinit(L, &b); |
1610 | 507k | while (*fmt != '\0') { |
1611 | 472k | int size, ntoalign; |
1612 | 472k | KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign); |
1613 | 472k | totalsize += ntoalign + size; |
1614 | 479k | while (ntoalign-- > 0) |
1615 | 7.45k | luaL_addchar(&b, LUAL_PACKPADBYTE); /* fill alignment */ |
1616 | 472k | arg++; |
1617 | 472k | switch (opt) { |
1618 | 516 | case Kint: { /* signed integers */ |
1619 | 516 | lua_Integer n = luaL_checkinteger(L, arg); |
1620 | 516 | if (size < SZINT) { /* need overflow check? */ |
1621 | 252 | lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1); |
1622 | 252 | luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow"); |
1623 | 252 | } |
1624 | 516 | packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0)); |
1625 | 516 | break; |
1626 | 0 | } |
1627 | 28 | case Kuint: { /* unsigned integers */ |
1628 | 28 | lua_Integer n = luaL_checkinteger(L, arg); |
1629 | 28 | if (size < SZINT) /* need overflow check? */ |
1630 | 4 | luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)), |
1631 | 28 | arg, "unsigned overflow"); |
1632 | 28 | packint(&b, (lua_Unsigned)n, h.islittle, size, 0); |
1633 | 28 | break; |
1634 | 0 | } |
1635 | 0 | case Kfloat: { /* C float */ |
1636 | 0 | float f = (float)luaL_checknumber(L, arg); /* get argument */ |
1637 | 0 | char *buff = luaL_prepbuffsize(&b, sizeof(f)); |
1638 | | /* move 'f' to final result, correcting endianness if needed */ |
1639 | 0 | copywithendian(buff, (char *)&f, sizeof(f), h.islittle); |
1640 | 0 | luaL_addsize(&b, size); |
1641 | 0 | break; |
1642 | 0 | } |
1643 | 0 | case Knumber: { /* Lua float */ |
1644 | 0 | lua_Number f = luaL_checknumber(L, arg); /* get argument */ |
1645 | 0 | char *buff = luaL_prepbuffsize(&b, sizeof(f)); |
1646 | | /* move 'f' to final result, correcting endianness if needed */ |
1647 | 0 | copywithendian(buff, (char *)&f, sizeof(f), h.islittle); |
1648 | 0 | luaL_addsize(&b, size); |
1649 | 0 | break; |
1650 | 0 | } |
1651 | 38 | case Kdouble: { /* C double */ |
1652 | 38 | double f = (double)luaL_checknumber(L, arg); /* get argument */ |
1653 | 38 | char *buff = luaL_prepbuffsize(&b, sizeof(f)); |
1654 | | /* move 'f' to final result, correcting endianness if needed */ |
1655 | 38 | copywithendian(buff, (char *)&f, sizeof(f), h.islittle); |
1656 | 38 | luaL_addsize(&b, size); |
1657 | 38 | break; |
1658 | 0 | } |
1659 | 40.8k | case Kchar: { /* fixed-size string */ |
1660 | 40.8k | size_t len; |
1661 | 40.8k | const char *s = luaL_checklstring(L, arg, &len); |
1662 | 40.8k | luaL_argcheck(L, len <= (size_t)size, arg, |
1663 | 40.8k | "string longer than given size"); |
1664 | 40.8k | luaL_addlstring(&b, s, len); /* add string */ |
1665 | 1.85G | while (len++ < (size_t)size) /* pad extra space */ |
1666 | 1.85G | luaL_addchar(&b, LUAL_PACKPADBYTE); |
1667 | 40.8k | break; |
1668 | 0 | } |
1669 | 5.87k | case Kstring: { /* strings with length count */ |
1670 | 5.87k | size_t len; |
1671 | 5.87k | const char *s = luaL_checklstring(L, arg, &len); |
1672 | 5.87k | luaL_argcheck(L, size >= (int)sizeof(size_t) || |
1673 | 5.87k | len < ((size_t)1 << (size * NB)), |
1674 | 5.87k | arg, "string length does not fit in given size"); |
1675 | 5.87k | packint(&b, (lua_Unsigned)len, h.islittle, size, 0); /* pack length */ |
1676 | 5.87k | luaL_addlstring(&b, s, len); |
1677 | 5.87k | totalsize += len; |
1678 | 5.87k | break; |
1679 | 0 | } |
1680 | 138 | case Kzstr: { /* zero-terminated string */ |
1681 | 138 | size_t len; |
1682 | 138 | const char *s = luaL_checklstring(L, arg, &len); |
1683 | 138 | luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros"); |
1684 | 138 | luaL_addlstring(&b, s, len); |
1685 | 138 | luaL_addchar(&b, '\0'); /* add zero at the end */ |
1686 | 138 | totalsize += len + 1; |
1687 | 138 | break; |
1688 | 0 | } |
1689 | 4.63k | case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE); /* FALLTHROUGH */ |
1690 | 424k | case Kpaddalign: case Knop: |
1691 | 424k | arg--; /* undo increment */ |
1692 | 424k | break; |
1693 | 472k | } |
1694 | 472k | } |
1695 | 35.1k | luaL_pushresult(&b); |
1696 | 35.1k | return 1; |
1697 | 35.1k | } |
1698 | | |
1699 | | |
1700 | 639 | static int str_packsize (lua_State *L) { |
1701 | 639 | Header h; |
1702 | 639 | const char *fmt = luaL_checkstring(L, 1); /* format string */ |
1703 | 639 | size_t totalsize = 0; /* accumulate total size of result */ |
1704 | 639 | initheader(L, &h); |
1705 | 24.1k | while (*fmt != '\0') { |
1706 | 23.5k | int size, ntoalign; |
1707 | 23.5k | KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign); |
1708 | 23.5k | luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1, |
1709 | 23.5k | "variable-length format"); |
1710 | 23.5k | size += ntoalign; /* total space used by option */ |
1711 | 23.5k | luaL_argcheck(L, totalsize <= MAXSIZE - size, 1, |
1712 | 23.5k | "format result too large"); |
1713 | 23.5k | totalsize += size; |
1714 | 23.5k | } |
1715 | 639 | lua_pushinteger(L, (lua_Integer)totalsize); |
1716 | 639 | return 1; |
1717 | 639 | } |
1718 | | |
1719 | | |
1720 | | /* |
1721 | | ** Unpack an integer with 'size' bytes and 'islittle' endianness. |
1722 | | ** If size is smaller than the size of a Lua integer and integer |
1723 | | ** is signed, must do sign extension (propagating the sign to the |
1724 | | ** higher bits); if size is larger than the size of a Lua integer, |
1725 | | ** it must check the unread bytes to see whether they do not cause an |
1726 | | ** overflow. |
1727 | | */ |
1728 | | static lua_Integer unpackint (lua_State *L, const char *str, |
1729 | 21 | int islittle, int size, int issigned) { |
1730 | 21 | lua_Unsigned res = 0; |
1731 | 21 | int i; |
1732 | 21 | int limit = (size <= SZINT) ? size : SZINT; |
1733 | 189 | for (i = limit - 1; i >= 0; i--) { |
1734 | 168 | res <<= NB; |
1735 | 168 | res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i]; |
1736 | 168 | } |
1737 | 21 | if (size < SZINT) { /* real size smaller than lua_Integer? */ |
1738 | 0 | if (issigned) { /* needs sign extension? */ |
1739 | 0 | lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1); |
1740 | 0 | res = ((res ^ mask) - mask); /* do sign extension */ |
1741 | 0 | } |
1742 | 0 | } |
1743 | 21 | else if (size > SZINT) { /* must check unread bytes */ |
1744 | 0 | int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC; |
1745 | 0 | for (i = limit; i < size; i++) { |
1746 | 0 | if (l_unlikely((unsigned char)str[islittle ? i : size - 1 - i] != mask)) |
1747 | 0 | luaL_error(L, "%d-byte integer does not fit into Lua Integer", size); |
1748 | 0 | } |
1749 | 0 | } |
1750 | 21 | return (lua_Integer)res; |
1751 | 21 | } |
1752 | | |
1753 | | |
1754 | 25 | static int str_unpack (lua_State *L) { |
1755 | 25 | Header h; |
1756 | 25 | const char *fmt = luaL_checkstring(L, 1); |
1757 | 25 | size_t ld; |
1758 | 25 | const char *data = luaL_checklstring(L, 2, &ld); |
1759 | 25 | size_t pos = posrelatI(luaL_optinteger(L, 3, 1), ld) - 1; |
1760 | 25 | int n = 0; /* number of results */ |
1761 | 25 | luaL_argcheck(L, pos <= ld, 3, "initial position out of string"); |
1762 | 25 | initheader(L, &h); |
1763 | 67 | while (*fmt != '\0') { |
1764 | 42 | int size, ntoalign; |
1765 | 42 | KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign); |
1766 | 42 | luaL_argcheck(L, (size_t)ntoalign + size <= ld - pos, 2, |
1767 | 42 | "data string too short"); |
1768 | 42 | pos += ntoalign; /* skip alignment */ |
1769 | | /* stack space for item + next position */ |
1770 | 42 | luaL_checkstack(L, 2, "too many results"); |
1771 | 42 | n++; |
1772 | 42 | switch (opt) { |
1773 | 0 | case Kint: |
1774 | 0 | case Kuint: { |
1775 | 0 | lua_Integer res = unpackint(L, data + pos, h.islittle, size, |
1776 | 0 | (opt == Kint)); |
1777 | 0 | lua_pushinteger(L, res); |
1778 | 0 | break; |
1779 | 0 | } |
1780 | 0 | case Kfloat: { |
1781 | 0 | float f; |
1782 | 0 | copywithendian((char *)&f, data + pos, sizeof(f), h.islittle); |
1783 | 0 | lua_pushnumber(L, (lua_Number)f); |
1784 | 0 | break; |
1785 | 0 | } |
1786 | 21 | case Knumber: { |
1787 | 21 | lua_Number f; |
1788 | 21 | copywithendian((char *)&f, data + pos, sizeof(f), h.islittle); |
1789 | 21 | lua_pushnumber(L, f); |
1790 | 21 | break; |
1791 | 0 | } |
1792 | 0 | case Kdouble: { |
1793 | 0 | double f; |
1794 | 0 | copywithendian((char *)&f, data + pos, sizeof(f), h.islittle); |
1795 | 0 | lua_pushnumber(L, (lua_Number)f); |
1796 | 0 | break; |
1797 | 0 | } |
1798 | 0 | case Kchar: { |
1799 | 0 | lua_pushlstring(L, data + pos, size); |
1800 | 0 | break; |
1801 | 0 | } |
1802 | 21 | case Kstring: { |
1803 | 21 | size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0); |
1804 | 21 | luaL_argcheck(L, len <= ld - pos - size, 2, "data string too short"); |
1805 | 21 | lua_pushlstring(L, data + pos + size, len); |
1806 | 21 | pos += len; /* skip string */ |
1807 | 21 | break; |
1808 | 0 | } |
1809 | 0 | case Kzstr: { |
1810 | 0 | size_t len = strlen(data + pos); |
1811 | 0 | luaL_argcheck(L, pos + len < ld, 2, |
1812 | 0 | "unfinished string for format 'z'"); |
1813 | 0 | lua_pushlstring(L, data + pos, len); |
1814 | 0 | pos += len + 1; /* skip string plus final '\0' */ |
1815 | 0 | break; |
1816 | 0 | } |
1817 | 0 | case Kpaddalign: case Kpadding: case Knop: |
1818 | 0 | n--; /* undo increment */ |
1819 | 0 | break; |
1820 | 42 | } |
1821 | 42 | pos += size; |
1822 | 42 | } |
1823 | 25 | lua_pushinteger(L, pos + 1); /* next position */ |
1824 | 25 | return n + 1; |
1825 | 25 | } |
1826 | | |
1827 | | /* }====================================================== */ |
1828 | | |
1829 | | |
1830 | | static const luaL_Reg strlib[] = { |
1831 | | {"byte", str_byte}, |
1832 | | {"char", str_char}, |
1833 | | {"dump", str_dump}, |
1834 | | {"find", str_find}, |
1835 | | {"format", str_format}, |
1836 | | {"gmatch", gmatch}, |
1837 | | {"gsub", str_gsub}, |
1838 | | {"len", str_len}, |
1839 | | {"lower", str_lower}, |
1840 | | {"match", str_match}, |
1841 | | {"rep", str_rep}, |
1842 | | {"reverse", str_reverse}, |
1843 | | {"sub", str_sub}, |
1844 | | {"upper", str_upper}, |
1845 | | {"pack", str_pack}, |
1846 | | {"packsize", str_packsize}, |
1847 | | {"unpack", str_unpack}, |
1848 | | {NULL, NULL} |
1849 | | }; |
1850 | | |
1851 | | |
1852 | 3.20k | static void createmetatable (lua_State *L) { |
1853 | | /* table to be metatable for strings */ |
1854 | 3.20k | luaL_newlibtable(L, stringmetamethods); |
1855 | 3.20k | luaL_setfuncs(L, stringmetamethods, 0); |
1856 | 3.20k | lua_pushliteral(L, ""); /* dummy string */ |
1857 | 3.20k | lua_pushvalue(L, -2); /* copy table */ |
1858 | 3.20k | lua_setmetatable(L, -2); /* set table as metatable for strings */ |
1859 | 3.20k | lua_pop(L, 1); /* pop dummy string */ |
1860 | 3.20k | lua_pushvalue(L, -2); /* get string library */ |
1861 | 3.20k | lua_setfield(L, -2, "__index"); /* metatable.__index = string */ |
1862 | 3.20k | lua_pop(L, 1); /* pop metatable */ |
1863 | 3.20k | } |
1864 | | |
1865 | | |
1866 | | /* |
1867 | | ** Open string library |
1868 | | */ |
1869 | 3.20k | LUAMOD_API int luaopen_string (lua_State *L) { |
1870 | 3.20k | luaL_newlib(L, strlib); |
1871 | 3.20k | createmetatable(L); |
1872 | 3.20k | return 1; |
1873 | 3.20k | } |
1874 | | |