diff -r lua-5.3.2/Makefile lua-5.3.3/Makefile 49c49 < R= $V.2 --- > R= $V.3 diff -r lua-5.3.2/README lua-5.3.3/README 2c2 < This is Lua 5.3.2, released on 25 Nov 2015. --- > This is Lua 5.3.3, released on 30 May 2016. diff -r lua-5.3.2/doc/contents.html lua-5.3.3/doc/contents.html 35c35 < Copyright © 2015 Lua.org, PUC-Rio. --- > Copyright © 2015–2016 Lua.org, PUC-Rio. 611c611 < Wed Jun 3 08:27:30 BRT 2015 --- > Thu Jan 14 10:14:28 BRST 2016 614c614 < Last change: revised for Lua 5.3.1 --- > Last change: revised for Lua 5.3.3 diff -r lua-5.3.2/doc/lua.css lua-5.3.3/doc/lua.css 94a95 > text-transform: lowercase ; 159a161,164 > > img { > background-color: white ; > } diff -r lua-5.3.2/doc/manual.html lua-5.3.3/doc/manual.html 22c22 < Copyright © 2015 Lua.org, PUC-Rio. --- > Copyright © 2015–2016 Lua.org, PUC-Rio. 38c38 < --- > 46,52c46,64 < Lua is an extension programming language designed to support < general procedural programming with data description < facilities. < Lua also offers good support for object-oriented programming, < functional programming, and data-driven programming. < Lua is intended to be used as a powerful, lightweight, < embeddable scripting language for any program that needs one. --- > Lua is a powerful, efficient, lightweight, embeddable scripting language. > It supports procedural programming, > object-oriented programming, functional programming, > data-driven programming, and data description. > > >

> Lua combines simple procedural syntax with powerful data description > constructs based on associative arrays and extensible semantics. > Lua is dynamically typed, > runs by interpreting bytecode with a register-based > virtual machine, > and has automatic memory management with > incremental garbage collection, > making it ideal for configuration, scripting, > and rapid prototyping. > > >

54a67,73 > The Lua distribution includes a host program called lua, > which uses the Lua library to offer a complete, > standalone Lua interpreter, > for interactive or batch use. > Lua is intended to be used both as a powerful, lightweight, > embeddable scripting language for any program that needs one, > and as a powerful but lightweight and efficient stand-alone language. 59c78 < it only works embedded in a host client, --- > it works embedded in a host client, 60a80 > (Frequently, this host is the stand-alone lua program.) 67,69d86 < The Lua distribution includes a sample host program called lua, < which uses the Lua library to offer a complete, standalone Lua interpreter, < for interactive or batch use. 354,355c371,372 < This function is called with the original error message < and returns a new error message. --- > This function is called with the original error object > and returns a new error object. 385c402,403 < The keys in a metatable are derived from the event names; --- > The key for each event in a metatable is a string > with the event name prefixed by two underscores; 387c405 < In the previous example, the event is "add" --- > In the previous example, the key is "__add" 393a412,414 > Lua queries metamethods in metatables using a raw access (see rawget). > So, to retrieve the metamethod for event ev in object o, > Lua does the equivalent to the following code: 394a416,418 >

>      rawget(getmetatable(o) or {}, "__ev")
> 
423,434c447 < A detailed list of events controlled by metatables is given next. < Each operation is identified by its corresponding event name. < The key for each event is a string with its name prefixed by < two underscores, '__'; < for instance, the key for operation "add" is the < string "__add". < Note that queries for metamethods are always raw; < the access to a metamethod does not invoke other metamethods. < < <

< For the unary operators (negation, length, and bitwise not), --- > For the unary operators (negation, length, and bitwise NOT), 442a456,460 >

