on @ true
off @ false
fn @ function
ael @ addEventListener

add @ |stage:addChild|

\`~ ! # $ % ^ & * / + = | 

-- define your lib in init.lua
include_my_lib @ \
local f = function(...) return ... end
-- your functions here
\

pi @ \math.pi\
print(pi + pi / pi ^ pi)

what @ /
what @@ |
 what @@ \
  LOL @ !
   "LOL"
  !
 \
|
/
what
what
what
print(LOL) -- guess what you will get :)

print @ |--|

print(x, y, z, x + y, y * z)

time_ @ |local _time_ = os.timer()|
_time @ |print("TIME:", os.timer() - _time_)|

local x = 0
time_ for i = 1, 1e8 do x = x + i end _time

rnd @ |math.random(0, 0xFFFFFF)|

local pixel = Pixel.new(rnd, 1, 200, 200)

local function myFunction1(a)
	local function c(a) return math.cos(a*math.pi/180) end
	return c(a)+c(a+1)
end

local function profile(myFunction)
	Profiler.start()
	for i=1,1000000 do myFunction(i) end
	Profiler.stop()
end

profile(myFunction1)

<	[  6]	  3768	100%	1000000	 @main.lua:22
=	[  1]	  3768	 36%	1000000	myFunction @main.lua:1
>	[  2]	  2424	 64%	2000000	c @main.lua:2
--------------------------------
<	[  1]	  2424	100%	2000000	myFunction @main.lua:1
=	[  2]	  2424	 63%	2000000	c @main.lua:2
>	[  3]	   892	 37%	2000000	cos =[C] 6E416930
--------------------------------
<	[  2]	   892	100%	2000000	c @main.lua:2
=	[  3]	   892	100%	2000000	cos =[C] 6E416930
--------------------------------
=	[  4]	     0	 -1%	     0	 =[C] 00456FA0
--------------------------------
=	[  5]	     0	 -1%	     0	stop @profiler.lua:7
--------------------------------
=	[  6]	     0	 -1%	     0	 @main.lua:22
>	[  1]	  3768	  1%	1000000	myFunction @main.lua:1
--------------------------------
=	[  7]	     0	 -1%	     0	 @profiler.lua:2
--------------------------------
=	[  8]	     0	 -1%	     0	profilerStop =[C] 004536A0
--------------------------------

<	[  6]	  3768	100%	1000000	 @main.lua:22 (This is the function that called this one)
=	[  1]	  3768	 36%	1000000	myFunction @main.lua:1 (This is the considered function)
>	[  2]	  2424	 64%	2000000	c @main.lua:2 (This is the function that was called by this function)

local function myFunction2(a)
	return math.cos(a*math.pi/180)+math.cos((a+1)*math.pi/180)
end

<	[  5]	   912	100%	1000000	 @main.lua:22
=	[  1]	   912	 76%	1000000	myFunction @main.lua:6
>	[  2]	   215	 24%	2000000	cos =[C] 6E416930
--------------------------------
<	[  1]	   215	100%	2000000	myFunction @main.lua:6
=	[  2]	   215	100%	2000000	cos =[C] 6E416930

local function myFunction3(a)
	local cos=math.cos
	local pi=math.pi
	return cos(a*pi/180)+cos((a+1)*pi/180)
end

<	[  6]	   798	100%	1000000	 @main.lua:22
=	[  1]	   798	 73%	1000000	myFunction @main.lua:10
>	[  2]	   216	 27%	2000000	cos =[C] 6E416930

local function myFunction4(a)
	local cos=math.cos
	return cos(^

and profiler report:
<	[  5]	   741	100%	1000000	 @main.lua:22
=	[  1]	   741	 71%	1000000	myFunction @main.lua:16
>	[  2]	   216	 29%	2000000	cos =[C] 6E416930


We saved a few more precious milliseconds!

As you can see, the profiler is an useful tool to spot CPU bottlenecks in your app, and some times a few minor changes in the code can make big differences: avoid table access, avoid function calls, avoid duplicate computations.

local function encodeInt(n)
	local t = {}
	local char = string.char
	t[1] = char(n >> 24 & 0xFF)
	t[2] = char(n >> 16 & 0xFF)
	t[3] = char(n >> 08 & 0xFF)
	t[4] = char(n >> 00 & 0xFF)
	return t:concat()
end

mt = {
	__bnot = function(t)
		local r = {}
		for i = 1, #t do r[i] = ~t[i] end
		return r
	end
}
t = {1, 2, 3, 4 ,5}
setmetatable(t, mt)

print(require"json".encode(~t)) --> [-2,-3,-4,-5,-6]

#include "gideros.h"
#include "lua.h"
#include "lauxlib.h"
static int addTwoIntegers(lua_State *L)
{
        //retrieve the two integers from the stack
        int firstInteger = lua_tointeger(L, -1);
        int secondInteger = lua_tointeger(L, -2);
        int result = firstInteger + secondInteger;
   
        //place the result on the stack
        lua_pushinteger(L, result);
   
        //one item off the top of the stack, the result, is returned
        return 1;
}
static int loader(lua_State *L)
{
        //This is a list of functions that can be called from Lua
    const luaL_Reg functionlist[] = {
            {"addTwoIntegers", addTwoIntegers},
            {NULL, NULL},
      };
            luaL_register(L, "myFirstPlugin", functionlist);
   
    //return the pointer to the plugin
    return 1;
}
static void g_initializePlugin(lua_State* L)
{
    lua_getglobal(L, "package");
    lua_getfield(L, -1, "preload");
   
    lua_pushcfunction(L, loader);
    lua_setfield(L, -2, "myFirst");
   
    lua_pop(L, 2);    
}
static void g_deinitializePlugin(lua_State *L)
{   }
REGISTER_PLUGIN("myFirstPlugin", "1.0")

require "myFirst"

local result = myFirstPlugin.addTwoIntegers(14, 48)
print("\n\nSample 1 - Result of addTwoIntegers:", result, "\n\n")

  -- main.lua

  local stack = Stack.new({"one","two", "three", "four", "five"})

  stack:push("six")
  stack:push("seven")
  print ("Remove an item from the stack: "..stack:pop())

  for item in stack:iterator() do
    print("Item: ".. item)
  end

TextField.new(font, "my world", "l")
TextField.new(font, "my world", "m")
TextField.new(font, "my world")

setFont(font) -- font should be either bitmap or true type font
setSample(sample) -- sample should be a string
getSample() -- returns sample string
getLineHeight() -- returns height of the sample as a number

@def HELLO "Hello, World!"
print(HELLO) --> Hello, World

@def CUBE(x) ((x)*(x)*(x))
local n = 5
print(CUBE(n)) --> 125

@def x 1
do
  @def x 2
  print(x) --> 2
end
print(x) --> 1

@def (complain(msg,n)
  for i = 1,n do
    print msg
  end
)
complain("Hello!", 5) --> print "Hello" 5 times

@require "do"
y = 0
@do(i, 1, 10, y = y + 1)
print(y)

What do you need to have to use Gideros?

Getting started with Gideros Studio