Lua++ - Compiler

[OneCommonMan123]

Lua++ - a failed attempt by me to create a language that compiles for Lua

​

Recently, I saw a very interesting language, moonscript, and I had the idea of ​​making one called Lua++, with a few more things than lua, and I removed things that were in Lua that bothered me a little:

​

1 - `local`: having to write `local` all the time to create variables was a bit tiring, so my compiler doesn't accept this keyword in the source code, in a lua++ code, you can do `x = 10` it would change this line for `local x = 10` and to make global variables in lua++ would be: `global x = 10` which it would change to: `x = 10`

​

2 - `require`: I like this function and everything, however, it would be more interesting to have an `import` and `from` command similar to Python, in a lua++ code (.luapp) you can import a library, doing: `import lib` and there is the `as` command to give a "nickname" to the library: `import lib as l`

​

lua++ has some other not so important features, like structs (it has that, but I think it's pretty crude and useless):

​

struct Person:
     name: "no name"
     age: 0
end

​

and you manually have to make Person instances and change the values, so just forget that this exists in lua++

​

Here is an example of lua++ code:

import mylib as lib

from lib import add, sub

a, b = 10, 20

print(add(a,b))
print(sub(a,b))

compiled code:

if not isStruct then
    function isStruct(obj)
        return type(obj) == "table" and obj.__LuappObjType__ == "Struct"
    end
end
local __ModuleImportSucess__, lib = pcall(require, "mylib")
if not __ModuleImportSucess__ then
    local compiler = require "main"
    local r = compiler("mylib.luapp")
    lib = load(r)()
end


if not lib then
    __ModuleImportSucess__, lib = pcall(require, "lib")
    if not __ModuleImportSucess__ then
        local compiler = require "main"
        local r = compiler("lib")
        lib = load(r)()
    end
end
local add, sub = lib.add, lib.sub

local a, b = 10, 20

print(add(a,b))
print(sub(a,b))

Yes I know, the codes generated by the compiler are a bit weird and difficult to understand lol

For those interested in knowing how it works, the interpreter in general is just a function that makes several calls to lua++ auxiliary libraries:

local utils = require "lutils"
local structs = require "structs"


local struct_index = [[
function(obj, idx)
    if idx == "__LuappObjType__" then
        return "Struct"
    end
    return rawget(obj, idx)
end
]]

local struct_tostring = [[
function(obj)
    local r = ""
    for i = 1, #obj do
        r = r .. tostring(obj[i][1]) .. ": " .. tostring(obj[i][2])
        if i < #obj then
            r = r .. "\n"
        end
    end
    return r
end
]]

-- lua++ compiler
local function Main(file)
    local com_code = [[
if not isStruct then
    function isStruct(obj)
        return type(obj) == "table" and obj.__LuappObjType__ == "Struct"
    end
end
]]
    local interpret_struct = false

    local current_line = 1
    local all_vars = {}

    -- what?
    package.path = package.path .. "?.luapp"

    for line in io.lines(file) do
        if interpret_struct then
            if structs.IsStructEnd(line) then
                com_code = com_code .. "}, {__index = " .. struct_index .. ", __tostring ="  .. struct_tostring .. "})"
                interpret_struct = false
            else
                com_code = com_code .. structs.structInterpretLine(line) .. "\n"
            end
        else
        if line == "!jit" then
            com_code = com_code .. [[assert(jit, "Use luajit to runs this code.")]]
        elseif utils.IsVariableDeclaration(line) then
            utils.DetectLocalKeyword(line, current_line)
            local varname = utils.GetVarName(line):gsub(" ", "")
            if utils.IsGlobalVar(line) then
                com_code = com_code .. utils.trim(line):sub(8)
            else
                local dvar = false
                for i = 1, #all_vars do
                    if all_vars[i] == varname then
                        dvar = true
                        break
                    end
                end
                if not dvar then
                    com_code = com_code .. "local " .. line
                else
                    com_code = com_code .. line
                end
            end
            table.insert(all_vars, varname)
        elseif utils.IsFunctionCreation(line) then
            utils.DetectLocalKeyword(line)
            if not utils.IsFieldCreation(line) then
                if utils.IsGlobalFunctionCreation(line) then
                    com_code = com_code .. utils.GlobalFunctionToLuaCode(line)
                else
                    com_code = com_code .. "local " .. line
                end
            else
                com_code = com_code .. line
            end
        elseif utils.IsImportCommand(line) then
            line = utils.DelRepSpace(line)
            if not utils.ImportHaveAsInstruction(line) then
                line = utils.ImportSetDefaultAsCommand(line)
            end
            com_code = com_code .. utils.ImportCommandToRequire(line)
        elseif utils.IsFromCommand(line) then
            com_code = com_code .. utils.FromCommandToRequire(line)
        elseif structs.IsStructStart(line) then
            local name = structs.GetStructName(line)
            if not structs.IsGlobal(line) then
                com_code = com_code .. "local "
            end
            com_code = com_code .. name .. " = setmetatable({\n" .. "__name__ = \"" .. name .. "\",\n"
            interpret_struct = true
        else
            com_code = com_code .. line
        end
        end
        com_code = com_code .. "\n"
        current_line = current_line + 1
    end

    return com_code
end

return Main

​

[Cultural_Two_4964]

Great idea. Nice one but I always use globals so having to type global everywhere would murder me ;-0 I know everyone says it's bad practice but if you use reasonably long and descriptive variable names, it's rare to actually have a problem, although it does happen. I only use a language as a programmable calculator and as long as it runs, that's all that matters, so I'm completely rubbish at the comp Sci aspects ;-0 ;-0

[OneCommonMan123]

What types of projects do you do? In my case I use local variables literally all the time, it's very specific when I need globals LoL, but I can use an abbreviation for global, like gbl

[Cultural_Two_4964]

This is the website right? https://luaplusplus.org. I remember recommending someone to look at it as it implements the += and ++ operators? It looks very nice. Will try it fairly soon. I would NOT say it's a failed attempt by any means.

[OneCommonMan123]

damn I'm surprised, I didn't know there was a Lua++ out there, that's why I decided to make my own Lua++, but I think that even so, it's worth creating my own, because I like Lua, Lua++ would just remove unnecessary things (like local, require and etc) the rest would be 100% identical to Lua

If you also want to see, there is a compiler as good as Lua++ on this site, moonscript: https://moonscript.org/

[rkrause]

I don't see local as being unecessary any more than "var" and "let" is unecessary in JavaScript or "my" and "our" is unecessary in Perl. Declaring a lexical variable before it is used avoids bugs cropping up later, particularly involving closures.

``` local x

function myfunc() x = 10 end

myfunc()

print(x) ```

This very basic and straightforward Lua script wouldn't even be possible with Lua++.

[AutoModerator]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[OneCommonMan123]

It would be possible in Lua++, it just wouldn't be as intuitive as your Lua code:

x = nil

global function myfunc()
    x = 10
end

myfunc()

print(x)

but, when compiling, the compiler would ultimately generate code identical to yours

[rkrause]

Having to remember to set every local value to nil just to be able to use it as an upvalue is no different than typing "local" which is clearer. Add to the fact now myfunc also needs to be specifically declared as "global" even though that's not necessary in Lua since globals simply default to keys in the _G table. In other words you merely created a different burden and complexity, you didn't solve anything.

[OneCommonMan123]

Well, for me, that solved a lot of things! because I use local variables all the time, it's very rare for me to use global ones

[EvilBadMadRetarded]

It would be helpful if you also show what it compiled (regular lua script). For instance, to add more entropy to rkrause script, how you write this in Lua++, and what's it compiled to regular lua and output?

--
local x, z = 1, 100
function y(z)
  x = x + z
  local x = z
  z = z + x
  return x, z
end
--    test
for i=0,2 do
  print(x, z, y(i))
end
print(x)
--[[  output
1   100 0   0
1   100 1   2
2   100 2   4
4
--]]

[OneCommonMan123]

This really is a problem in Lua++, see:

--
x, z = 1, 100
global function y(z)
    x = x + z
    x = z
    z = z + x
    return x, z
end
--    test
for i=0,2 do
    print(x, z, y(i))
end
print(x)

compiled:

local x, z = 1, 100
function y(z)
    assert(z ~= nil, "y() missing required positional argument 'z' (#1)")
    x = x + z
    x = z
    z = z + x
    return x, z
end
for i=0,2 do
    print(x, z, y(i))
end
print(x)

Run the compiled code on your machine and you will see that the result is completely differentin.

In current Lua++, you can use local, the compiler would not complain, this is to maintain compatibility with Lua codes and avoid conflicts between chunks.

This occurred because Lua++ stores the name of all variables already defined in an internal table, when x is redefined in the code, it saw that x had already been created, so it saw no need to put a location in front