/src/testdir/build/lua-master/source/lobject.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | ** $Id: lobject.c $ |
3 | | ** Some generic functions over Lua objects |
4 | | ** See Copyright Notice in lua.h |
5 | | */ |
6 | | |
7 | | #define lobject_c |
8 | | #define LUA_CORE |
9 | | |
10 | | #include "lprefix.h" |
11 | | |
12 | | |
13 | | #include <locale.h> |
14 | | #include <math.h> |
15 | | #include <stdarg.h> |
16 | | #include <stdio.h> |
17 | | #include <stdlib.h> |
18 | | #include <string.h> |
19 | | |
20 | | #include "lua.h" |
21 | | |
22 | | #include "lctype.h" |
23 | | #include "ldebug.h" |
24 | | #include "ldo.h" |
25 | | #include "lmem.h" |
26 | | #include "lobject.h" |
27 | | #include "lstate.h" |
28 | | #include "lstring.h" |
29 | | #include "lvm.h" |
30 | | |
31 | | |
32 | | /* |
33 | | ** Computes ceil(log2(x)) |
34 | | */ |
35 | 171 | int luaO_ceillog2 (unsigned int x) { |
36 | 171 | static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ |
37 | 171 | 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, |
38 | 171 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, |
39 | 171 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
40 | 171 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
41 | 171 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
42 | 171 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
43 | 171 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
44 | 171 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8 |
45 | 171 | }; |
46 | 171 | int l = 0; |
47 | 171 | x--; |
48 | 171 | while (x >= 256) { l += 8; x >>= 8; } |
49 | 171 | return l + log_2[x]; |
50 | 171 | } |
51 | | |
52 | | |
53 | | static lua_Integer intarith (lua_State *L, int op, lua_Integer v1, |
54 | 0 | lua_Integer v2) { |
55 | 0 | switch (op) { |
56 | 0 | case LUA_OPADD: return intop(+, v1, v2); |
57 | 0 | case LUA_OPSUB:return intop(-, v1, v2); |
58 | 0 | case LUA_OPMUL:return intop(*, v1, v2); |
59 | 0 | case LUA_OPMOD: return luaV_mod(L, v1, v2); |
60 | 0 | case LUA_OPIDIV: return luaV_idiv(L, v1, v2); |
61 | 0 | case LUA_OPBAND: return intop(&, v1, v2); |
62 | 0 | case LUA_OPBOR: return intop(|, v1, v2); |
63 | 0 | case LUA_OPBXOR: return intop(^, v1, v2); |
64 | 0 | case LUA_OPSHL: return luaV_shiftl(v1, v2); |
65 | 0 | case LUA_OPSHR: return luaV_shiftr(v1, v2); |
66 | 0 | case LUA_OPUNM: return intop(-, 0, v1); |
67 | 0 | case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); |
68 | 0 | default: lua_assert(0); return 0; |
69 | 0 | } |
70 | 0 | } |
71 | | |
72 | | |
73 | | static lua_Number numarith (lua_State *L, int op, lua_Number v1, |
74 | 0 | lua_Number v2) { |
75 | 0 | switch (op) { |
76 | 0 | case LUA_OPADD: return luai_numadd(L, v1, v2); |
77 | 0 | case LUA_OPSUB: return luai_numsub(L, v1, v2); |
78 | 0 | case LUA_OPMUL: return luai_nummul(L, v1, v2); |
79 | 0 | case LUA_OPDIV: return luai_numdiv(L, v1, v2); |
80 | 0 | case LUA_OPPOW: return luai_numpow(L, v1, v2); |
81 | 0 | case LUA_OPIDIV: return luai_numidiv(L, v1, v2); |
82 | 0 | case LUA_OPUNM: return luai_numunm(L, v1); |
83 | 0 | case LUA_OPMOD: return luaV_modf(L, v1, v2); |
84 | 0 | default: lua_assert(0); return 0; |
85 | 0 | } |
86 | 0 | } |
87 | | |
88 | | |
89 | | int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2, |
90 | 0 | TValue *res) { |
91 | 0 | switch (op) { |
92 | 0 | case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: |
93 | 0 | case LUA_OPSHL: case LUA_OPSHR: |
94 | 0 | case LUA_OPBNOT: { /* operate only on integers */ |
95 | 0 | lua_Integer i1; lua_Integer i2; |
96 | 0 | if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { |
97 | 0 | setivalue(res, intarith(L, op, i1, i2)); |
98 | 0 | return 1; |
99 | 0 | } |
100 | 0 | else return 0; /* fail */ |
101 | 0 | } |
102 | 0 | case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ |
103 | 0 | lua_Number n1; lua_Number n2; |
104 | 0 | if (tonumberns(p1, n1) && tonumberns(p2, n2)) { |
105 | 0 | setfltvalue(res, numarith(L, op, n1, n2)); |
106 | 0 | return 1; |
107 | 0 | } |
108 | 0 | else return 0; /* fail */ |
109 | 0 | } |
110 | 0 | default: { /* other operations */ |
111 | 0 | lua_Number n1; lua_Number n2; |
112 | 0 | if (ttisinteger(p1) && ttisinteger(p2)) { |
113 | 0 | setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); |
114 | 0 | return 1; |
115 | 0 | } |
116 | 0 | else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { |
117 | 0 | setfltvalue(res, numarith(L, op, n1, n2)); |
118 | 0 | return 1; |
119 | 0 | } |
120 | 0 | else return 0; /* fail */ |
121 | 0 | } |
122 | 0 | } |
123 | 0 | } |
124 | | |
125 | | |
126 | | void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2, |
127 | 0 | StkId res) { |
128 | 0 | if (!luaO_rawarith(L, op, p1, p2, s2v(res))) { |
129 | | /* could not perform raw operation; try metamethod */ |
130 | 0 | luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD)); |
131 | 0 | } |
132 | 0 | } |
133 | | |
134 | | |
135 | 0 | int luaO_hexavalue (int c) { |
136 | 0 | if (lisdigit(c)) return c - '0'; |
137 | 0 | else return (ltolower(c) - 'a') + 10; |
138 | 0 | } |
139 | | |
140 | | |
141 | 27 | static int isneg (const char **s) { |
142 | 27 | if (**s == '-') { (*s)++; return 1; } |
143 | 26 | else if (**s == '+') (*s)++; |
144 | 26 | return 0; |
145 | 27 | } |
146 | | |
147 | | |
148 | | |
149 | | /* |
150 | | ** {================================================================== |
151 | | ** Lua's implementation for 'lua_strx2number' |
152 | | ** =================================================================== |
153 | | */ |
154 | | |
155 | | #if !defined(lua_strx2number) |
156 | | |
157 | | /* maximum number of significant digits to read (to avoid overflows |
158 | | even with single floats) */ |
159 | | #define MAXSIGDIG 30 |
160 | | |
161 | | /* |
162 | | ** convert a hexadecimal numeric string to a number, following |
163 | | ** C99 specification for 'strtod' |
164 | | */ |
165 | | static lua_Number lua_strx2number (const char *s, char **endptr) { |
166 | | int dot = lua_getlocaledecpoint(); |
167 | | lua_Number r = l_mathop(0.0); /* result (accumulator) */ |
168 | | int sigdig = 0; /* number of significant digits */ |
169 | | int nosigdig = 0; /* number of non-significant digits */ |
170 | | int e = 0; /* exponent correction */ |
171 | | int neg; /* 1 if number is negative */ |
172 | | int hasdot = 0; /* true after seen a dot */ |
173 | | *endptr = cast_charp(s); /* nothing is valid yet */ |
174 | | while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ |
175 | | neg = isneg(&s); /* check sign */ |
176 | | if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */ |
177 | | return l_mathop(0.0); /* invalid format (no '0x') */ |
178 | | for (s += 2; ; s++) { /* skip '0x' and read numeral */ |
179 | | if (*s == dot) { |
180 | | if (hasdot) break; /* second dot? stop loop */ |
181 | | else hasdot = 1; |
182 | | } |
183 | | else if (lisxdigit(cast_uchar(*s))) { |
184 | | if (sigdig == 0 && *s == '0') /* non-significant digit (zero)? */ |
185 | | nosigdig++; |
186 | | else if (++sigdig <= MAXSIGDIG) /* can read it without overflow? */ |
187 | | r = (r * l_mathop(16.0)) + luaO_hexavalue(*s); |
188 | | else e++; /* too many digits; ignore, but still count for exponent */ |
189 | | if (hasdot) e--; /* decimal digit? correct exponent */ |
190 | | } |
191 | | else break; /* neither a dot nor a digit */ |
192 | | } |
193 | | if (nosigdig + sigdig == 0) /* no digits? */ |
194 | | return l_mathop(0.0); /* invalid format */ |
195 | | *endptr = cast_charp(s); /* valid up to here */ |
196 | | e *= 4; /* each digit multiplies/divides value by 2^4 */ |
197 | | if (*s == 'p' || *s == 'P') { /* exponent part? */ |
198 | | int exp1 = 0; /* exponent value */ |
199 | | int neg1; /* exponent sign */ |
200 | | s++; /* skip 'p' */ |
201 | | neg1 = isneg(&s); /* sign */ |
202 | | if (!lisdigit(cast_uchar(*s))) |
203 | | return l_mathop(0.0); /* invalid; must have at least one digit */ |
204 | | while (lisdigit(cast_uchar(*s))) /* read exponent */ |
205 | | exp1 = exp1 * 10 + *(s++) - '0'; |
206 | | if (neg1) exp1 = -exp1; |
207 | | e += exp1; |
208 | | *endptr = cast_charp(s); /* valid up to here */ |
209 | | } |
210 | | if (neg) r = -r; |
211 | | return l_mathop(ldexp)(r, e); |
212 | | } |
213 | | |
214 | | #endif |
215 | | /* }====================================================== */ |
216 | | |
217 | | |
218 | | /* maximum length of a numeral to be converted to a number */ |
219 | | #if !defined (L_MAXLENNUM) |
220 | 1 | #define L_MAXLENNUM 200 |
221 | | #endif |
222 | | |
223 | | /* |
224 | | ** Convert string 's' to a Lua number (put in 'result'). Return NULL on |
225 | | ** fail or the address of the ending '\0' on success. ('mode' == 'x') |
226 | | ** means a hexadecimal numeral. |
227 | | */ |
228 | 24 | static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { |
229 | 24 | char *endptr; |
230 | | *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ |
231 | 24 | : lua_str2number(s, &endptr); |
232 | 24 | if (endptr == s) return NULL; /* nothing recognized? */ |
233 | 0 | while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ |
234 | 0 | return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */ |
235 | 24 | } |
236 | | |
237 | | |
238 | | /* |
239 | | ** Convert string 's' to a Lua number (put in 'result') handling the |
240 | | ** current locale. |
241 | | ** This function accepts both the current locale or a dot as the radix |
242 | | ** mark. If the conversion fails, it may mean number has a dot but |
243 | | ** locale accepts something else. In that case, the code copies 's' |
244 | | ** to a buffer (because 's' is read-only), changes the dot to the |
245 | | ** current locale radix mark, and tries to convert again. |
246 | | ** The variable 'mode' checks for special characters in the string: |
247 | | ** - 'n' means 'inf' or 'nan' (which should be rejected) |
248 | | ** - 'x' means a hexadecimal numeral |
249 | | ** - '.' just optimizes the search for the common case (no special chars) |
250 | | */ |
251 | 24 | static const char *l_str2d (const char *s, lua_Number *result) { |
252 | 24 | const char *endptr; |
253 | 24 | const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */ |
254 | 24 | int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; |
255 | 24 | if (mode == 'n') /* reject 'inf' and 'nan' */ |
256 | 1 | return NULL; |
257 | 23 | endptr = l_str2dloc(s, result, mode); /* try to convert */ |
258 | 23 | if (endptr == NULL) { /* failed? may be a different locale */ |
259 | 23 | char buff[L_MAXLENNUM + 1]; |
260 | 23 | const char *pdot = strchr(s, '.'); |
261 | 23 | if (pdot == NULL || strlen(s) > L_MAXLENNUM) |
262 | 22 | return NULL; /* string too long or no dot; fail */ |
263 | 1 | strcpy(buff, s); /* copy string to buffer */ |
264 | 1 | buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ |
265 | 1 | endptr = l_str2dloc(buff, result, mode); /* try again */ |
266 | 1 | if (endptr != NULL) |
267 | 0 | endptr = s + (endptr - buff); /* make relative to 's' */ |
268 | 1 | } |
269 | 1 | return endptr; |
270 | 23 | } |
271 | | |
272 | | |
273 | 3 | #define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) |
274 | 0 | #define MAXLASTD cast_int(LUA_MAXINTEGER % 10) |
275 | | |
276 | 27 | static const char *l_str2int (const char *s, lua_Integer *result) { |
277 | 27 | lua_Unsigned a = 0; |
278 | 27 | int empty = 1; |
279 | 27 | int neg; |
280 | 27 | while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ |
281 | 27 | neg = isneg(&s); |
282 | 27 | if (s[0] == '0' && |
283 | 27 | (s[1] == 'x' || s[1] == 'X')) { /* hex? */ |
284 | 0 | s += 2; /* skip '0x' */ |
285 | 0 | for (; lisxdigit(cast_uchar(*s)); s++) { |
286 | 0 | a = a * 16 + luaO_hexavalue(*s); |
287 | 0 | empty = 0; |
288 | 0 | } |
289 | 0 | } |
290 | 27 | else { /* decimal */ |
291 | 27 | for (; lisdigit(cast_uchar(*s)); s++) { |
292 | 3 | int d = *s - '0'; |
293 | 3 | if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ |
294 | 0 | return NULL; /* do not accept it (as integer) */ |
295 | 3 | a = a * 10 + d; |
296 | 3 | empty = 0; |
297 | 3 | } |
298 | 27 | } |
299 | 27 | while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ |
300 | 27 | if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ |
301 | 3 | else { |
302 | 3 | *result = l_castU2S((neg) ? 0u - a : a); |
303 | 3 | return s; |
304 | 3 | } |
305 | 27 | } |
306 | | |
307 | | |
308 | 27 | size_t luaO_str2num (const char *s, TValue *o) { |
309 | 27 | lua_Integer i; lua_Number n; |
310 | 27 | const char *e; |
311 | 27 | if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ |
312 | 3 | setivalue(o, i); |
313 | 3 | } |
314 | 24 | else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ |
315 | 0 | setfltvalue(o, n); |
316 | 0 | } |
317 | 24 | else |
318 | 24 | return 0; /* conversion failed */ |
319 | 3 | return (e - s) + 1; /* success; return string size */ |
320 | 27 | } |
321 | | |
322 | | |
323 | 0 | int luaO_utf8esc (char *buff, unsigned long x) { |
324 | 0 | int n = 1; /* number of bytes put in buffer (backwards) */ |
325 | 0 | lua_assert(x <= 0x7FFFFFFFu); |
326 | 0 | if (x < 0x80) /* ascii? */ |
327 | 0 | buff[UTF8BUFFSZ - 1] = cast_char(x); |
328 | 0 | else { /* need continuation bytes */ |
329 | 0 | unsigned int mfb = 0x3f; /* maximum that fits in first byte */ |
330 | 0 | do { /* add continuation bytes */ |
331 | 0 | buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); |
332 | 0 | x >>= 6; /* remove added bits */ |
333 | 0 | mfb >>= 1; /* now there is one less bit available in first byte */ |
334 | 0 | } while (x > mfb); /* still needs continuation byte? */ |
335 | 0 | buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ |
336 | 0 | } |
337 | 0 | return n; |
338 | 0 | } |
339 | | |
340 | | |
341 | | /* |
342 | | ** Maximum length of the conversion of a number to a string. Must be |
343 | | ** enough to accommodate both LUA_INTEGER_FMT and LUA_NUMBER_FMT. |
344 | | ** (For a long long int, this is 19 digits plus a sign and a final '\0', |
345 | | ** adding to 21. For a long double, it can go to a sign, 33 digits, |
346 | | ** the dot, an exponent letter, an exponent sign, 5 exponent digits, |
347 | | ** and a final '\0', adding to 43.) |
348 | | */ |
349 | 0 | #define MAXNUMBER2STR 44 |
350 | | |
351 | | |
352 | | /* |
353 | | ** Convert a number object to a string, adding it to a buffer |
354 | | */ |
355 | 49 | static int tostringbuff (TValue *obj, char *buff) { |
356 | 49 | int len; |
357 | 49 | lua_assert(ttisnumber(obj)); |
358 | 49 | if (ttisinteger(obj)) |
359 | 21 | len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj)); |
360 | 28 | else { |
361 | 28 | len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj)); |
362 | 28 | if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ |
363 | 28 | buff[len++] = lua_getlocaledecpoint(); |
364 | 28 | buff[len++] = '0'; /* adds '.0' to result */ |
365 | 28 | } |
366 | 28 | } |
367 | 49 | return len; |
368 | 49 | } |
369 | | |
370 | | |
371 | | /* |
372 | | ** Convert a number object to a Lua string, replacing the value at 'obj' |
373 | | */ |
374 | 49 | void luaO_tostring (lua_State *L, TValue *obj) { |
375 | 49 | char buff[MAXNUMBER2STR]; |
376 | 49 | int len = tostringbuff(obj, buff); |
377 | 49 | setsvalue(L, obj, luaS_newlstr(L, buff, len)); |
378 | 49 | } |
379 | | |
380 | | |
381 | | |
382 | | |
383 | | /* |
384 | | ** {================================================================== |
385 | | ** 'luaO_pushvfstring' |
386 | | ** =================================================================== |
387 | | */ |
388 | | |
389 | | /* |
390 | | ** Size for buffer space used by 'luaO_pushvfstring'. It should be |
391 | | ** (LUA_IDSIZE + MAXNUMBER2STR) + a minimal space for basic messages, |
392 | | ** so that 'luaG_addinfo' can work directly on the buffer. |
393 | | */ |
394 | 0 | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) |
395 | | |
396 | | /* buffer used by 'luaO_pushvfstring' */ |
397 | | typedef struct BuffFS { |
398 | | lua_State *L; |
399 | | int pushed; /* true if there is a part of the result on the stack */ |
400 | | int blen; /* length of partial string in 'space' */ |
401 | | char space[BUFVFS]; /* holds last part of the result */ |
402 | | } BuffFS; |
403 | | |
404 | | |
405 | | /* |
406 | | ** Push given string to the stack, as part of the result, and |
407 | | ** join it to previous partial result if there is one. |
408 | | ** It may call 'luaV_concat' while using one slot from EXTRA_STACK. |
409 | | ** This call cannot invoke metamethods, as both operands must be |
410 | | ** strings. It can, however, raise an error if the result is too |
411 | | ** long. In that case, 'luaV_concat' frees the extra slot before |
412 | | ** raising the error. |
413 | | */ |
414 | 0 | static void pushstr (BuffFS *buff, const char *str, size_t lstr) { |
415 | 0 | lua_State *L = buff->L; |
416 | 0 | setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr)); |
417 | 0 | L->top.p++; /* may use one slot from EXTRA_STACK */ |
418 | 0 | if (!buff->pushed) /* no previous string on the stack? */ |
419 | 0 | buff->pushed = 1; /* now there is one */ |
420 | 0 | else /* join previous string with new one */ |
421 | 0 | luaV_concat(L, 2); |
422 | 0 | } |
423 | | |
424 | | |
425 | | /* |
426 | | ** empty the buffer space into the stack |
427 | | */ |
428 | 0 | static void clearbuff (BuffFS *buff) { |
429 | 0 | pushstr(buff, buff->space, buff->blen); /* push buffer contents */ |
430 | 0 | buff->blen = 0; /* space now is empty */ |
431 | 0 | } |
432 | | |
433 | | |
434 | | /* |
435 | | ** Get a space of size 'sz' in the buffer. If buffer has not enough |
436 | | ** space, empty it. 'sz' must fit in an empty buffer. |
437 | | */ |
438 | 0 | static char *getbuff (BuffFS *buff, int sz) { |
439 | 0 | lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); |
440 | 0 | if (sz > BUFVFS - buff->blen) /* not enough space? */ |
441 | 0 | clearbuff(buff); |
442 | 0 | return buff->space + buff->blen; |
443 | 0 | } |
444 | | |
445 | | |
446 | 0 | #define addsize(b,sz) ((b)->blen += (sz)) |
447 | | |
448 | | |
449 | | /* |
450 | | ** Add 'str' to the buffer. If string is larger than the buffer space, |
451 | | ** push the string directly to the stack. |
452 | | */ |
453 | 0 | static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { |
454 | 0 | if (slen <= BUFVFS) { /* does string fit into buffer? */ |
455 | 0 | char *bf = getbuff(buff, cast_int(slen)); |
456 | 0 | memcpy(bf, str, slen); /* add string to buffer */ |
457 | 0 | addsize(buff, cast_int(slen)); |
458 | 0 | } |
459 | 0 | else { /* string larger than buffer */ |
460 | 0 | clearbuff(buff); /* string comes after buffer's content */ |
461 | 0 | pushstr(buff, str, slen); /* push string */ |
462 | 0 | } |
463 | 0 | } |
464 | | |
465 | | |
466 | | /* |
467 | | ** Add a numeral to the buffer. |
468 | | */ |
469 | 0 | static void addnum2buff (BuffFS *buff, TValue *num) { |
470 | 0 | char *numbuff = getbuff(buff, MAXNUMBER2STR); |
471 | 0 | int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */ |
472 | 0 | addsize(buff, len); |
473 | 0 | } |
474 | | |
475 | | |
476 | | /* |
477 | | ** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%' |
478 | | conventional formats, plus Lua-specific '%I' and '%U' |
479 | | */ |
480 | 0 | const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { |
481 | 0 | BuffFS buff; /* holds last part of the result */ |
482 | 0 | const char *e; /* points to next '%' */ |
483 | 0 | buff.pushed = buff.blen = 0; |
484 | 0 | buff.L = L; |
485 | 0 | while ((e = strchr(fmt, '%')) != NULL) { |
486 | 0 | addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */ |
487 | 0 | switch (*(e + 1)) { /* conversion specifier */ |
488 | 0 | case 's': { /* zero-terminated string */ |
489 | 0 | const char *s = va_arg(argp, char *); |
490 | 0 | if (s == NULL) s = "(null)"; |
491 | 0 | addstr2buff(&buff, s, strlen(s)); |
492 | 0 | break; |
493 | 0 | } |
494 | 0 | case 'c': { /* an 'int' as a character */ |
495 | 0 | char c = cast_uchar(va_arg(argp, int)); |
496 | 0 | addstr2buff(&buff, &c, sizeof(char)); |
497 | 0 | break; |
498 | 0 | } |
499 | 0 | case 'd': { /* an 'int' */ |
500 | 0 | TValue num; |
501 | 0 | setivalue(&num, va_arg(argp, int)); |
502 | 0 | addnum2buff(&buff, &num); |
503 | 0 | break; |
504 | 0 | } |
505 | 0 | case 'I': { /* a 'lua_Integer' */ |
506 | 0 | TValue num; |
507 | 0 | setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt))); |
508 | 0 | addnum2buff(&buff, &num); |
509 | 0 | break; |
510 | 0 | } |
511 | 0 | case 'f': { /* a 'lua_Number' */ |
512 | 0 | TValue num; |
513 | 0 | setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber))); |
514 | 0 | addnum2buff(&buff, &num); |
515 | 0 | break; |
516 | 0 | } |
517 | 0 | case 'p': { /* a pointer */ |
518 | 0 | const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */ |
519 | 0 | char *bf = getbuff(&buff, sz); |
520 | 0 | void *p = va_arg(argp, void *); |
521 | 0 | int len = lua_pointer2str(bf, sz, p); |
522 | 0 | addsize(&buff, len); |
523 | 0 | break; |
524 | 0 | } |
525 | 0 | case 'U': { /* a 'long' as a UTF-8 sequence */ |
526 | 0 | char bf[UTF8BUFFSZ]; |
527 | 0 | int len = luaO_utf8esc(bf, va_arg(argp, long)); |
528 | 0 | addstr2buff(&buff, bf + UTF8BUFFSZ - len, len); |
529 | 0 | break; |
530 | 0 | } |
531 | 0 | case '%': { |
532 | 0 | addstr2buff(&buff, "%", 1); |
533 | 0 | break; |
534 | 0 | } |
535 | 0 | default: { |
536 | 0 | luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", |
537 | 0 | *(e + 1)); |
538 | 0 | } |
539 | 0 | } |
540 | 0 | fmt = e + 2; /* skip '%' and the specifier */ |
541 | 0 | } |
542 | 0 | addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ |
543 | 0 | clearbuff(&buff); /* empty buffer into the stack */ |
544 | 0 | lua_assert(buff.pushed == 1); |
545 | 0 | return getstr(tsvalue(s2v(L->top.p - 1))); |
546 | 0 | } |
547 | | |
548 | | |
549 | 0 | const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { |
550 | 0 | const char *msg; |
551 | 0 | va_list argp; |
552 | 0 | va_start(argp, fmt); |
553 | 0 | msg = luaO_pushvfstring(L, fmt, argp); |
554 | 0 | va_end(argp); |
555 | 0 | return msg; |
556 | 0 | } |
557 | | |
558 | | /* }================================================================== */ |
559 | | |
560 | | |
561 | | #define RETS "..." |
562 | | #define PRE "[string \"" |
563 | 0 | #define POS "\"]" |
564 | | |
565 | 0 | #define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) |
566 | | |
567 | 0 | void luaO_chunkid (char *out, const char *source, size_t srclen) { |
568 | 0 | size_t bufflen = LUA_IDSIZE; /* free space in buffer */ |
569 | 0 | if (*source == '=') { /* 'literal' source */ |
570 | 0 | if (srclen <= bufflen) /* small enough? */ |
571 | 0 | memcpy(out, source + 1, srclen * sizeof(char)); |
572 | 0 | else { /* truncate it */ |
573 | 0 | addstr(out, source + 1, bufflen - 1); |
574 | 0 | *out = '\0'; |
575 | 0 | } |
576 | 0 | } |
577 | 0 | else if (*source == '@') { /* file name */ |
578 | 0 | if (srclen <= bufflen) /* small enough? */ |
579 | 0 | memcpy(out, source + 1, srclen * sizeof(char)); |
580 | 0 | else { /* add '...' before rest of name */ |
581 | 0 | addstr(out, RETS, LL(RETS)); |
582 | 0 | bufflen -= LL(RETS); |
583 | 0 | memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char)); |
584 | 0 | } |
585 | 0 | } |
586 | 0 | else { /* string; format as [string "source"] */ |
587 | 0 | const char *nl = strchr(source, '\n'); /* find first new line (if any) */ |
588 | 0 | addstr(out, PRE, LL(PRE)); /* add prefix */ |
589 | 0 | bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ |
590 | 0 | if (srclen < bufflen && nl == NULL) { /* small one-line source? */ |
591 | 0 | addstr(out, source, srclen); /* keep it */ |
592 | 0 | } |
593 | 0 | else { |
594 | 0 | if (nl != NULL) srclen = nl - source; /* stop at first newline */ |
595 | 0 | if (srclen > bufflen) srclen = bufflen; |
596 | 0 | addstr(out, source, srclen); |
597 | 0 | addstr(out, RETS, LL(RETS)); |
598 | 0 | } |
599 | 0 | memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); |
600 | 0 | } |
601 | 0 | } |
602 | | |