github.com/milochristiansen/lua

• Function calls or parenthesized expressions that are followed by table indexers are now properly compiled (Fixed #13).
• The compiler sometimes did not always mark "used" the proper number of registers when compiling identifiers (Fixed #16).
• Fixed the table iterator not finalizing (Fixed #17).
• Removed my hacky slice library and just did things properly (Fixed #18).
• Fix pcall not returning true on success (Fixed #19).
• Fixed setting a nil index in a table not raising an error (Fixed #20).

Fun with tables! Ok, not so much fun.

• Fixed scripts with lots of constants overflowing RK fields in certain instructions. The proper constant load instructions are emitted in this case now.
• Tables with lots of empty space at the beginning of the array portion will no longer cause crashes when the array portion is resized.

And, another stupid little bug.

• Constructs similar to the following [=[]==]]=] were not working properly. The lexer was not properly constructing the lexeme, and it would return the wrong number of equals signs and it would eat the last square bracket. As a bonus I greatly simplified the string lexing code. (ast/lexer.go)

Not sure how I missed this one... Oh well, it should work now.

• require was not checking package.loaded properly. (lmodpackage/functions.go)

1.1.1

More script tests, more compiler bugs fixed. Same song, different verse.

• Added another set of script tests. (script_test.go)
• Fixed unary operators after a power operator, for example 2 ^ - -2. To fix this issue I totally rewrote how operators
  are parsed. (ast/parse_expr.go)
• Fixed semicolons immediately after a return statement. (ast/parse.go)
• Fixed an improper optimization or repeat-until loops. Basically if the loop had a constant for the loop condition its
  sense was being reversed (so a false condition resulted in the loop being compiled as a simple block, and a true condition
  resulted in an infinite loop). (compile.go)
• Fixed and in non-boolean contexts. Also and and or may produce slightly better code now. (compile_expr.go)

1.1.0

I was a little bored recently, so I threw together a generic metatable API. It was a quick little project, based on
earlier work for one of my many toy languages. This new API is kinda cool, but it in no way replaces proper metatables!
Basically it is intended for quick projects and temporarily exposing data to scripts. It was fun to write, and so even
if no one uses it, it has served its purpose :P

I really should have been working on more script tests, but this was more fun... Anyway, I have no doubt responsibility
will reassert itself soon...

Anyway, I also added two new convenience methods for table iteration, as well as some minor changes to the old one (you
can still use it, but it is now a thin wrapper over one of the new functions, so you shouldn't).

• Ran all code through go fmt. I often forget to do this, but I recently switched to a new editor that formats files
  automatically whenever they are saved. Anyway, everything is formatted now. (almost every file in minor ways)
• Added Protect and Recover, simple error handlers for native code. They are to be used when calling native APIs
  outside of code otherwise protected (such as by a call to PCall). Recover is the old handler from PCall, wrapped
  so it can be used by itself. Protect simply wraps Recover so it is easier to use. (api.go)
• Added ForEachRaw, basically ForEachInTable, but the passed in function returns a boolean specifying if you want to
  break out of the loop early. In other news ForEachInTable is now depreciated. (api.go)
• Added ForEach, a version of ForEachRaw that respects the __pairs metamethod. ForEachRaw uses the table iterator
  directly and does much less stack manipulation, so it is probably a little faster. (api.go)
• Added a new sub-package: supermeta adds "generic" metatables for just about any Go type. For obvious reasons this
  makes heavy use of reflection, so it is generally much faster to write your own metatables, that said this is really
  nice for quickly exposing native data to scripts. From the user's perspective you just call supermeta.New(l, &object)
  and object is suddenly a script value on the top of l's stack. Arrays, slices, maps, structs, etc should all work
  just fine. Note that this is very new, and as of yet has received little real-world testing! (supermeta/supermeta.go,
  supermeta/tables.go)
• Added a new sub-package: testhelp contains a few test helper functions I find useful when writing tests that interact
  with the VM. Better to have all this stuff in one place rather than copied and pasted all over... (testhelp/testhelp.go)
• Modified the script tests in the base package to use the helper functions in testhelp rather than their own copies.
  The API tests still have their own copies of some of the functions, as they need to be in the base package so they can
  access internal APIs (stupid circular imports). (script_test.go)
• Clarified what API functions may panic, I think I got them all... (api.go)

More tests, more (compiler) bugs fixed. Damn compiler will be the death of me yet...

In addition to the inevitable compiler bugs I also fixed the way the VM handles upvalues. Before I was giving each
closure its own copy of each upvalue, so multiple closures never properly shared values. This change fixes several
subtle (and several not so subtle) bugs.

Oh, and pcall works now (it didn't work at all before. Sorry, I never used it).

• Added more script tests. I still have a lot more to do... (script_test.go)
• Fixed incorrect compilation of method declarations (function a:x() end). Depressingly the issue was only one
  incorrect word, but it resulted in very wrong results (I am really starting to remember why I hated writing the
  compiler, the VM was fun, the compiler... not.) (ast/parse.go)
• Parenthesized expression that would normally (without the parenthesis) return multiple values (for example: (...))
  were not properly truncating the result to a single value. (compile_expr.go)
• Fixed a semi-major VM issue with upvalues. Closures that should have a single shared upvalue were instead each using
  their own private copy after said upvalue was closed. This required an almost total rewrite of the way upvalues are
  stored internally. (all over the place, but mainly callframe.go, function.go, api.go, and vm.go)
• JMP instructions created by break and continue statements are now properly patched by the compiler to close any
  upvalues there may be. (compile.go)
• Fixed the pcall script function so it actually works. (lmodbase/functions.go)
• On a recovered error each stack frame's upvalues are closed before the stack is stripped. This corrects incorrect
  behavior that arises when a function stores a closure to an unclosed upvalue then errors out (the closure may still be
  referenced, but it's upvalues may be invalid). (api.go, callframe.go)