> A detailed list of events controlled by metatables is given next. > Each operation is identified by its corresponding key. > > 446,448c464,465 <

  • "add": < the + operation. < --- >
  • __add: > the addition (+) operation. 453c470 < If that operand does not define a metamethod for the "__add" event, --- > If that operand does not define a metamethod for __add, 464,467c481,483 <
  • "sub": < the - operation. < < Behavior similar to the "add" operation. --- >
  • __sub: > the subtraction (-) operation. > Behavior similar to the addition operation. 470,473c486,488 <
  • "mul": < the * operation. < < Behavior similar to the "add" operation. --- >
  • __mul: > the multiplication (*) operation. > Behavior similar to the addition operation. 476,479c491,493 <
  • "div": < the / operation. < < Behavior similar to the "add" operation. --- >
  • __div: > the division (/) operation. > Behavior similar to the addition operation. 482,485c496,498 <
  • "mod": < the % operation. < < Behavior similar to the "add" operation. --- >
  • __mod: > the modulo (%) operation. > Behavior similar to the addition operation. 488,491c501,503 <
  • "pow": < the ^ (exponentiation) operation. < < Behavior similar to the "add" operation. --- >
  • __pow: > the exponentiation (^) operation. > Behavior similar to the addition operation. 494,497c506,508 <
  • "unm": < the - (unary minus) operation. < < Behavior similar to the "add" operation. --- >
  • __unm: > the negation (unary -) operation. > Behavior similar to the addition operation. 500,503c511,513 <
  • "idiv": < the // (floor division) operation. < < Behavior similar to the "add" operation. --- >
  • __idiv: > the floor division (//) operation. > Behavior similar to the addition operation. 506,509c516,518 <
  • "band": < the & (bitwise and) operation. < < Behavior similar to the "add" operation, --- >
  • __band: > the bitwise AND (&) operation. > Behavior similar to the addition operation, 515,518c524,526 <
  • "bor": < the | (bitwise or) operation. < < Behavior similar to the "band" operation. --- >
  • __bor: > the bitwise OR (|) operation. > Behavior similar to the bitwise AND operation. 521,524c529,531 <
  • "bxor": < the ~ (bitwise exclusive or) operation. < < Behavior similar to the "band" operation. --- >
  • __bxor: > the bitwise exclusive OR (binary ~) operation. > Behavior similar to the bitwise AND operation. 527,530c534,536 <
  • "bnot": < the ~ (bitwise unary not) operation. < < Behavior similar to the "band" operation. --- >
  • __bnot: > the bitwise NOT (unary ~) operation. > Behavior similar to the bitwise AND operation. 533,536c539,541 <
  • "shl": < the << (bitwise left shift) operation. < < Behavior similar to the "band" operation. --- >
  • __shl: > the bitwise left shift (<<) operation. > Behavior similar to the bitwise AND operation. 539,542c544,546 <
  • "shr": < the >> (bitwise right shift) operation. < < Behavior similar to the "band" operation. --- >
  • __shr: > the bitwise right shift (>>) operation. > Behavior similar to the bitwise AND operation. 545,548c549,551 <
  • "concat": < the .. (concatenation) operation. < < Behavior similar to the "add" operation, --- >
  • __concat: > the concatenation (..) operation. > Behavior similar to the addition operation, 554,556c557,558 <
  • "len": < the # (length) operation. < --- >
  • __len: > the length (#) operation. 569,572c571,573 <
  • "eq": < the == (equal) operation. < < Behavior similar to the "add" operation, --- >
  • __eq: > the equal (==) operation. > Behavior similar to the addition operation, 579,582c580,582 <
  • "lt": < the < (less than) operation. < < Behavior similar to the "add" operation, --- >
  • __lt: > the less than (<) operation. > Behavior similar to the addition operation, 588,590c588,589 <
  • "le": < the <= (less equal) operation. < --- >
  • __le: > the less equal (<=) operation. 593,594c592,593 < First, Lua looks for the "__le" metamethod in both operands, < like in the "lt" operation. --- > First, Lua looks for the __le metamethod in both operands, > like in the less than operation. 596c595 < then it will try the "__lt" event, --- > then it will try the __lt metamethod, 600,601c599,600 < (This use of the "__lt" event can be removed in future versions; < it is also slower than a real "__le" metamethod.) --- > (This use of the __lt event can be removed in future versions; > it is also slower than a real __le metamethod.) 604c603 <
  • "index": --- >
  • __index: 606d604 < 616c614,617 < it is called with table and key as arguments. --- > it is called with table and key as arguments, > and the result of the call > (adjusted to one value) > is the result of the operation. 623c624 <
  • "newindex": --- >
  • __newindex: 625d625 < 644c644 < Whenever there is a "newindex" metamethod, --- > Whenever there is a __newindex metamethod, 651c651 <
  • "call": --- >
  • __call: 653d652 < 659a659,661 > All results of the call > are the result of the operation. > (This is the only metamethod that allows multiple results.) 667c669 < In particular, the "__gc" metamethod works only when this order --- > In particular, the __gc metamethod works only when this order 670a673,681 >

    > Because metatables are regular tables, > they can contain arbitrary fields, > not only the event names defined above. > Some functions in the standard library > (e.g., tostring) > use other fields in metatables for their own purposes. > > 938c949 < plus an error message. --- > plus an error object. 1171c1182 < explicit escape sequences for non-text characters. --- > explicit escape sequences for the non-text characters. 1204c1215 < A numeric constant with a fractional dot or an exponent --- > A numeric constant with a radix point or an exponent 1206c1217,1219 < otherwise it denotes an integer. --- > otherwise, > if its value fits in an integer, > it denotes an integer. 1797c1810 < the unary bitwise not (see §3.4.2), --- > the unary bitwise NOT (see §3.4.2), 1911,1913c1924,1926 <

  • &: bitwise and
  • <
  • |: bitwise or
  • <
  • ~: bitwise exclusive or
  • --- >
  • &: bitwise AND
  • >
  • |: bitwise OR
  • >
  • ~: bitwise exclusive OR
  • 1916c1929 <
  • ~: unary bitwise not
  • --- >
  • ~: unary bitwise NOT
  • 1986a2000,2006 > All conversions from strings to numbers > accept both a dot and the current locale mark > as the radix character. > (The Lua lexer, however, accepts only a dot.) > > >

    2795c2815 < in particular, the error message is at the top of the stack. --- > in particular, the error object is at the top of the stack. 2977,2978c2997,3001 < 'm' means the function may raise memory errors; < 'e' means the function may raise errors; --- > 'm' means the function may raise out-of-memory errors > and errors running a __gc metamethod; > 'e' means the function may raise any errors > (it can run arbitrary Lua code, > either directly or through metamethods); 3105,3108c3128,3131 <

  • LUA_OPBNOT: performs bitwise negation (~)
  • <
  • LUA_OPBAND: performs bitwise and (&)
  • <
  • LUA_OPBOR: performs bitwise or (|)
  • <
  • LUA_OPBXOR: performs bitwise exclusive or (~)
  • --- >
  • LUA_OPBNOT: performs bitwise NOT (~)
  • >
  • LUA_OPBAND: performs bitwise AND (&)
  • >
  • LUA_OPBOR: performs bitwise OR (|)
  • >
  • LUA_OPBXOR: performs bitwise exclusive OR (~)
  • 3427c3450 < [-0, +0, e] --- > [-0, +0, m] 3922c3945 < memory allocation error; --- > memory allocation (out-of-memory) error; 4131c4154 < pushes a single value on the stack (the error message), --- > pushes a single value on the stack (the error object), 4140,4141c4163,4164 < then the error message returned on the stack < is exactly the original error message. --- > then the error object returned on the stack > is exactly the original error object. 4146,4147c4169,4170 < this function will be called with the error message < and its return value will be the message --- > this function will be called with the error object > and its return value will be the object 4153c4176 < information to the error message, such as a stack traceback. --- > information to the error object, such as a stack traceback. 4287c4310 < [-0, +1, m] --- > [-0, +1, e] 4319a4343,4348 >

    > Unlike other push functions, > this function checks for the stack space it needs, > including the slot for its result. > > 4489c4518 < (that is, without calling metamethods). --- > (that is, without calling the __eq metamethod). 4516,4517c4545,4546 < The access is raw; < that is, it does not invoke metamethods. --- > The access is raw, > that is, it does not invoke the __index metamethod. 4536c4565 < that is, it does not invoke metamethods. --- > that is, it does not invoke the __index metamethod. 4587,4588c4616,4617 < The assignment is raw; < that is, it does not invoke metamethods. --- > The assignment is raw, > that is, it does not invoke the __newindex metamethod. 4607,4608c4636,4637 < The assignment is raw; < that is, it does not invoke metamethods. --- > The assignment is raw, > that is, it does not invoke __newindex metamethod. 4707c4736 < The error message is on the top of the stack. --- > The error object is on the top of the stack. 5182c5211 < [-0, +0, v] --- > [-0, +0, –] 5186c5215,5217 < Returns the address of the version number stored in the Lua core. --- > Returns the address of the version number > (a C static variable) > stored in the Lua core. 5290c5321 < from inside a line hook (see §4.9). --- > from inside a line or a count hook (see §4.9). 5292c5323 < (probably in the form of lua_yield), --- > (probably in the form of lua_yield) and no results, 5707c5738 < it is formed by a bitwise or of the constants --- > it is formed by a bitwise OR of the constants 6259c6290 < [-0, +0, –] --- > [-0, +0, v] 6475c6506 < [-0, +1, e] --- > [-0, +1, m] 6486c6517 < [-0, +1, e] --- > [-0, +1, m] 6636a6668,6688 >


    luaL_opt

    > [-0, +0, e] >

    T luaL_opt (L, func, arg, dflt);
    > >

    > This macro is defined as follows: > >

    >      (lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))
    > 

    > In words, if the argument arg is nil or absent, > the macro results in the default dflt. > Otherwise, it results in the result of calling func > with the state L and the argument index arg as > parameters. > Note that it evaluates the expression dflt only if needed. > > > > > 6934c6986 < If the value has a metatable with a "__tostring" field, --- > If the value has a metatable with a __tostring field, 7223c7275 < if the object's metatable has a "__metatable" field, --- > if the object's metatable has a __metatable field, 7427c7479 < without invoking any metamethod. --- > without invoking the __eq metamethod. 7436c7488 < without invoking any metamethod. --- > without invoking the __index metamethod. 7447c7499 < without invoking any metamethod. --- > without invoking the __len metamethod. 7456c7508 < without invoking any metamethod. --- > without invoking the __newindex metamethod. 7492c7544 < If the original metatable has a "__metatable" field, --- > If the original metatable has a __metatable field, 7544c7596 < If the metatable of v has a "__tostring" field, --- > If the metatable of v has a __tostring field, 8186a8239,8241 > > >

    8209c8264,8269 < Option q expects a string. --- > When Lua is compiled with a C89 compiler, > options A and a (hexadecimal floats) > do not support any modifier (flags, width, length). > > >

    8217,8222d8276 <

    < When Lua is compiled with a non-C99 compiler, < options A and a (hexadecimal floats) < do not support any modifier (flags, width, length). < < 8550a8605,8612 > You can put a closing square bracket in a set > by positioning it as the first character in the set. > You can put an hyphen in a set > by positioning it as the first or the last character in the set. > (You can also use an escape for both cases.) > > >

    8928,8929c8990,8991 < Moves elements from table a1 to table a2. < This function performs the equivalent to the following --- > Moves elements from table a1 to table a2, > performing the equivalent to the following 8936a8999,9002 >

    > Returns the destination table a2. > > 9460,9461c9526,9527 < It returns a new file handle, < or, in case of errors, nil plus an error message. --- > In case of success, > it returns a new file handle. 9526c9592,9593 < Returns a handle for a temporary file. --- > In case of success, > returns a handle for a temporary file. 9804,9805c9871,9872 < wday (weekday, Sunday is 1), < yday (day of the year), --- > wday (weekday, 1–7, Sunday is 1), > yday (day of the year, 1–366), 10507a10575,10582 > If the global variable _PROMPT contains a string, > then its value is used as the prompt. > Similarly, if the global variable _PROMPT2 contains a string, > its value is used as the secondary prompt > (issued during incomplete statements). > > >

    10828c10903 < Wed Nov 25 15:19:10 BRST 2015 --- > Mon May 30 13:11:08 BRT 2016 10831c10906 < Last change: revised for Lua 5.3.2 --- > Last change: revised for Lua 5.3.3 diff -r lua-5.3.2/doc/readme.html lua-5.3.3/doc/readme.html 279c279 <

  • integer division --- >
  • floor division 331c331 < Copyright © 1994–2015 Lua.org, PUC-Rio. --- > Copyright © 1994–2016 Lua.org, PUC-Rio. 358c358 < Mon Jun 1 21:48:24 BRT 2015 --- > Tue Feb 2 22:25:27 BRST 2016 361c361 < Last change: revised for Lua 5.3.1 --- > Last change: revised for Lua 5.3.3 diff -r lua-5.3.2/src/lapi.c lua-5.3.3/src/lapi.c 2c2 < ** $Id: lapi.c,v 2.257 2015/11/02 18:48:07 roberto Exp $ --- > ** $Id: lapi.c,v 2.259 2016/02/29 14:27:14 roberto Exp $ 380a381 > luaO_tostring(L, o); 383d383 < luaO_tostring(L, o); 482d481 < luaC_checkGC(L); 485a485 > luaC_checkGC(L); 497d496 < luaC_checkGC(L); 502a502 > luaC_checkGC(L); 512d511 < luaC_checkGC(L); 513a513 > luaC_checkGC(L); 523d522 < luaC_checkGC(L); 526a526 > luaC_checkGC(L); 541d540 < luaC_checkGC(L); 551a551 > luaC_checkGC(L); 588c588 < const TValue *aux; --- > const TValue *slot; 590,591c590,591 < if (luaV_fastget(L, t, str, aux, luaH_getstr)) { < setobj2s(L, L->top, aux); --- > if (luaV_fastget(L, t, str, slot, luaH_getstr)) { > setobj2s(L, L->top, slot); 597c597 < luaV_finishget(L, t, L->top - 1, L->top - 1, aux); --- > luaV_finishget(L, t, L->top - 1, L->top - 1, slot); 629c629 < const TValue *aux; --- > const TValue *slot; 632,633c632,633 < if (luaV_fastget(L, t, n, aux, luaH_getint)) { < setobj2s(L, L->top, aux); --- > if (luaV_fastget(L, t, n, slot, luaH_getint)) { > setobj2s(L, L->top, slot); 639c639 < luaV_finishget(L, t, L->top - 1, L->top - 1, aux); --- > luaV_finishget(L, t, L->top - 1, L->top - 1, slot); 686d685 < luaC_checkGC(L); 691a691 > luaC_checkGC(L); 743c743 < const TValue *aux; --- > const TValue *slot; 746c746 < if (luaV_fastset(L, t, str, aux, luaH_getstr, L->top - 1)) --- > if (luaV_fastset(L, t, str, slot, luaH_getstr, L->top - 1)) 751c751 < luaV_finishset(L, t, L->top - 1, L->top - 2, aux); --- > luaV_finishset(L, t, L->top - 1, L->top - 2, slot); 784c784 < const TValue *aux; --- > const TValue *slot; 788c788 < if (luaV_fastset(L, t, n, aux, luaH_getint, L->top - 1)) --- > if (luaV_fastset(L, t, n, slot, luaH_getint, L->top - 1)) 793c793 < luaV_finishset(L, t, L->top - 1, L->top - 2, aux); --- > luaV_finishset(L, t, L->top - 1, L->top - 2, slot); 1143d1142 < luaC_checkGC(L); 1150a1150 > luaC_checkGC(L); 1186d1185 < luaC_checkGC(L); 1189a1189 > luaC_checkGC(L); diff -r lua-5.3.2/src/lauxlib.c lua-5.3.3/src/lauxlib.c 2c2 < ** $Id: lauxlib.c,v 1.284 2015/11/19 19:16:22 roberto Exp $ --- > ** $Id: lauxlib.c,v 1.286 2016/01/08 15:33:09 roberto Exp $ 20c20,21 < /* This file uses only the official API of Lua. --- > /* > ** This file uses only the official API of Lua. 200a202,205 > /* > ** The use of 'lua_pushfstring' ensures this function does not > ** need reserved stack space when called. > */ 210c215 < lua_pushliteral(L, ""); /* else, no information available... */ --- > lua_pushfstring(L, ""); /* else, no information available... */ 213a219,223 > /* > ** Again, the use of 'lua_pushvfstring' ensures this function does > ** not need reserved stack space when called. (At worst, it generates > ** an error with "stack overflow" instead of the given message.) > */ 351a362,368 > /* > ** Ensures the stack has at least 'space' extra slots, raising an error > ** if it cannot fulfill the request. (The error handling needs a few > ** extra slots to format the error message. In case of an error without > ** this extra space, Lua will generate the same 'stack overflow' error, > ** but without 'msg'.) > */ 353,355c370 < /* keep some extra space to run error routines, if needed */ < const int extra = LUA_MINSTACK; < if (!lua_checkstack(L, space + extra)) { --- > if (!lua_checkstack(L, space)) { 681c696 < } while (c != EOF && c != '\n') ; --- > } while (c != EOF && c != '\n'); diff -r lua-5.3.2/src/lbaselib.c lua-5.3.3/src/lbaselib.c 2c2 < ** $Id: lbaselib.c,v 1.312 2015/10/29 15:21:04 roberto Exp $ --- > ** $Id: lbaselib.c,v 1.313 2016/04/11 19:18:40 roberto Exp $ 105,106c105,106 < if (lua_isstring(L, 1) && level > 0) { /* add extra information? */ < luaL_where(L, level); --- > if (lua_type(L, 1) == LUA_TSTRING && level > 0) { > luaL_where(L, level); /* add extra information */ 254,256c254,255 < ** This function will use either 'ipairsaux' or 'ipairsaux_raw' to < ** traverse a table, depending on whether the table has metamethods < ** that can affect the traversal. --- > ** 'ipairs' function. Returns 'ipairsaux', given "table", 0. > ** (The given "table" may not be a table.) diff -r lua-5.3.2/src/lcode.c lua-5.3.3/src/lcode.c 2c2 < ** $Id: lcode.c,v 2.103 2015/11/19 19:16:22 roberto Exp $ --- > ** $Id: lcode.c,v 2.109 2016/05/13 19:09:21 roberto Exp $ 38a39,42 > /* > ** If expression is a numeric constant, fills 'v' with its value > ** and returns 1. Otherwise, returns 0. > */ 53a58,63 > /* > ** Create a OP_LOADNIL instruction, but try to optimize: if the previous > ** instruction is also OP_LOADNIL and ranges are compatible, adjust > ** range of previous instruction instead of emitting a new one. (For > ** instance, 'local a; local b' will generate a single opcode.) > */ 59,60c69,70 < if (GET_OPCODE(*previous) == OP_LOADNIL) { < int pfrom = GETARG_A(*previous); --- > if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ > int pfrom = GETARG_A(*previous); /* get previous range */ 75a86,135 > /* > ** Gets the destination address of a jump instruction. Used to traverse > ** a list of jumps. > */ > static int getjump (FuncState *fs, int pc) { > int offset = GETARG_sBx(fs->f->code[pc]); > if (offset == NO_JUMP) /* point to itself represents end of list */ > return NO_JUMP; /* end of list */ > else > return (pc+1)+offset; /* turn offset into absolute position */ > } > > > /* > ** Fix jump instruction at position 'pc' to jump to 'dest'. > ** (Jump addresses are relative in Lua) > */ > static void fixjump (FuncState *fs, int pc, int dest) { > Instruction *jmp = &fs->f->code[pc]; > int offset = dest - (pc + 1); > lua_assert(dest != NO_JUMP); > if (abs(offset) > MAXARG_sBx) > luaX_syntaxerror(fs->ls, "control structure too long"); > SETARG_sBx(*jmp, offset); > } > > > /* > ** Concatenate jump-list 'l2' into jump-list 'l1' > */ > void luaK_concat (FuncState *fs, int *l1, int l2) { > if (l2 == NO_JUMP) return; /* nothing to concatenate? */ > else if (*l1 == NO_JUMP) /* no original list? */ > *l1 = l2; /* 'l1' points to 'l2' */ > else { > int list = *l1; > int next; > while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ > list = next; > fixjump(fs, list, l2); /* last element links to 'l2' */ > } > } > > > /* > ** Create a jump instruction and return its position, so its destination > ** can be fixed later (with 'fixjump'). If there are jumps to > ** this position (kept in 'jpc'), link them all together so that > ** 'patchlistaux' will fix all them directly to the final destination. > */ 79c139 < fs->jpc = NO_JUMP; --- > fs->jpc = NO_JUMP; /* no more jumps to here */ 85a146,148 > /* > ** Code a 'return' instruction > */ 90a154,157 > /* > ** Code a "conditional jump", that is, a test or comparison opcode > ** followed by a jump. Return jump position. > */ 97,106d163 < static void fixjump (FuncState *fs, int pc, int dest) { < Instruction *jmp = &fs->f->code[pc]; < int offset = dest-(pc+1); < lua_assert(dest != NO_JUMP); < if (abs(offset) > MAXARG_sBx) < luaX_syntaxerror(fs->ls, "control structure too long"); < SETARG_sBx(*jmp, offset); < } < < 117,125c174,178 < static int getjump (FuncState *fs, int pc) { < int offset = GETARG_sBx(fs->f->code[pc]); < if (offset == NO_JUMP) /* point to itself represents end of list */ < return NO_JUMP; /* end of list */ < else < return (pc+1)+offset; /* turn offset into absolute position */ < } < < --- > /* > ** Returns the position of the instruction "controlling" a given > ** jump (that is, its condition), or the jump itself if it is > ** unconditional. > */ 136,137c189,193 < ** check whether list has any jump that do not produce a value < ** (or produce an inverted value) --- > ** Patch destination register for a TESTSET instruction. > ** If instruction in position 'node' is not a TESTSET, return 0 ("fails"). > ** Otherwise, if 'reg' is not 'NO_REG', set it as the destination > ** register. Otherwise, change instruction to a simple 'TEST' (produces > ** no register value) 139,147d194 < static int need_value (FuncState *fs, int list) { < for (; list != NO_JUMP; list = getjump(fs, list)) { < Instruction i = *getjumpcontrol(fs, list); < if (GET_OPCODE(i) != OP_TESTSET) return 1; < } < return 0; /* not found */ < } < < 154c201,203 < else /* no register to put value or register already has the value */ --- > else { > /* no register to put value or register already has the value; > change instruction to simple test */ 156c205 < --- > } 160a210,212 > /* > ** Traverse a list of tests ensuring no one produces a value > */ 166a219,223 > /* > ** Traverse a list of tests, patching their destination address and > ** registers: tests producing values jump to 'vtarget' (and put their > ** values in 'reg'), other tests jump to 'dtarget'. > */ 179a237,241 > /* > ** Ensure all pending jumps to current position are fixed (jumping > ** to current position with no values) and reset list of pending > ** jumps > */ 185a248,262 > /* > ** Add elements in 'list' to list of pending jumps to "here" > ** (current position) > */ > void luaK_patchtohere (FuncState *fs, int list) { > luaK_getlabel(fs); /* mark "here" as a jump target */ > luaK_concat(fs, &fs->jpc, list); > } > > > /* > ** Path all jumps in 'list' to jump to 'target'. > ** (The assert means that we cannot fix a jump to a forward address > ** because we only know addresses once code is generated.) > */ 187,188c264,265 < if (target == fs->pc) < luaK_patchtohere(fs, list); --- > if (target == fs->pc) /* 'target' is current position? */ > luaK_patchtohere(fs, list); /* add list to pending jumps */ 195a273,277 > /* > ** Path all jumps in 'list' to close upvalues up to given 'level' > ** (The assertion checks that jumps either were closing nothing > ** or were closing higher levels, from inner blocks.) > */ 198,199c280 < while (list != NO_JUMP) { < int next = getjump(fs, list); --- > for (; list != NO_JUMP; list = getjump(fs, list)) { 204,224d284 < list = next; < } < } < < < void luaK_patchtohere (FuncState *fs, int list) { < luaK_getlabel(fs); < luaK_concat(fs, &fs->jpc, list); < } < < < void luaK_concat (FuncState *fs, int *l1, int l2) { < if (l2 == NO_JUMP) return; < else if (*l1 == NO_JUMP) < *l1 = l2; < else { < int list = *l1; < int next; < while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ < list = next; < fixjump(fs, list, l2); 228a289,292 > /* > ** Emit instruction 'i', checking for array sizes and saving also its > ** line information. Return 'i' position. > */ 243a308,311 > /* > ** Format and emit an 'iABC' instruction. (Assertions check consistency > ** of parameters versus opcode.) > */ 252a321,323 > /* > ** Format and emit an 'iABx' instruction. > */ 260a332,334 > /* > ** Emit an "extra argument" instruction (format 'iAx') > */ 266a341,345 > /* > ** Emit a "load constant" instruction, using either 'OP_LOADK' > ** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX' > ** instruction with "extra argument". > */ 277a357,360 > /* > ** Check register-stack level, keeping track of its maximum size > ** in field 'maxstacksize' > */ 288a372,374 > /* > ** Reserve 'n' registers in register stack > */ 294a381,385 > /* > ** Free register 'reg', if it is neither a constant index nor > ** a local variable. > ) > */ 302a394,396 > /* > ** Free register used by expression 'e' (if any) > */ 309a404,422 > ** Free registers used by expressions 'e1' and 'e2' (if any) in proper > ** order. > */ > static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { > int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; > int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; > if (r1 > r2) { > freereg(fs, r1); > freereg(fs, r2); > } > else { > freereg(fs, r2); > freereg(fs, r1); > } > } > > > /* > ** Add constant 'v' to prototype's list of constants (field 'k'). 311c424,426 < ** and try to reuse constants --- > ** and try to reuse constants. Because some values should not be used > ** as keys (nil cannot be a key, integer keys can collapse with float > ** keys), the caller must provide a useful 'key' for indexing the cache. 339a455,457 > /* > ** Add a string to list of constants and return its index. > */ 343c461 < return addk(fs, &o, &o); --- > return addk(fs, &o, &o); /* use string itself as key */ 348,350c466,469 < ** Integers use userdata as keys to avoid collision with floats with same < ** value; conversion to 'void*' used only for hashing, no "precision" < ** problems --- > ** Add an integer to list of constants and return its index. > ** Integers use userdata as keys to avoid collision with floats with > ** same value; conversion to 'void*' is used only for hashing, so there > ** are no "precision" problems. 359c478,480 < --- > /* > ** Add a float to list of constants and return its index. > */ 363c484 < return addk(fs, &o, &o); --- > return addk(fs, &o, &o); /* use number itself as key */ 366a488,490 > /* > ** Add a boolean to list of constants and return its index. > */ 370c494 < return addk(fs, &o, &o); --- > return addk(fs, &o, &o); /* use boolean itself as key */ 373a498,500 > /* > ** Add nil to list of constants and return its index. > */ 382a510,514 > /* > ** Fix an expression to return the number of results 'nresults'. > ** Either 'e' is a multi-ret expression (function call or vararg) > ** or 'nresults' is LUA_MULTRET (as any expression can satisfy that). > */ 385c517 < SETARG_C(getcode(fs, e), nresults+1); --- > SETARG_C(getinstruction(fs, e), nresults + 1); 388,389c520,522 < SETARG_B(getcode(fs, e), nresults+1); < SETARG_A(getcode(fs, e), fs->freereg); --- > Instruction *pc = &getinstruction(fs, e); > SETARG_B(*pc, nresults + 1); > SETARG_A(*pc, fs->freereg); 391a525 > else lua_assert(nresults == LUA_MULTRET); 394a529,538 > /* > ** Fix an expression to return one result. > ** If expression is not a multi-ret expression (function call or > ** vararg), it already returns one result, so nothing needs to be done. > ** Function calls become VNONRELOC expressions (as its result comes > ** fixed in the base register of the call), while vararg expressions > ** become VRELOCABLE (as OP_VARARG puts its results where it wants). > ** (Calls are created returning one result, so that does not need > ** to be fixed.) > */ 397,398c541,544 < e->k = VNONRELOC; < e->u.info = GETARG_A(getcode(fs, e)); --- > /* already returns 1 value */ > lua_assert(GETARG_C(getinstruction(fs, e)) == 2); > e->k = VNONRELOC; /* result has fixed position */ > e->u.info = GETARG_A(getinstruction(fs, e)); 401c547 < SETARG_B(getcode(fs, e), 2); --- > SETARG_B(getinstruction(fs, e), 2); 406a553,555 > /* > ** Ensure that expression 'e' is not a variable. > */ 409,410c558,559 < case VLOCAL: { < e->k = VNONRELOC; --- > case VLOCAL: { /* already in a register */ > e->k = VNONRELOC; /* becomes a non-relocatable value */ 413c562 < case VUPVAL: { --- > case VUPVAL: { /* move value to some (pending) register */ 419c568 < OpCode op = OP_GETTABUP; /* assume 't' is in an upvalue */ --- > OpCode op; 421c570 < if (e->u.ind.vt == VLOCAL) { /* 't' is in a register? */ --- > if (e->u.ind.vt == VLOCAL) { /* is 't' in a register? */ 424a574,577 > else { > lua_assert(e->u.ind.vt == VUPVAL); > op = OP_GETTABUP; /* 't' is in an upvalue */ > } 429,430c582 < case VVARARG: < case VCALL: { --- > case VVARARG: case VCALL: { 439,444c591,594 < static int code_label (FuncState *fs, int A, int b, int jump) { < luaK_getlabel(fs); /* those instructions may be jump targets */ < return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump); < } < < --- > /* > ** Ensures expression value is in register 'reg' (and therefore > ** 'e' will become a non-relocatable expression). > */ 469,470c619,620 < Instruction *pc = &getcode(fs, e); < SETARG_A(*pc, reg); --- > Instruction *pc = &getinstruction(fs, e); > SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ 479c629 < lua_assert(e->k == VVOID || e->k == VJMP); --- > lua_assert(e->k == VJMP); 487a638,640 > /* > ** Ensures expression value is in any register. > */ 489,491c642,662 < if (e->k != VNONRELOC) { < luaK_reserveregs(fs, 1); < discharge2reg(fs, e, fs->freereg-1); --- > if (e->k != VNONRELOC) { /* no fixed register yet? */ > luaK_reserveregs(fs, 1); /* get a register */ > discharge2reg(fs, e, fs->freereg-1); /* put value there */ > } > } > > > static int code_loadbool (FuncState *fs, int A, int b, int jump) { > luaK_getlabel(fs); /* those instructions may be jump targets */ > return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump); > } > > > /* > ** check whether list has any jump that do not produce a value > ** or produce an inverted value > */ > static int need_value (FuncState *fs, int list) { > for (; list != NO_JUMP; list = getjump(fs, list)) { > Instruction i = *getjumpcontrol(fs, list); > if (GET_OPCODE(i) != OP_TESTSET) return 1; 492a664 > return 0; /* not found */ 495a668,674 > /* > ** Ensures final expression result (including results from its jump > ** lists) is in register 'reg'. > ** If expression has jumps, need to patch these jumps either to > ** its final position or to "load" instructions (for those tests > ** that do not produce values). > */ 498c677 < if (e->k == VJMP) --- > if (e->k == VJMP) /* expression itself is a test? */ 506,507c685,686 < p_f = code_label(fs, reg, 0, 1); < p_t = code_label(fs, reg, 1, 0); --- > p_f = code_loadbool(fs, reg, 0, 1); > p_t = code_loadbool(fs, reg, 1, 0); 519a699,702 > /* > ** Ensures final expression result (including results from its jump > ** lists) is in next available register. > */ 527a711,714 > /* > ** Ensures final expression result (including results from its jump > ** lists) is in some (any) register and return that register. > */ 530,531c717,719 < if (e->k == VNONRELOC) { < if (!hasjumps(e)) return e->u.info; /* exp is already in a register */ --- > if (e->k == VNONRELOC) { /* expression already has a register? */ > if (!hasjumps(e)) /* no jumps? */ > return e->u.info; /* result is already in a register */ 533c721 < exp2reg(fs, e, e->u.info); /* put value on it */ --- > exp2reg(fs, e, e->u.info); /* put final result in it */ 537c725 < luaK_exp2nextreg(fs, e); /* default */ --- > luaK_exp2nextreg(fs, e); /* otherwise, use next available register */ 541a730,733 > /* > ** Ensures final expression result is either in a register or in an > ** upvalue. > */ 547a740,743 > /* > ** Ensures final expression result is either in a register or it is > ** a constant. > */ 555a752,757 > /* > ** Ensures final expression result is in a valid R/K index > ** (that is, it is either in a register or in 'k' with an index > ** in the range of R/K indices). > ** Returns R/K index. > */ 558,579c760,766 < switch (e->k) { < case VTRUE: < case VFALSE: < case VNIL: { < if (fs->nk <= MAXINDEXRK) { /* constant fits in RK operand? */ < e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE)); < e->k = VK; < return RKASK(e->u.info); < } < else break; < } < case VKINT: { < e->u.info = luaK_intK(fs, e->u.ival); < e->k = VK; < goto vk; < } < case VKFLT: { < e->u.info = luaK_numberK(fs, e->u.nval); < e->k = VK; < } < /* FALLTHROUGH */ < case VK: { --- > switch (e->k) { /* move constants to 'k' */ > case VTRUE: e->u.info = boolK(fs, 1); goto vk; > case VFALSE: e->u.info = boolK(fs, 0); goto vk; > case VNIL: e->u.info = nilK(fs); goto vk; > case VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk; > case VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk; > case VK: 580a768 > e->k = VK; 584d771 < } 591a779,781 > /* > ** Generate code to store result of expression 'ex' into variable 'var'. > */ 596c786 < exp2reg(fs, ex, var->u.info); --- > exp2reg(fs, ex, var->u.info); /* compute 'ex' into proper place */ 610,613c800 < default: { < lua_assert(0); /* invalid var kind to store */ < break; < } --- > default: lua_assert(0); /* invalid var kind to store */ 618a806,808 > /* > ** Emit SELF instruction (convert expression 'e' into 'e:key(e,'). > */ 625c815 < e->k = VNONRELOC; --- > e->k = VNONRELOC; /* self expression has a fixed register */ 632c822,825 < static void invertjump (FuncState *fs, expdesc *e) { --- > /* > ** Negate condition 'e' (where 'e' is a comparison). > */ > static void negatecondition (FuncState *fs, expdesc *e) { 639a833,838 > /* > ** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond' > ** is true, code will jump if 'e' is true.) Return jump position. > ** Optimize when 'e' is 'not' something, inverting the condition > ** and removing the 'not'. > */ 642c841 < Instruction ie = getcode(fs, e); --- > Instruction ie = getinstruction(fs, e); 654a854,856 > /* > ** Emit code to go through if 'e' is true, jump otherwise. > */ 656c858 < int pc; /* pc of last jump */ --- > int pc; /* pc of new jump */ 659,661c861,863 < case VJMP: { < invertjump(fs, e); < pc = e->u.info; --- > case VJMP: { /* condition? */ > negatecondition(fs, e); /* jump when it is false */ > pc = e->u.info; /* save jump position */ 669c871 < pc = jumponcond(fs, e, 0); --- > pc = jumponcond(fs, e, 0); /* jump when false */ 673,674c875,876 < luaK_concat(fs, &e->f, pc); /* insert last jump in 'f' list */ < luaK_patchtohere(fs, e->t); --- > luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ > luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ 678a881,883 > /* > ** Emit code to go through if 'e' is false, jump otherwise. > */ 680c885 < int pc; /* pc of last jump */ --- > int pc; /* pc of new jump */ 684c889 < pc = e->u.info; --- > pc = e->u.info; /* already jump if true */ 692c897 < pc = jumponcond(fs, e, 1); --- > pc = jumponcond(fs, e, 1); /* jump if true */ 696,697c901,902 < luaK_concat(fs, &e->t, pc); /* insert last jump in 't' list */ < luaK_patchtohere(fs, e->f); --- > luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ > luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ 701a907,909 > /* > ** Code 'not e', doing constant folding. > */ 706c914 < e->k = VTRUE; --- > e->k = VTRUE; /* true == not nil == not false */ 710c918 < e->k = VFALSE; --- > e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ 714c922 < invertjump(fs, e); --- > negatecondition(fs, e); 725,728c933 < default: { < lua_assert(0); /* cannot happen */ < break; < } --- > default: lua_assert(0); /* cannot happen */ 732c937 < removevalues(fs, e->f); --- > removevalues(fs, e->f); /* values are useless when negated */ 736a942,945 > /* > ** Create expression 't[k]'. 't' must have its final result already in a > ** register or upvalue. > */ 738,742c947,950 < lua_assert(!hasjumps(t)); < t->u.ind.t = t->u.info; < t->u.ind.idx = luaK_exp2RK(fs, k); < t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL < : check_exp(vkisinreg(t->k), VLOCAL); --- > lua_assert(!hasjumps(t) && (vkisinreg(t->k) || t->k == VUPVAL)); > t->u.ind.t = t->u.info; /* register or upvalue index */ > t->u.ind.idx = luaK_exp2RK(fs, k); /* R/K index for key */ > t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL : VLOCAL; 748c956,958 < ** return false if folding can raise an error --- > ** Return false if folding can raise an error. > ** Bitwise operations need operands convertible to integers; division > ** operations cannot have 0 as divisor. 765c975,976 < ** Try to "constant-fold" an operation; return 1 iff successful --- > ** Try to "constant-fold" an operation; return 1 iff successful. > ** (In this case, 'e1' has the final result.) 776c987 < else { /* folds neither NaN nor 0.0 (to avoid collapsing with -0.0) */ --- > else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ 788,791c999,1015 < ** Code for binary and unary expressions that "produce values" < ** (arithmetic operations, bitwise operations, concat, length). First < ** try to do constant folding (only for numeric [arithmetic and < ** bitwise] operations, which is what 'lua_arith' accepts). --- > ** Emit code for unary expressions that "produce values" > ** (everything but 'not'). > ** Expression to produce final result will be encoded in 'e'. > */ > static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { > int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ > freeexp(fs, e); > e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ > e->k = VRELOCABLE; /* all those operations are relocatable */ > luaK_fixline(fs, line); > } > > > /* > ** Emit code for binary expressions that "produce values" > ** (everything but logical operators 'and'/'or' and comparison > ** operators). 794,821c1018,1025 < static void codeexpval (FuncState *fs, OpCode op, < expdesc *e1, expdesc *e2, int line) { < lua_assert(op >= OP_ADD); < if (op <= OP_BNOT && constfolding(fs, (op - OP_ADD) + LUA_OPADD, e1, e2)) < return; /* result has been folded */ < else { < int o1, o2; < /* move operands to registers (if needed) */ < if (op == OP_UNM || op == OP_BNOT || op == OP_LEN) { /* unary op? */ < o2 = 0; /* no second expression */ < o1 = luaK_exp2anyreg(fs, e1); /* cannot operate on constants */ < } < else { /* regular case (binary operators) */ < o2 = luaK_exp2RK(fs, e2); /* both operands are "RK" */ < o1 = luaK_exp2RK(fs, e1); < } < if (o1 > o2) { /* free registers in proper order */ < freeexp(fs, e1); < freeexp(fs, e2); < } < else { < freeexp(fs, e2); < freeexp(fs, e1); < } < e1->u.info = luaK_codeABC(fs, op, 0, o1, o2); /* generate opcode */ < e1->k = VRELOCABLE; /* all those operations are relocatable */ < luaK_fixline(fs, line); < } --- > static void codebinexpval (FuncState *fs, OpCode op, > expdesc *e1, expdesc *e2, int line) { > int rk1 = luaK_exp2RK(fs, e1); /* both operands are "RK" */ > int rk2 = luaK_exp2RK(fs, e2); > freeexps(fs, e1, e2); > e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2); /* generate opcode */ > e1->k = VRELOCABLE; /* all those operations are relocatable */ > luaK_fixline(fs, line); 825,834c1029,1053 < static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1, < expdesc *e2) { < int o1 = luaK_exp2RK(fs, e1); < int o2 = luaK_exp2RK(fs, e2); < freeexp(fs, e2); < freeexp(fs, e1); < if (cond == 0 && op != OP_EQ) { < int temp; /* exchange args to replace by '<' or '<=' */ < temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */ < cond = 1; --- > /* > ** Emit code for comparisons. > ** 'e1' was already put in R/K form by 'luaK_infix'. > */ > static void codecomp (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { > int rk1 = (e1->k == VK) ? RKASK(e1->u.info) > : check_exp(e1->k == VNONRELOC, e1->u.info); > int rk2 = luaK_exp2RK(fs, e2); > freeexps(fs, e1, e2); > switch (opr) { > case OPR_NE: { /* '(a ~= b)' ==> 'not (a == b)' */ > e1->u.info = condjump(fs, OP_EQ, 0, rk1, rk2); > break; > } > case OPR_GT: case OPR_GE: { > /* '(a > b)' ==> '(b < a)'; '(a >= b)' ==> '(b <= a)' */ > OpCode op = cast(OpCode, (opr - OPR_NE) + OP_EQ); > e1->u.info = condjump(fs, op, 1, rk2, rk1); /* invert operands */ > break; > } > default: { /* '==', '<', '<=' use their own opcodes */ > OpCode op = cast(OpCode, (opr - OPR_EQ) + OP_EQ); > e1->u.info = condjump(fs, op, 1, rk1, rk2); > break; > } 836d1054 < e1->u.info = condjump(fs, op, cond, o1, o2); 840a1059,1061 > /* > ** Aplly prefix operation 'op' to expression 'e'. > */ 842,843c1063 < expdesc e2; < e2.t = e2.f = NO_JUMP; e2.k = VKINT; e2.u.ival = 0; --- > static expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; /* fake 2nd operand */ 845,846c1065,1070 < case OPR_MINUS: case OPR_BNOT: case OPR_LEN: { < codeexpval(fs, cast(OpCode, (op - OPR_MINUS) + OP_UNM), e, &e2, line); --- > case OPR_MINUS: case OPR_BNOT: > if (constfolding(fs, op + LUA_OPUNM, e, &ef)) > break; > /* FALLTHROUGH */ > case OPR_LEN: > codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line); 848d1071 < } 854a1078,1081 > /* > ** Process 1st operand 'v' of binary operation 'op' before reading > ** 2nd operand. > */ 858c1085 < luaK_goiftrue(fs, v); --- > luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ 862c1089 < luaK_goiffalse(fs, v); --- > luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ 874c1101,1103 < if (!tonumeral(v, NULL)) luaK_exp2RK(fs, v); --- > if (!tonumeral(v, NULL)) > luaK_exp2RK(fs, v); > /* else keep numeral, which may be folded with 2nd operand */ 884a1114,1119 > /* > ** Finalize code for binary operation, after reading 2nd operand. > ** For '(a .. b .. c)' (which is '(a .. (b .. c))', because > ** concatenation is right associative), merge second CONCAT into first > ** one. > */ 889c1124 < lua_assert(e1->t == NO_JUMP); /* list must be closed */ --- > lua_assert(e1->t == NO_JUMP); /* list closed by 'luK_infix' */ 896c1131 < lua_assert(e1->f == NO_JUMP); /* list must be closed */ --- > lua_assert(e1->f == NO_JUMP); /* list closed by 'luK_infix' */ 904,905c1139,1141 < if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) { < lua_assert(e1->u.info == GETARG_B(getcode(fs, e2))-1); --- > if (e2->k == VRELOCABLE && > GET_OPCODE(getinstruction(fs, e2)) == OP_CONCAT) { > lua_assert(e1->u.info == GETARG_B(getinstruction(fs, e2))-1); 907c1143 < SETARG_B(getcode(fs, e2), e1->u.info); --- > SETARG_B(getinstruction(fs, e2), e1->u.info); 912c1148 < codeexpval(fs, OP_CONCAT, e1, e2, line); --- > codebinexpval(fs, OP_CONCAT, e1, e2, line); 920,924c1156,1157 < codeexpval(fs, cast(OpCode, (op - OPR_ADD) + OP_ADD), e1, e2, line); < break; < } < case OPR_EQ: case OPR_LT: case OPR_LE: { < codecomp(fs, cast(OpCode, (op - OPR_EQ) + OP_EQ), 1, e1, e2); --- > if (!constfolding(fs, op + LUA_OPADD, e1, e2)) > codebinexpval(fs, cast(OpCode, op + OP_ADD), e1, e2, line); 926a1160 > case OPR_EQ: case OPR_LT: case OPR_LE: 928c1162 < codecomp(fs, cast(OpCode, (op - OPR_NE) + OP_EQ), 0, e1, e2); --- > codecomp(fs, op, e1, e2); 935a1170,1172 > /* > ** Change line information associated with current position. > */ 940a1178,1184 > /* > ** Emit a SETLIST instruction. > ** 'base' is register that keeps table; > ** 'nelems' is #table plus those to be stored now; > ** 'tostore' is number of values (in registers 'base + 1',...) to add to > ** table (or LUA_MULTRET to add up to stack top). > */ 944c1188 < lua_assert(tostore != 0); --- > lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH); diff -r lua-5.3.2/src/lcode.h lua-5.3.3/src/lcode.h 2c2 < ** $Id: lcode.h,v 1.63 2013/12/30 20:47:58 roberto Exp $ --- > ** $Id: lcode.h,v 1.64 2016/01/05 16:22:37 roberto Exp $ 43c43,44 < #define getcode(fs,e) ((fs)->f->code[(e)->u.info]) --- > /* get (pointer to) instruction of given 'expdesc' */ > #define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) diff -r lua-5.3.2/src/lcorolib.c lua-5.3.3/src/lcorolib.c 2c2 < ** $Id: lcorolib.c,v 1.9 2014/11/02 19:19:04 roberto Exp $ --- > ** $Id: lcorolib.c,v 1.10 2016/04/11 19:19:55 roberto Exp $ 78c78 < if (lua_isstring(L, -1)) { /* error object is a string? */ --- > if (lua_type(L, -1) == LUA_TSTRING) { /* error object is a string? */ diff -r lua-5.3.2/src/ldebug.c lua-5.3.3/src/ldebug.c 2c2 < ** $Id: ldebug.c,v 2.117 2015/11/02 18:48:07 roberto Exp $ --- > ** $Id: ldebug.c,v 2.120 2016/03/31 19:01:21 roberto Exp $ 72c72,78 < ** this function can be called asynchronous (e.g. during a signal) --- > ** This function can be called asynchronously (e.g. during a signal). > ** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by > ** 'resethookcount') are for debug only, and it is no problem if they > ** get arbitrary values (causes at most one wrong hook call). 'hookmask' > ** is an atomic value. We assume that pointers are atomic too (e.g., gcc > ** ensures that for all platforms where it runs). Moreover, 'hook' is > ** always checked before being called (see 'luaD_hook'). 561c567 < const char *t = objtypename(o); --- > const char *t = luaT_objtypename(L, o); 593,595c599,601 < const char *t1 = objtypename(p1); < const char *t2 = objtypename(p2); < if (t1 == t2) --- > const char *t1 = luaT_objtypename(L, p1); > const char *t2 = luaT_objtypename(L, p2); > if (strcmp(t1, t2) == 0) diff -r lua-5.3.2/src/ldo.c lua-5.3.3/src/ldo.c 2c2 < ** $Id: ldo.c,v 2.150 2015/11/19 19:16:22 roberto Exp $ --- > ** $Id: ldo.c,v 2.151 2015/12/16 16:40:07 roberto Exp $ 244a245,249 > /* > ** Call a hook for the given event. Make sure there is a hook to be > ** called. (Both 'L->hook' and 'L->hookmask', which triggers this > ** function, can be changed asynchronously by signals.) > */ 247c252 < if (hook && L->allowhook) { --- > if (hook && L->allowhook) { /* make sure there is a hook */ diff -r lua-5.3.2/src/ldo.h lua-5.3.3/src/ldo.h 2c2 < ** $Id: ldo.h,v 2.28 2015/11/23 11:29:43 roberto Exp $ --- > ** $Id: ldo.h,v 2.29 2015/12/21 13:02:14 roberto Exp $ 28c28 < #define luaD_checkstack(L,n) luaD_checkstackaux(L,n,,) --- > #define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) diff -r lua-5.3.2/src/lgc.c lua-5.3.3/src/lgc.c 2c2 < ** $Id: lgc.c,v 2.210 2015/11/03 18:10:44 roberto Exp $ --- > ** $Id: lgc.c,v 2.212 2016/03/31 19:02:03 roberto Exp $ 757c757 < static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) { --- > static GCObject **sweeptolive (lua_State *L, GCObject **p) { 759d758 < int i = 0; 761d759 < i++; 764d761 < if (n) *n += i; 859c856 < static void callallpendingfinalizers (lua_State *L, int propagateerrors) { --- > static void callallpendingfinalizers (lua_State *L) { 862c859 < GCTM(L, propagateerrors); --- > GCTM(L, 0); 912c909 < g->sweepgc = sweeptolive(L, g->sweepgc, NULL); /* change 'sweepgc' */ --- > g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */ 954,958c951,954 < ** The call to 'sweeptolive' makes pointer point to an object inside < ** the list (instead of to the header), so that the real sweep do not < ** need to skip objects created between "now" and the start of the real < ** sweep. < ** Returns how many objects it swept. --- > ** The call to 'sweeplist' tries to make pointer point to an object > ** inside the list (instead of to the header), so that the real sweep do > ** not need to skip objects created between "now" and the start of the > ** real sweep. 960c956 < static int entersweep (lua_State *L) { --- > static void entersweep (lua_State *L) { 962d957 < int n = 0; 965,966c960 < g->sweepgc = sweeptolive(L, &g->allgc, &n); < return n; --- > g->sweepgc = sweeplist(L, &g->allgc, 1); 974c968 < callallpendingfinalizers(L, 0); --- > callallpendingfinalizers(L); 1067d1060 < int sw; 1070c1063 < sw = entersweep(L); --- > entersweep(L); 1072c1065 < return work + sw * GCSWEEPCOST; --- > return work; diff -r lua-5.3.2/src/lgc.h lua-5.3.3/src/lgc.h 2c2 < ** $Id: lgc.h,v 2.90 2015/10/21 18:15:15 roberto Exp $ --- > ** $Id: lgc.h,v 2.91 2015/12/21 13:02:14 roberto Exp $ 115c115 < #define luaC_checkGC(L) luaC_condGC(L,,) --- > #define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) diff -r lua-5.3.2/src/liolib.c lua-5.3.3/src/liolib.c 2c2 < ** $Id: liolib.c,v 2.148 2015/11/23 11:36:11 roberto Exp $ --- > ** $Id: liolib.c,v 2.149 2016/05/02 14:03:19 roberto Exp $ 378c378,381 < #define MAXRN 200 --- > #if !defined (L_MAXLENNUM) > #define L_MAXLENNUM 200 > #endif > 385c388 < char buff[MAXRN + 1]; /* +1 for ending '\0' */ --- > char buff[L_MAXLENNUM + 1]; /* +1 for ending '\0' */ 393c396 < if (rn->n >= MAXRN) { /* buffer overflow? */ --- > if (rn->n >= L_MAXLENNUM) { /* buffer overflow? */ 406c409 < ** Accept current char if it is in 'set' (of size 1 or 2) --- > ** Accept current char if it is in 'set' (of size 2) 409c412 < if (rn->c == set[0] || (rn->c == set[1] && rn->c != '\0')) --- > if (rn->c == set[0] || rn->c == set[1]) 438c441 < decp[1] = '\0'; --- > decp[1] = '.'; /* always accept a dot */ 442c445 < if (test2(&rn, "0")) { --- > if (test2(&rn, "00")) { diff -r lua-5.3.2/src/llex.c lua-5.3.3/src/llex.c 2c2 < ** $Id: llex.c,v 2.95 2015/11/19 19:16:22 roberto Exp $ --- > ** $Id: llex.c,v 2.96 2016/05/02 14:02:12 roberto Exp $ 165d164 < ls->decpoint = '.'; 210,238d208 < /* < ** change all characters 'from' in buffer to 'to' < */ < static void buffreplace (LexState *ls, char from, char to) { < if (from != to) { < size_t n = luaZ_bufflen(ls->buff); < char *p = luaZ_buffer(ls->buff); < while (n--) < if (p[n] == from) p[n] = to; < } < } < < < /* < ** in case of format error, try to change decimal point separator to < ** the one defined in the current locale and check again < */ < static void trydecpoint (LexState *ls, TValue *o) { < char old = ls->decpoint; < ls->decpoint = lua_getlocaledecpoint(); < buffreplace(ls, old, ls->decpoint); /* try new decimal separator */ < if (luaO_str2num(luaZ_buffer(ls->buff), o) == 0) { < /* format error with correct decimal point: no more options */ < buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */ < lexerror(ls, "malformed number", TK_FLT); < } < } < < 262d231 < buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */ 264c233 < trydecpoint(ls, &obj); /* try to update decimal point separator */ --- > lexerror(ls, "malformed number", TK_FLT); diff -r lua-5.3.2/src/llex.h lua-5.3.3/src/llex.h 2c2 < ** $Id: llex.h,v 1.78 2014/10/29 15:38:24 roberto Exp $ --- > ** $Id: llex.h,v 1.79 2016/05/02 14:02:12 roberto Exp $ 72d71 < char decpoint; /* locale decimal point */ diff -r lua-5.3.2/src/lobject.c lua-5.3.3/src/lobject.c 2c2 < ** $Id: lobject.c,v 2.108 2015/11/02 16:09:30 roberto Exp $ --- > ** $Id: lobject.c,v 2.111 2016/05/20 14:07:48 roberto Exp $ 246c246,251 < static const char *l_str2d (const char *s, lua_Number *result) { --- > /* maximum length of a numeral */ > #if !defined (L_MAXLENNUM) > #define L_MAXLENNUM 200 > #endif > > static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { 248c253,278 < if (strpbrk(s, "nN")) /* reject 'inf' and 'nan' */ --- > *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ > : lua_str2number(s, &endptr); > if (endptr == s) return NULL; /* nothing recognized? */ > while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ > return (*endptr == '\0') ? endptr : NULL; /* OK if no trailing characters */ > } > > > /* > ** Convert string 's' to a Lua number (put in 'result'). Return NULL > ** on fail or the address of the ending '\0' on success. > ** 'pmode' points to (and 'mode' contains) special things in the string: > ** - 'x'/'X' means an hexadecimal numeral > ** - 'n'/'N' means 'inf' or 'nan' (which should be rejected) > ** - '.' just optimizes the search for the common case (nothing special) > ** This function accepts both the current locale or a dot as the radix > ** mark. If the convertion fails, it may mean number has a dot but > ** locale accepts something else. In that case, the code copies 's' > ** to a buffer (because 's' is read-only), changes the dot to the > ** current locale radix mark, and tries to convert again. > */ > static const char *l_str2d (const char *s, lua_Number *result) { > const char *endptr; > const char *pmode = strpbrk(s, ".xXnN"); > int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; > if (mode == 'n') /* reject 'inf' and 'nan' */ 250,256c280,292 < else if (strpbrk(s, "xX")) /* hex? */ < *result = lua_strx2number(s, &endptr); < else < *result = lua_str2number(s, &endptr); < if (endptr == s) return NULL; /* nothing recognized */ < while (lisspace(cast_uchar(*endptr))) endptr++; < return (*endptr == '\0' ? endptr : NULL); /* OK if no trailing characters */ --- > endptr = l_str2dloc(s, result, mode); /* try to convert */ > if (endptr == NULL) { /* failed? may be a different locale */ > char buff[L_MAXLENNUM + 1]; > char *pdot = strchr(s, '.'); > if (strlen(s) > L_MAXLENNUM || pdot == NULL) > return NULL; /* string too long or no dot; fail */ > strcpy(buff, s); /* copy string to buffer */ > buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ > endptr = l_str2dloc(buff, result, mode); /* try again */ > if (endptr != NULL) > endptr = s + (endptr - buff); /* make relative to 's' */ > } > return endptr; 259a296,298 > #define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) > #define MAXLASTD cast_int(LUA_MAXINTEGER % 10) > 276c315,318 < a = a * 10 + *s - '0'; --- > int d = *s - '0'; > if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ > return NULL; /* do not accept it (as integer) */ > a = a * 10 + d; 354,355c396,399 < /* this function handles only '%d', '%c', '%f', '%p', and '%s' < conventional formats, plus Lua-specific '%I' and '%U' */ --- > /* > ** this function handles only '%d', '%c', '%f', '%p', and '%s' > conventional formats, plus Lua-specific '%I' and '%U' > */ 363c407 < case 's': { --- > case 's': { /* zero-terminated string */ 369c413 < case 'c': { --- > case 'c': { /* an 'int' as a character */ 377c421 < case 'd': { --- > case 'd': { /* an 'int' */ 381c425 < case 'I': { --- > case 'I': { /* a 'lua_Integer' */ 385c429 < case 'f': { --- > case 'f': { /* a 'lua_Number' */ 387c431 < top2str: --- > top2str: /* convert the top element to a string */ 392c436 < case 'p': { --- > case 'p': { /* a pointer */ 398c442 < case 'U': { --- > case 'U': { /* an 'int' as a UTF-8 sequence */ diff -r lua-5.3.2/src/loslib.c lua-5.3.3/src/loslib.c 2c2 < ** $Id: loslib.c,v 1.60 2015/11/19 19:16:22 roberto Exp $ --- > ** $Id: loslib.c,v 1.64 2016/04/18 13:06:55 roberto Exp $ 27c27,28 < ** list of valid conversion specifiers for the 'strftime' function --- > ** List of valid conversion specifiers for the 'strftime' function; > ** options are grouped by length; group of length 2 start with '||'. 32,33c33,47 < #if defined(LUA_USE_C89) < #define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" } --- > /* options for ANSI C 89 */ > #define L_STRFTIMEC89 "aAbBcdHIjmMpSUwWxXyYZ%" > > /* options for ISO C 99 and POSIX */ > #define L_STRFTIMEC99 "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%" \ > "||" "EcECExEXEyEY" "OdOeOHOIOmOMOSOuOUOVOwOWOy" > > /* options for Windows */ > #define L_STRFTIMEWIN "aAbBcdHIjmMpSUwWxXyYzZ%" \ > "||" "#c#x#d#H#I#j#m#M#S#U#w#W#y#Y" > > #if defined(LUA_USE_WINDOWS) > #define LUA_STRFTIMEOPTIONS L_STRFTIMEWIN > #elif defined(LUA_USE_C89) > #define LUA_STRFTIMEOPTIONS L_STRFTIMEC89 35,38c49 < #define LUA_STRFTIMEOPTIONS \ < { "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "", \ < "E", "cCxXyY", \ < "O", "deHImMSuUVwWy" } --- > #define LUA_STRFTIMEOPTIONS L_STRFTIMEC99 197a209,225 > > /* > ** Set all fields from structure 'tm' in the table on top of the stack > */ > static void setallfields (lua_State *L, struct tm *stm) { > setfield(L, "sec", stm->tm_sec); > setfield(L, "min", stm->tm_min); > setfield(L, "hour", stm->tm_hour); > setfield(L, "day", stm->tm_mday); > setfield(L, "month", stm->tm_mon + 1); > setfield(L, "year", stm->tm_year + 1900); > setfield(L, "wday", stm->tm_wday + 1); > setfield(L, "yday", stm->tm_yday + 1); > setboolfield(L, "isdst", stm->tm_isdst); > } > > 213c241 < int t = lua_getfield(L, -1, key); --- > int t = lua_getfield(L, -1, key); /* get field and its type */ 215c243 < if (!isnum) { /* field is not a number? */ --- > if (!isnum) { /* field is not an integer? */ 217c245 < return luaL_error(L, "field '%s' not an integer", key); --- > return luaL_error(L, "field '%s' is not an integer", key); 224c252 < return luaL_error(L, "field '%s' out-of-bounds", key); --- > return luaL_error(L, "field '%s' is out-of-bound", key); 233,247c261,269 < static const char *const options[] = LUA_STRFTIMEOPTIONS; < unsigned int i; < for (i = 0; i < sizeof(options)/sizeof(options[0]); i += 2) { < if (*conv != '\0' && strchr(options[i], *conv) != NULL) { < buff[1] = *conv; < if (*options[i + 1] == '\0') { /* one-char conversion specifier? */ < buff[2] = '\0'; /* end buffer */ < return conv + 1; < } < else if (*(conv + 1) != '\0' && < strchr(options[i + 1], *(conv + 1)) != NULL) { < buff[2] = *(conv + 1); /* valid two-char conversion specifier */ < buff[3] = '\0'; /* end buffer */ < return conv + 2; < } --- > const char *option; > int oplen = 1; > for (option = LUA_STRFTIMEOPTIONS; *option != '\0'; option += oplen) { > if (*option == '|') /* next block? */ > oplen++; /* next length */ > else if (memcmp(conv, option, oplen) == 0) { /* match? */ > memcpy(buff, conv, oplen); /* copy valid option to buffer */ > buff[oplen] = '\0'; > return conv + oplen; /* return next item */ 274,282c296 < setfield(L, "sec", stm->tm_sec); < setfield(L, "min", stm->tm_min); < setfield(L, "hour", stm->tm_hour); < setfield(L, "day", stm->tm_mday); < setfield(L, "month", stm->tm_mon+1); < setfield(L, "year", stm->tm_year+1900); < setfield(L, "wday", stm->tm_wday+1); < setfield(L, "yday", stm->tm_yday+1); < setboolfield(L, "isdst", stm->tm_isdst); --- > setallfields(L, stm); 285c299 < char cc[4]; --- > char cc[4]; /* buffer for individual conversion specifiers */ 295c309 < s = checkoption(L, s + 1, cc); --- > s = checkoption(L, s + 1, cc + 1); /* copy specifier to 'cc' */ 321a336 > setallfields(L, &ts); /* update fields with normalized values */ diff -r lua-5.3.2/src/lparser.c lua-5.3.3/src/lparser.c 2c2 < ** $Id: lparser.c,v 2.149 2015/11/02 16:09:30 roberto Exp $ --- > ** $Id: lparser.c,v 2.153 2016/05/13 19:10:16 roberto Exp $ 167c167,168 < while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL; --- > while (oldsize < f->sizelocvars) > f->locvars[oldsize++].varname = NULL; 233c234,235 < while (oldsize < f->sizeupvalues) f->upvalues[oldsize++].name = NULL; --- > while (oldsize < f->sizeupvalues) > f->upvalues[oldsize++].name = NULL; 258c260,261 < while (bl->nactvar > level) bl = bl->previous; --- > while (bl->nactvar > level) > bl = bl->previous; 267c270 < static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { --- > static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 269c272 < return VVOID; /* default is global */ --- > init_exp(var, VVOID, 0); /* default is global */ 276d278 < return VLOCAL; 281,282c283,285 < if (singlevaraux(fs->prev, n, var, 0) == VVOID) /* try upper levels */ < return VVOID; /* not found; is a global */ --- > singlevaraux(fs->prev, n, var, 0); /* try upper levels */ > if (var->k == VVOID) /* not found? */ > return; /* it is a global */ 286,287c289 < init_exp(var, VUPVAL, idx); < return VUPVAL; --- > init_exp(var, VUPVAL, idx); /* new or old upvalue */ 296c298,299 < if (singlevaraux(fs, varname, var, 1) == VVOID) { /* global name? */ --- > singlevaraux(fs, varname, var, 1); > if (var->k == VVOID) { /* global name? */ 299c302 < lua_assert(var->k == VLOCAL || var->k == VUPVAL); --- > lua_assert(var->k != VVOID); /* this one must exist */ 502c505,506 < while (oldsize < f->sizep) f->p[oldsize++] = NULL; --- > while (oldsize < f->sizep) > f->p[oldsize++] = NULL; 1229c1233 < l = newlabelentry(ls, ll, label, line, fs->pc); --- > l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs)); 1497c1501 < SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ --- > SETARG_C(getinstruction(fs, &v.v), 1); /* call statement uses no results */ 1514,1515c1518,1519 < SET_OPCODE(getcode(fs,&e), OP_TAILCALL); < lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar); --- > SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); > lua_assert(GETARG_A(getinstruction(fs,&e)) == fs->nactvar); diff -r lua-5.3.2/src/lparser.h lua-5.3.3/src/lparser.h 2c2 < ** $Id: lparser.h,v 1.74 2014/10/25 11:50:46 roberto Exp $ --- > ** $Id: lparser.h,v 1.76 2015/12/30 18:16:13 roberto Exp $ 16c16,21 < ** Expression descriptor --- > ** Expression and variable descriptor. > ** Code generation for variables and expressions can be delayed to allow > ** optimizations; An 'expdesc' structure describes a potentially-delayed > ** variable/expression. It has a description of its "main" value plus a > ** list of conditional jumps that can also produce its value (generated > ** by short-circuit operators 'and'/'or'). 18a24 > /* kinds of variables/expressions */ 20,34c26,47 < VVOID, /* no value */ < VNIL, < VTRUE, < VFALSE, < VK, /* info = index of constant in 'k' */ < VKFLT, /* nval = numerical float value */ < VKINT, /* nval = numerical integer value */ < VNONRELOC, /* info = result register */ < VLOCAL, /* info = local register */ < VUPVAL, /* info = index of upvalue in 'upvalues' */ < VINDEXED, /* t = table register/upvalue; idx = index R/K */ < VJMP, /* info = instruction pc */ < VRELOCABLE, /* info = instruction pc */ < VCALL, /* info = instruction pc */ < VVARARG /* info = instruction pc */ --- > VVOID, /* when 'expdesc' describes the last expression a list, > this kind means an empty list (so, no expression) */ > VNIL, /* constant nil */ > VTRUE, /* constant true */ > VFALSE, /* constant false */ > VK, /* constant in 'k'; info = index of constant in 'k' */ > VKFLT, /* floating constant; nval = numerical float value */ > VKINT, /* integer constant; nval = numerical integer value */ > VNONRELOC, /* expression has its value in a fixed register; > info = result register */ > VLOCAL, /* local variable; info = local register */ > VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */ > VINDEXED, /* indexed variable; > ind.vt = whether 't' is register or upvalue; > ind.t = table register or upvalue; > ind.idx = key's R/K index */ > VJMP, /* expression is a test/comparison; > info = pc of corresponding jump instruction */ > VRELOCABLE, /* expression can put result in any register; > info = instruction pc */ > VCALL, /* expression is a function call; info = instruction pc */ > VVARARG /* vararg expression; info = instruction pc */ 43a57,59 > lua_Integer ival; /* for VKINT */ > lua_Number nval; /* for VKFLT */ > int info; /* for generic use */ 49,51d64 < int info; /* for generic use */ < lua_Number nval; /* for VKFLT */ < lua_Integer ival; /* for VKINT */ diff -r lua-5.3.2/src/lstate.h lua-5.3.3/src/lstate.h 2c2 < ** $Id: lstate.h,v 2.128 2015/11/13 12:16:51 roberto Exp $ --- > ** $Id: lstate.h,v 2.130 2015/12/16 16:39:38 roberto Exp $ 35a36,44 > /* > ** Atomic type (relative to signals) to better ensure that 'lua_sethook' > ** is thread safe > */ > #if !defined(l_signalT) > #include > #define l_signalT sig_atomic_t > #endif > 165c174 < lua_Hook hook; --- > volatile lua_Hook hook; 172c181 < lu_byte hookmask; --- > l_signalT hookmask; diff -r lua-5.3.2/src/lstrlib.c lua-5.3.3/src/lstrlib.c 2c2 < ** $Id: lstrlib.c,v 1.239 2015/11/25 16:28:17 roberto Exp $ --- > ** $Id: lstrlib.c,v 1.251 2016/05/20 14:13:21 roberto Exp $ 15a16 > #include 29c30,31 < ** pattern-matching. This limit is arbitrary. --- > ** pattern-matching. This limit is arbitrary, but must fit in > ** an unsigned char. 217d218 < size_t nrep; /* limit to avoid non-linear complexity */ 219c220 < int level; /* total number of captures (finished or unfinished) */ --- > unsigned char level; /* total number of captures (finished or unfinished) */ 237,247d237 < /* < ** parameters to control the maximum number of operators handled in < ** a match (to avoid non-linear complexity). The maximum will be: < ** (subject length) * A_REPS + B_REPS < */ < #if !defined(A_REPS) < #define A_REPS 4 < #define B_REPS 100000 < #endif < < 505,506d494 < if (ms->nrep-- == 0) < luaL_error(ms->L, "pattern too complex"); 610,613d597 < if (ls < (MAX_SIZET - B_REPS) / A_REPS) < ms->nrep = A_REPS * ls + B_REPS; < else /* overflow (very long subject) */ < ms->nrep = MAX_SIZET; /* no limit */ 683a668 > const char *lastmatch; /* end of last match */ 690a676 > gm->ms.L = L; 694,698c680,681 < if ((e = match(&gm->ms, src, gm->p)) != NULL) { < if (e == src) /* empty match? */ < gm->src =src + 1; /* go at least one position */ < else < gm->src = e; --- > if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) { > gm->src = gm->lastmatch = e; 714c697 < gm->src = s; gm->p = p; --- > gm->src = s; gm->p = p; gm->lastmatch = NULL; 781,784c764,768 < const char *src = luaL_checklstring(L, 1, &srcl); < const char *p = luaL_checklstring(L, 2, &lp); < int tr = lua_type(L, 3); < lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1); --- > const char *src = luaL_checklstring(L, 1, &srcl); /* subject */ > const char *p = luaL_checklstring(L, 2, &lp); /* pattern */ > const char *lastmatch = NULL; /* end of last match */ > int tr = lua_type(L, 3); /* replacement type */ > lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1); /* max replacements */ 786c770 < lua_Integer n = 0; --- > lua_Integer n = 0; /* replacement count */ 799,800c783,784 < reprepstate(&ms); < if ((e = match(&ms, src, p)) != NULL) { --- > reprepstate(&ms); /* (re)prepare state for new match */ > if ((e = match(&ms, src, p)) != NULL && e != lastmatch) { /* match? */ 802c786,787 < add_value(&ms, &b, src, e, tr); --- > add_value(&ms, &b, src, e, tr); /* add replacement to buffer */ > src = lastmatch = e; 804,806c789 < if (e && e>src) /* non empty match? */ < src = e; /* skip it */ < else if (src < ms.src_end) --- > else if (src < ms.src_end) /* otherwise, skip one character */ 808c791 < else break; --- > else break; /* end of subject */ 833d815 < #include 925,927c907 < static void addquoted (lua_State *L, luaL_Buffer *b, int arg) { < size_t l; < const char *s = luaL_checklstring(L, arg, &l); --- > static void addquoted (luaL_Buffer *b, const char *s, size_t len) { 929c909 < while (l--) { --- > while (len--) { 934c914 < else if (*s == '\0' || iscntrl(uchar(*s))) { --- > else if (iscntrl(uchar(*s))) { 948a929,979 > > /* > ** Ensures the 'buff' string uses a dot as the radix character. > */ > static void checkdp (char *buff, int nb) { > if (memchr(buff, '.', nb) == NULL) { /* no dot? */ > char point = lua_getlocaledecpoint(); /* try locale point */ > char *ppoint = memchr(buff, point, nb); > if (ppoint) *ppoint = '.'; /* change it to a dot */ > } > } > > > static void addliteral (lua_State *L, luaL_Buffer *b, int arg) { > switch (lua_type(L, arg)) { > case LUA_TSTRING: { > size_t len; > const char *s = lua_tolstring(L, arg, &len); > addquoted(b, s, len); > break; > } > case LUA_TNUMBER: { > char *buff = luaL_prepbuffsize(b, MAX_ITEM); > int nb; > if (!lua_isinteger(L, arg)) { /* float? */ > lua_Number n = lua_tonumber(L, arg); /* write as hexa ('%a') */ > nb = lua_number2strx(L, buff, MAX_ITEM, "%" LUA_NUMBER_FRMLEN "a", n); > checkdp(buff, nb); /* ensure it uses a dot */ > } > else { /* integers */ > lua_Integer n = lua_tointeger(L, arg); > const char *format = (n == LUA_MININTEGER) /* corner case? */ > ? "0x%" LUA_INTEGER_FRMLEN "x" /* use hexa */ > : LUA_INTEGER_FMT; /* else use default format */ > nb = l_sprintf(buff, MAX_ITEM, format, n); > } > luaL_addsize(b, nb); > break; > } > case LUA_TNIL: case LUA_TBOOLEAN: { > luaL_tolstring(L, arg, NULL); > luaL_addvalue(b); > break; > } > default: { > luaL_argerror(L, arg, "value has no literal form"); > } > } > } > > 1028c1059 < addquoted(L, &b, arg); --- > addliteral(L, &b, arg); 1073,1074c1104,1105 < #if !defined(LUA_PACKPADBYTE) < #define LUA_PACKPADBYTE 0x00 --- > #if !defined(LUAL_PACKPADBYTE) > #define LUAL_PACKPADBYTE 0x00 1311c1342 < luaL_addchar(&b, LUA_PACKPADBYTE); /* fill alignment */ --- > luaL_addchar(&b, LUAL_PACKPADBYTE); /* fill alignment */ 1346,1352c1377,1381 < if ((size_t)size <= len) /* string larger than (or equal to) needed? */ < luaL_addlstring(&b, s, size); /* truncate string to asked size */ < else { /* string smaller than needed */ < luaL_addlstring(&b, s, len); /* add it all */ < while (len++ < (size_t)size) /* pad extra space */ < luaL_addchar(&b, LUA_PACKPADBYTE); < } --- > luaL_argcheck(L, len <= (size_t)size, arg, > "string longer than given size"); > luaL_addlstring(&b, s, len); /* add string */ > while (len++ < (size_t)size) /* pad extra space */ > luaL_addchar(&b, LUAL_PACKPADBYTE); 1375c1404 < case Kpadding: luaL_addchar(&b, LUA_PACKPADBYTE); /* FALLTHROUGH */ --- > case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE); /* FALLTHROUGH */ diff -r lua-5.3.2/src/ltablib.c lua-5.3.3/src/ltablib.c 2c2 < ** $Id: ltablib.c,v 1.90 2015/11/25 12:48:57 roberto Exp $ --- > ** $Id: ltablib.c,v 1.93 2016/02/25 19:41:54 roberto Exp $ 56c56 < luaL_argerror(L, arg, "table expected"); /* force an error */ --- > luaL_checktype(L, arg, LUA_TTABLE); /* force an error */ 142c142 < if (t > e || t <= f || tt != 1) { --- > if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) { 155c155 < lua_pushvalue(L, tt); /* return "to table" */ --- > lua_pushvalue(L, tt); /* return destination table */ 175c175 < last = luaL_opt(L, luaL_checkinteger, 4, last); --- > last = luaL_optinteger(L, 4, last); 234a235,238 > /* type for array indices */ > typedef unsigned int IdxT; > > 273c277 < static void set2 (lua_State *L, unsigned int i, unsigned int j) { --- > static void set2 (lua_State *L, IdxT i, IdxT j) { 306,309c310,312 < static unsigned int partition (lua_State *L, unsigned int lo, < unsigned int up) { < unsigned int i = lo; /* will be incremented before first use */ < unsigned int j = up - 1; /* will be decremented before first use */ --- > static IdxT partition (lua_State *L, IdxT lo, IdxT up) { > IdxT i = lo; /* will be incremented before first use */ > IdxT j = up - 1; /* will be decremented before first use */ 343,346c346,348 < static unsigned int choosePivot (unsigned int lo, unsigned int up, < unsigned int rnd) { < unsigned int r4 = (unsigned int)(up - lo) / 4u; /* range/4 */ < unsigned int p = rnd % (r4 * 2) + (lo + r4); --- > static IdxT choosePivot (IdxT lo, IdxT up, unsigned int rnd) { > IdxT r4 = (up - lo) / 4; /* range/4 */ > IdxT p = rnd % (r4 * 2) + (lo + r4); 355c357 < static void auxsort (lua_State *L, unsigned int lo, unsigned int up, --- > static void auxsort (lua_State *L, IdxT lo, IdxT up, 358,359c360,361 < unsigned int p; /* Pivot index */ < unsigned int n; /* to be used later */ --- > IdxT p; /* Pivot index */ > IdxT n; /* to be used later */ 403c405 < if ((up - lo) / 128u > n) /* partition too imbalanced? */ --- > if ((up - lo) / 128 > n) /* partition too imbalanced? */ 413d414 < luaL_checkstack(L, 40, ""); /* assume array is smaller than 2^40 */ 417c418 < auxsort(L, 1, (unsigned int)n, 0u); --- > auxsort(L, 1, (IdxT)n, 0); diff -r lua-5.3.2/src/ltm.c lua-5.3.3/src/ltm.c 2c2 < ** $Id: ltm.c,v 2.36 2015/11/03 15:47:30 roberto Exp $ --- > ** $Id: ltm.c,v 2.37 2016/02/26 19:20:15 roberto Exp $ 85a86,101 > /* > ** Return the name of the type of an object. For tables and userdata > ** with metatable, use their '__name' metafield, if present. > */ > const char *luaT_objtypename (lua_State *L, const TValue *o) { > Table *mt; > if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || > (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { > const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name")); > if (ttisstring(name)) /* is '__name' a string? */ > return getstr(tsvalue(name)); /* use it as type name */ > } > return ttypename(ttnov(o)); /* else use standard type name */ > } > > diff -r lua-5.3.2/src/ltm.h lua-5.3.3/src/ltm.h 2c2 < ** $Id: ltm.h,v 2.21 2014/10/25 11:50:46 roberto Exp $ --- > ** $Id: ltm.h,v 2.22 2016/02/26 19:20:15 roberto Exp $ 54d53 < #define objtypename(x) ttypename(ttnov(x)) 58a58,59 > LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o); > diff -r lua-5.3.2/src/lua.h lua-5.3.3/src/lua.h 2c2 < ** $Id: lua.h,v 1.329 2015/11/13 17:18:42 roberto Exp $ --- > ** $Id: lua.h,v 1.331 2016/05/30 15:53:28 roberto Exp $ 22c22 < #define LUA_VERSION_RELEASE "2" --- > #define LUA_VERSION_RELEASE "3" 26c26 < #define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2015 Lua.org, PUC-Rio" --- > #define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2016 Lua.org, PUC-Rio" 364c364 < lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) --- > ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) 463c463 < * Copyright (C) 1994-2015 Lua.org, PUC-Rio. --- > * Copyright (C) 1994-2016 Lua.org, PUC-Rio. diff -r lua-5.3.2/src/luaconf.h lua-5.3.3/src/luaconf.h 2c2 < ** $Id: luaconf.h,v 1.254 2015/10/21 18:17:40 roberto Exp $ --- > ** $Id: luaconf.h,v 1.255 2016/05/01 20:06:09 roberto Exp $ 615c615 < #define lua_number2strx(L,b,sz,f,n) l_sprintf(b,sz,f,n) --- > #define lua_number2strx(L,b,sz,f,n) ((void)L, l_sprintf(b,sz,f,n)) diff -r lua-5.3.2/src/lvm.c lua-5.3.3/src/lvm.c 2c2 < ** $Id: lvm.c,v 2.265 2015/11/23 11:30:45 roberto Exp $ --- > ** $Id: lvm.c,v 2.268 2016/02/05 19:59:14 roberto Exp $ 156,157c156,158 < ** Complete a table access: if 't' is a table, 'tm' has its metamethod; < ** otherwise, 'tm' is NULL. --- > ** Finish the table access 'val = t[key]'. > ** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to > ** t[k] entry (which must be nil). 160c161 < const TValue *tm) { --- > const TValue *slot) { 162c163 < lua_assert(tm != NULL || !ttistable(t)); --- > const TValue *tm; /* metamethod */ 164,165c165,168 < if (tm == NULL) { /* no metamethod (from a table)? */ < if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))) --- > if (slot == NULL) { /* 't' is not a table? */ > lua_assert(!ttistable(t)); > tm = luaT_gettmbyobj(L, t, TM_INDEX); > if (ttisnil(tm)) 166a170 > /* else will try the metamethod */ 168c172,181 < if (ttisfunction(tm)) { /* metamethod is a function */ --- > else { /* 't' is a table */ > lua_assert(ttisnil(slot)); > tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ > if (tm == NULL) { /* no metamethod? */ > setnilvalue(val); /* result is nil */ > return; > } > /* else will try the metamethod */ > } > if (ttisfunction(tm)) { /* is metamethod a function? */ 172,174c185,187 < t = tm; /* else repeat access over 'tm' */ < if (luaV_fastget(L,t,key,tm,luaH_get)) { /* try fast track */ < setobj2s(L, val, tm); /* done */ --- > t = tm; /* else try to access 'tm[key]' */ > if (luaV_fastget(L,t,key,slot,luaH_get)) { /* fast track? */ > setobj2s(L, val, slot); /* done */ 177c190 < /* else repeat */ --- > /* else repeat (tail call 'luaV_finishget') */ 179c192 < luaG_runerror(L, "gettable chain too long; possible loop"); --- > luaG_runerror(L, "'__index' chain too long; possible loop"); 184,185c197,201 < ** Main function for table assignment (invoking metamethods if needed). < ** Compute 't[key] = val' --- > ** Finish a table assignment 't[key] = val'. > ** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points > ** to the entry 't[key]', or to 'luaO_nilobject' if there is no such > ** entry. (The value at 'slot' must be nil, otherwise 'luaV_fastset' > ** would have done the job.) 188c204 < StkId val, const TValue *oldval) { --- > StkId val, const TValue *slot) { 191,200c207,214 < const TValue *tm; < if (oldval != NULL) { < lua_assert(ttistable(t) && ttisnil(oldval)); < /* must check the metamethod */ < if ((tm = fasttm(L, hvalue(t)->metatable, TM_NEWINDEX)) == NULL && < /* no metamethod; is there a previous entry in the table? */ < (oldval != luaO_nilobject || < /* no previous entry; must create one. (The next test is < always true; we only need the assignment.) */ < (oldval = luaH_newkey(L, hvalue(t), key), 1))) { --- > const TValue *tm; /* '__newindex' metamethod */ > if (slot != NULL) { /* is 't' a table? */ > Table *h = hvalue(t); /* save 't' table */ > lua_assert(ttisnil(slot)); /* old value must be nil */ > tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ > if (tm == NULL) { /* no metamethod? */ > if (slot == luaO_nilobject) /* no previous entry? */ > slot = luaH_newkey(L, h, key); /* create one */ 202,204c216,218 < setobj2t(L, cast(TValue *, oldval), val); < invalidateTMcache(hvalue(t)); < luaC_barrierback(L, hvalue(t), val); --- > setobj2t(L, cast(TValue *, slot), val); /* set its new value */ > invalidateTMcache(h); > luaC_barrierback(L, h, val); 219c233 < if (luaV_fastset(L, t, key, oldval, luaH_get, val)) --- > if (luaV_fastset(L, t, key, slot, luaH_get, val)) 223c237 < luaG_runerror(L, "settable chain too long; possible loop"); --- > luaG_runerror(L, "'__newindex' chain too long; possible loop"); 740a755,764 > /* fetch an instruction and prepare its execution */ > #define vmfetch() { \ > i = *(ci->u.l.savedpc++); \ > if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) \ > Protect(luaG_traceexec(L)); \ > ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \ > lua_assert(base == ci->u.l.base); \ > lua_assert(base <= L->top && L->top < L->stack + L->stacksize); \ > } > 747,748c771,772 < ** copy of 'luaV_gettable', but protecting call to potential metamethod < ** (which can reallocate the stack) --- > ** copy of 'luaV_gettable', but protecting the call to potential > ** metamethod (which can reallocate the stack) 750,752c774,776 < #define gettableProtected(L,t,k,v) { const TValue *aux; \ < if (luaV_fastget(L,t,k,aux,luaH_get)) { setobj2s(L, v, aux); } \ < else Protect(luaV_finishget(L,t,k,v,aux)); } --- > #define gettableProtected(L,t,k,v) { const TValue *slot; \ > if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \ > else Protect(luaV_finishget(L,t,k,v,slot)); } 775c799 < Instruction i = *(ci->u.l.savedpc++); --- > Instruction i; 777,782c801 < if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) < Protect(luaG_traceexec(L)); < /* WARNING: several calls may realloc the stack and invalidate 'ra' */ < ra = RA(i); < lua_assert(base == ci->u.l.base); < lua_assert(base <= L->top && L->top < L->stack + L->stacksize); --- > vmfetch(); diff -r lua-5.3.2/src/lvm.h lua-5.3.3/src/lvm.h 2c2 < ** $Id: lvm.h,v 2.39 2015/09/09 13:44:07 roberto Exp $ --- > ** $Id: lvm.h,v 2.40 2016/01/05 16:07:21 roberto Exp $ 52,54c52,56 < ** fast track for 'gettable': 1 means 'aux' points to resulted value; < ** 0 means 'aux' is metamethod (if 't' is a table) or NULL. 'f' is < ** the raw get function to use. --- > ** fast track for 'gettable': if 't' is a table and 't[k]' is not nil, > ** return 1 with 'slot' pointing to 't[k]' (final result). Otherwise, > ** return 0 (meaning it will have to check metamethod) with 'slot' > ** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise). > ** 'f' is the raw get function to use. 56c58 < #define luaV_fastget(L,t,k,aux,f) \ --- > #define luaV_fastget(L,t,k,slot,f) \ 58,63c60,62 < ? (aux = NULL, 0) /* not a table; 'aux' is NULL and result is 0 */ \ < : (aux = f(hvalue(t), k), /* else, do raw access */ \ < !ttisnil(aux) ? 1 /* result not nil? 'aux' has it */ \ < : (aux = fasttm(L, hvalue(t)->metatable, TM_INDEX), /* get metamethod */\ < aux != NULL ? 0 /* has metamethod? must call it */ \ < : (aux = luaO_nilobject, 1)))) /* else, final result is nil */ --- > ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ > : (slot = f(hvalue(t), k), /* else, do raw access */ \ > !ttisnil(slot))) /* result not nil? */ 68,70c67,69 < #define luaV_gettable(L,t,k,v) { const TValue *aux; \ < if (luaV_fastget(L,t,k,aux,luaH_get)) { setobj2s(L, v, aux); } \ < else luaV_finishget(L,t,k,v,aux); } --- > #define luaV_gettable(L,t,k,v) { const TValue *slot; \ > if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \ > else luaV_finishget(L,t,k,v,slot); } 103c102 < StkId val, const TValue *tm); --- > StkId val, const TValue *slot); 105c104 < StkId val, const TValue *oldval); --- > StkId val, const TValue *slot);