Nelua (stands for Native Extensible Lua) is a minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code.
Nelua is a systems programming language for performance-sensitive applications where Lua would not be efficient, such as operating systems, real-time applications and game engines. While it has syntax and semantics similar to Lua, it primarily focuses on generating efficient C code and provide support for highly-optimizable low-level programming. Using Nelua idioms such as records, arrays, manual memory management and pointers should result in performance as efficient as pure C; on the other hand, when using Lua idioms such as tables, metatables and untyped variables, the compiler will bake a runtime library for this sort of dynamic functionality into the program, which could incur some runtime overhead.
Nelua can do meta programming at compile time through preprocessor constructs written in Lua; since the compiler itself is also written in Lua, it means that user-provided preprocessor code can interact at any point with the compiler's internals and the source code's AST. Such system allows for ad-hoc implementation of high level constructs such as classes, generics and polymorphism, all without having to add them into the core specification, thus keeping the language simple, extensible and compact. The same way that Lua's object-oriented patterns are not built into the language, but can be nonetheless achieved through metatables, in Nelua you could yourself implement a similar functionality which is fully decided at compile time or dynamically dispatched at runtime.
Nelua can do extensible programming as the programmer may add extensions to the language such as new grammars, AST definitions, semantics, type checkers, code generation and behaviors to the compiler at compile time via the preprocessor.
Nelua provides support for both garbage-collected and manual memory management in a way that the developer can easily choose between either for each allocation in the program.
Nelua first compiles to C, then it executes a C compiler to produce native code. This way existing C code and libraries can be leveraged and new C libraries can be created. Another benefit is that Nelua can reach the same target platforms as C99 compilers, such GCC or Clang, while also enjoying state-of-the-art compiler optimizations provided by them.
The initial motivation for its creation was to replace C/C++ parts of projects which currently uses Lua with a language that has syntax and semantics similar to Lua, but allows for fine-grained performance optimizations and does not lose the ability to go low level, therefore unifying the syntax and semantics across both compiled and dynamic languages.
Goals
require 'span'
require 'string'
require 'math'
require 'memory'
require 'allocators.gc'
require 'allocators.general'
do -- Comments
-- one line comment
--[[
multi-line comment
]]
--[=[
multi line comment, `=` can be placed multiple times
in case if you have `[[` `]]` tokens inside, it will
always match it's corresponding token
]=]
end
do -- Variables
local a = nil -- of deduced type 'any', initialized to nil
local b = false -- of deduced type 'boolean', initialized to false
local s = 'test' -- of deduced type 'string', initialized to 'test'
local one = 1 -- of type 'integer', initialized to 1
local pi: number = 3.14 -- of type 'number', initialized to 1
print(a,b,s,one,pi) -- outputs: nil false test 1 3.1400000
end
do -- Type deduction
local a -- type will be deduced and scope end
a = 1
a = 2
print(a) -- outputs: 2
-- end of scope, compiler deduced 'a' to be of type 'integer'
end
do -- Type collision
local a -- a type will be deduced
a = 2
a = false
print(a) -- outputs: false
-- a is deduced to be of type 'any', because it could hold an 'integer' or a 'boolean'
end
do -- Zero initialization
local a -- variable of deduced type 'any', initialized to 'nil'
local i: integer -- variable of type 'integer', initialized to 0
print(a, i) --outputs: nil 0
end
do -- Auto variables
local a: auto = 1 -- a is deduced to be of type 'integer'
-- uncommenting the following will trigger the compile error:
-- error: in variable assignment: no viable type conversion from `boolean` to `int64`
--a = false
print(a) -- outputs: 1
end
do -- Comptime variables
local a <comptime> = 1 + 2 -- constant variable evaluated and known at compile time
print(a) -- outputs: 3
end
do -- Const variables
local x <const> = 1
local a <const> = x
print(a) -- outputs: 1
-- uncommenting the following will trigger the compile error:
-- error: cannot assign a constant variable
--a = 2
end
do -- Local symbol
do
local a = 1
do
print(a) -- outputs: 1
end
end
-- this would trigger a compiler error because `a` is not visible:
-- a = 1
end
--do -- Global symbols
global global_a = 1
global function global_f()
return 'f'
end
-- require 'globals'
print(global_a) -- outputs: 1
print(global_f()) -- outputs: f
--end
do -- If
local a = 1 -- change this to 2 or 3 to trigger other ifs
if a == 1 then
print 'is one'
elseif a == 2 then
print 'is two'
else
print('not one or two')
end
end
do -- Switch
local a = 1 -- change this to 2 or 3 to trigger other ifs
switch a
case 1 then
print 'is 1'
case 2 then
print 'is 2'
else
print 'else'
end
end
do -- Do
do
local a = 0
print(a) -- outputs: 0
end
do
local a = 1 -- can declare variable named a again
print(a) -- outputs: 1
end
end
do -- Defer
do
defer
print 'world'
end
print 'hello'
end
-- outputs 'hello' then 'world'
end
do -- Goto
local haserr = true
if haserr then
goto getout -- get out of the loop
end
print 'success'
::getout::
print 'fail'
-- outputs only 'fail'
end
do -- While
local a = 1
while a <= 5 do
print(a) -- outputs 1 2 3 4 5
a = a + 1
end
end
do -- Repeat
local a = 0
repeat
a = a + 1
print(a) -- outputs 1 2 3 4 5
local stop = a == 5
until stop
end
do -- Numeric For
for i=0,5 do
-- i is deduced to 'integer'
print(i) -- outputs 0 1 2 3 4 5
end
end
do -- Numeric For Exclusive
for i=0,<5 do
print(i) -- outputs 0 1 2 3 4
end
end
do -- Numeric For Stepped
for i=5,0,-1 do
print(i) -- outputs 5 4 3 2 1
end
end
do -- Continue
for i=1,10 do
if i<=5 then
continue
end
print(i) -- outputs: 6 7 8 9 10
end
end
do -- Break
for i=1,10 do
if i>5 then
break
end
print(i) -- outputs: 1 2 3 4 5
end
end
do -- Boolean
local a: boolean -- variable of type 'boolean' initialized to 'false'
local b = false
local c = true
print(a,b,c) -- outputs: false false true
end
do -- Numbers
local a = 1234 -- variable of type 'integer'
local b = 0xff -- variable of type 'integer'
local c = 3.14159 -- variable of type 'number'
local d: integer
print(a,b,c,d) -- outputs: 1234 255 3.141590 0
do
local a = 1234_u32 -- variable of type 'int32'
local b = 1_f32 -- variable of type 'float32'
print(a,b) --outputs: 1234 1.000000
end
end
do -- String
local mystr: string -- empty string
local str1: string = 'my string' -- variable of type 'string'
local str2 = "static stringview" -- variable of type 'stringview'
local str3: stringview = 'stringview two' -- also a 'stringview'
print(str1, str2, str3) -- outputs: "" "string one" "string two"
end
do -- The "type" type
local MyInt: type = @integer -- a symbol of type 'type' holding the type 'integer'
local a: MyInt -- variable of type 'MyInt' (actually an 'integer')
print(a) -- outputs: 0
end
do -- Explicit type conversion
local i = 1
local f = (@number)(i) -- convert 'i' to the type 'number'
print(i, f) -- outputs: 1 1.000000
local MyNumber = @number
local i = 1
local f = MyNumber(i) -- convert 'i' to the type 'number'
print(i, f) -- outputs: 1 1.000000
end
do print('Implicit type conversion')
local i: integer = 1
local u: uinteger = i
print(u) -- outputs: 1
local ni: integer = -1
local nu: uinteger = (@uinteger)(ni) -- explicit cast works, no checks are done
print(nu) -- outputs: 18446744073709551615
end
do -- Array
local a: array(integer, 4) = {1,2,3,4}
print(a[0], a[1], a[2], a[3]) -- outputs: 1 2 3 4
local b: [4]integer -- "[4]integer" is syntax sugar for "array(integer, 4)"
print(b[0], b[1], b[2], b[3]) -- outputs: 0 0 0 0
end
do -- Enum
local Weeks = @enum {
Sunday = 0,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday
}
print(Weeks.Sunday) -- outputs: 0
local a: Weeks = Weeks.Monday
print(a) -- outputs: 1
end
do -- Any
local a: any = 2 -- variable of type 'any', holding type 'integer' at runtime
print(a) -- outputs: 2
a = false -- now holds the type 'boolean' at runtime
print(a) -- outputs: false
end
do -- Record
local Person = @record {
name: string,
age: integer
}
-- typed initialization
local a: Person = {name = "Mark", age = 20}
print(a.name, a.age)
-- casting initialization
local b = (@Person){name = "Paul", age = 21}
print(b.name, b.age)
-- ordered fields initialization
local c = (@Person){"Eric", 21}
print(c.name, c.age)
-- late initialization
local d: Person
d.name = "John"
d.age = 22
print(d.name, d.age)
end
do -- Span
local arr = (@[4]integer) {1,2,3,4}
local s: span(integer) = &arr
print(s[0], s[1]) -- outputs: 1 2
print(#s) -- outputs 4
end
do -- Void
local function f(): void end
end
do -- Operators
print(2 ^ 2) -- pow, outputs: 4.000000
print(5 // 2) -- integer division, outputs: 2
print(5 / 2) -- float division, outputs: 2.500000
end
do -- Functions
local function get(a)
-- a is of type 'any'
return a -- return is of deduced type 'any'
end
print(get(1)) -- outputs: 1
local function add(a: integer, b: integer)
return a + b -- return is of deduced type 'integer'
end
print(add(1, 2)) -- outputs 3
end
do -- Return type inference
local function add(a: integer, b: integer): integer
return a + b -- return is of deduced type 'integer'
end
print(add(1, 2)) -- outputs 3
end
do -- Recursive calls
local function fib(n: integer): integer
if n < 2 then return n end
return fib(n - 2) + fib(n - 1)
end
print(fib(10)) -- outputs: 55
end
do -- Multiple returns
local function get_multiple()
return false, 1
end
local a, b = get_multiple()
-- a is of type 'boolean' with value 'false'
-- b is of type 'integer' with value '1'
print(a,b)
local function get_multiple(): (boolean, integer)
return false, 1
end
local a, b = get_multiple()
print(a,b) -- outputs: false 1
end
--do -- Top scope closures
local counter = 1 -- 'a' lives in the heap because it's on the top scope
local function increment() -- foo is a top scope closure
-- counter is an upvalue for this function, we can access and modify it
counter = counter + 1
end
print(counter) -- outputs 1
increment()
print(counter) -- outputs 2
--end
do -- Polymorphic functions
local function add(a: auto, b: auto)
return a + b
end
local a = add(1,2)
-- call to 'add', a function 'add(a: integer, b: integer): integer' is defined
print(a) -- outputs: 3
local b = add(1.0, 2.0)
-- call to 'add' with different types, function 'add(a: number, b: number): number' is defined
print(b) -- outputs: 3.000000
end
do -- Record functions
local Vec2 = @record{x: number, y: number}
function Vec2.create(x: integer, y: integer): Vec2
return (@Vec2){x, y}
end
local v = Vec2.create(1,2)
print(v.x, v.y) -- outputs: 1 2
end
do -- Record methods
local Rect = @record{x: number, y: number, w: number, h: number}
function Rect:translate(x: number, y: number)
self.x = self.x + x
self.y = self.y + y
end
function Rect:area()
return self.w * self.h
end
local v = Rect{0,0,2,3}
v:translate(2,2)
print(v.x, v.y) -- outputs 2 2
print(v:area()) -- outputs 6
end
do -- Record metamethods
local Vec2 = @record{x: number, y: number}
-- Called on the binary operator '+'
function Vec2.__add(a: Vec2, b: Vec2)
return (@Vec2){a.x+b.x, a.y+b.y}
end
-- Called on the unary operator '#'
function Vec2:__len()
return math.sqrt(self.x*self.x + self.y*self.y)
end
local a: Vec2 = {1, 2}
local b: Vec2 = {3, 4}
local c = a + b -- calls the __add metamethod
print(c.x, c.y) -- outputs: 4 6
local len = #c -- calls the __len metamethod
print(len) -- outputs: 7.2
end
do -- Dereferencing and referencing
local a = 1
local ap = &a -- ap is a pointer to a
$ap = 2
print(a) -- outputs 2
a = 3
print($ap) -- outputs 3
end
do -- Allocating memory
local Person = @record{name: string, age: integer}
local p: *Person = general_allocator:new(@Person)
p.name = "John"
p.age = 20
print(p.name, p.age)
general_allocator:delete(p)
p = nilptr
end
do -- Preprocessor
local a = 0
## for i = 1,4 do
a = a + 1 -- unroll this line 4 times
## end
print(a) -- outputs 4
##[[
local something = false
if something then
]]
print('hello') -- prints hello when compiling with "something" defined
##[[ end ]]
end
do -- Emitting AST nodes
local a = #[aster.Number{'dec','1'}]#
print(a) -- outputs: 1
end
do -- Expression replacement
local deg2rad = #[math.pi/180.0]#
local hello = #['hello' .. 'world']#
local mybool = #[false]#
print(deg2rad, hello, mybool) -- outputs: 0.017453 helloworld false
end
do -- Name replacement
local #|'my' .. 'var'|# = 1
print(myvar) -- outputs: 1
local function foo1() print 'foo' end
#|'foo' .. 1|#() -- outputs: foo
end
do -- Macros
## function increment(a, amount)
-- 'a' in the preprocessor context is a symbol, we access its name here
-- 'amount' in the preprocessor context is a lua number
#|a.name|# = #|a.name|# + #[amount]#
## end
local x = 0
## increment(x, 4)
print(x)
-- unroll
##[[
function unroll(count, block)
for i=1,count do
block()
end
end
]]
local counter = 1
## unroll(4, function()
print(counter) -- outputs: 1 2 3 4
counter = counter + 1
## end)
-- generic
## function Point(PointT, T)
local #|PointT|# = @record { x: #|T|#, y: #|T|# }
function #|PointT|#:squaredlength()
return self.x*self.x + self.y*self.y
end
## end
## Point('PointFloat', 'float64')
## Point('PointInt', 'int64')
local pa: PointFloat = {x=1,y=2}
print(pa:squaredlength()) -- outputs: 5
local pb: PointInt = {x=1,y=2}
print(pb:squaredlength()) -- outputs: 5.000000
end
do -- Preprocessor macros emitting AST nodes
##[[
-- Create a fixed array initializing to 1,2,3,4...n
local function create_sequence(attr_or_type, n)
local type
if traits.is_type(attr_or_type) then -- already a type
type = attr_or_type
elseif traits.is_attr(attr_or_type) then -- get a type from a symbol
type = attr_or_type.value
end
-- check if the inputs are valid, in case wrong input
static_assert(traits.is_type(type), 'expected a type or a symbol to a type')
static_assert(traits.is_number(n) and n > 0, 'expected n > 0')
-- create list of expression
local exprs = {}
for i=1,n do
-- aster.value convert any Lua value to the proper ASTNode
exprs[i] = aster.value(i)
end
-- create the Table ASTNode, it's used for any braces {} expression
return aster.Table{exprs, pattr = {
-- hint the compiler what type this braces should be evaluated
desiredtype = types.ArrayType(type, #exprs)}
}
end
]]
local a = #[create_sequence(integer, 10)]#
assert(#a == 10 and a[0] == 1 and a[9] == 10)
end
do -- Processing on the fly
local Weekends = @enum { Friday=0, Saturday, Sunday }
## for i,field in ipairs(Weekends.value.fields) do
print(#[field.name .. ' ' .. tostring(field.value)]#)
## end
local Person = @record{name: string}
## Person.value:add_field('age', primtypes.integer) -- add field 'age' to 'Person'
local p: Person = {name='Joe', age=21}
print(p.age) -- outputs '21'
end
do -- Preprocessing poly functions
local function pow(x: auto, n: integer)
## static_assert(x.type.is_arithmetic, 'cannot pow variable of type "%s"', x.type)
## if x.type.is_integral then
-- x is an integral type (any unsigned/signed integer)
local r: #[x.type]# = 1
for i=1,n do
r = r * x
end
return r
## elseif x.type.is_float then
-- x is a floating point type
return x ^ n
## end
end
local a = pow(2, 2) -- use specialized implementation for integers
local b = pow(2.0, 2) -- use pow implementation for floats
print(a,b) -- outputs: 4 4.000000
-- uncommenting the following will trigger the compile error:
-- error: cannot pow variable of type "string"
--pow('a', 2)
end
do -- Function annotations
local function sum(a: integer, b: integer) <inline> -- C inline function
return a + b
end
print(sum(1,2)) -- outputs: 3
end
do -- Variable annotations
local a: integer <noinit>-- don't initialize variable to zero
a = 0 -- manually initialize to zero
print(a) -- outputs: 0
local b <volatile> = 1 -- C volatile variable
print(b) -- outputs: 1
end
do -- Mixing C code
-- `cimport` informs the compiler the function name from C that should be imported
-- `cinclude` informs the compiler which C header its declared
-- `nodecl` informs the compiler that it doesn't need to declare it (C header already declares)
local function malloc(size: usize): pointer <cimport'malloc',cinclude'<stdlib.h>',nodecl> end
local function memset(s: pointer, c: int32, n: usize): pointer <cimport'memset',cinclude'<string.h>',nodecl> end
local function free(ptr: pointer) <cimport'free',cinclude'<stdlib.h>',nodecl> end
local a = (@*[10]int64)(malloc(10 * 8))
memset(a, 0, 10*8)
assert(a[0] == 0)
a[0] = 1
assert(a[0] == 1)
free(a)
end
require 'math'
-- SDL2 Snake Game Demo
## linklib 'SDL2'
-- import SDL structures
local SDL_Event <cimport> = @record {
type: uint32,
padding: [56]byte
}
local SDL_Keysym <cimport> = @record {
scancode: cint,
sym: int32,
mod: uint16,
unused: uint32
}
local SDL_KeyboardEvent <cimport> = @record {
type: uint32,
timestamp: uint32,
windowID: uint32,
state: uint8,
repeated: uint8,
padding: uint16,
keysym: SDL_Keysym
}
local SDL_Rect <cimport> = @record {
x: cint, y: cint,
w: cint, h: cint,
}
local SDL_Window <cimport> = @record{}
local SDL_Renderer <cimport> = @record{}
-- import SDL constants
local SDL_INIT_VIDEO <comptime> = 0x20
local SDL_WINDOWPOS_UNDEFINED <comptime> = 0x1fff0000
local SDL_WINDOW_OPENGL <comptime> = 0x2
local SDL_QUIT <comptime> = 0x100
local SDL_KEYDOWN <comptime> = 0x300
local SDLK_RIGHT <comptime> = 79 | 0x40000000
local SDLK_LEFT <comptime> = 80 | 0x40000000
local SDLK_DOWN <comptime> = 81 | 0x40000000
local SDLK_UP <comptime> = 82 | 0x40000000
local SDL_RENDERER_ACCELERATED <comptime> = 0x2
local SDL_RENDERER_PRESENTVSYNC <comptime> = 0x4
-- import SDL functions
local function SDL_Init(flags: uint32): int32 <cimport> end
local function SDL_CreateWindow(title: cstring, x: cint, y: cint, w: cint, h: cint, flags: uint32): *SDL_Window <cimport> end
local function SDL_Quit() <cimport> end
local function SDL_DestroyWindow(window: *SDL_Window) <cimport> end
local function SDL_PollEvent(event: *SDL_Event): int32 <cimport> end
local function SDL_CreateRenderer(window: *SDL_Window, index: cint, flags: uint32): *SDL_Renderer <cimport> end
local function SDL_DestroyRenderer(renderer: *SDL_Renderer) <cimport> end
local function SDL_RenderPresent(renderer: *SDL_Renderer) <cimport> end
local function SDL_RenderClear(renderer: *SDL_Renderer) <cimport> end
local function SDL_SetRenderDrawColor(renderer: *SDL_Renderer, r: uint8, g: uint8, b: uint8, a: uint8): cint <cimport> end
local function SDL_RenderFillRect(renderer: *SDL_Renderer, rect: *SDL_Rect): cint <cimport> end
local function SDL_GetTicks(): uint32 <cimport> end
-- game types
local Point2D = @record{x: integer, y: integer}
local Direction = @enum(byte){NONE=0, UP, DOWN, RIGHT, LEFT}
local Color = @record{r: byte, g: byte, b: byte}
-- game constants
local TILE_SIZE <comptime> = 64
local GRID_SIZE <comptime> = 12
local SCREEN_SIZE <comptime> = TILE_SIZE * GRID_SIZE
local MOVE_DELAY <comptime> = 128
local COLOR_RED <const> = Color{r=255, g=96, b=96}
local COLOR_GREEN <const> = Color{r=96, g=255, b=96}
local COLOR_BLACK <const> = Color{r=0, g=0, b=0}
-- game state variables
local renderer
local movedir
local quit = false
local nextmove
local score
local headpos, tailpos, applepos
local tiles: [GRID_SIZE][GRID_SIZE]Direction
local function move_point(pos: Point2D, dir: Direction)
switch dir
case Direction.UP then
pos.y = pos.y - 1
case Direction.DOWN then
pos.y = pos.y + 1
case Direction.RIGHT then
pos.x = pos.x + 1
case Direction.LEFT then
pos.x = pos.x - 1
end
return pos
end
local function set_tile(pos: Point2D, dir: Direction)
tiles[pos.x][pos.y] = dir
end
local function reset_tile(pos: Point2D)
tiles[pos.x][pos.y] = Direction.NONE
end
local function get_tile(pos: Point2D)
return tiles[pos.x][pos.y]
end
local function has_tile(pos: Point2D)
return tiles[pos.x][pos.y] ~= Direction.NONE
end
local function respawn_apple()
-- respawn until there is no collision with its body
repeat
applepos = Point2D{
x = math.random(GRID_SIZE) - 1,
y = math.random(GRID_SIZE) - 1
}
until not has_tile(applepos)
end
local function init_game()
tiles = {}
headpos = Point2D{x=GRID_SIZE//2, y=GRID_SIZE//2}
tailpos = Point2D{x=headpos.x, y=headpos.y+1}
movedir = Direction.UP
score = 0
nextmove = 0
set_tile(headpos, Direction.UP)
set_tile(tailpos, Direction.UP)
respawn_apple()
print 'NEW GAME'
end
local function game_over()
print 'GAME OVER.'
init_game()
end
local function poll_events()
local event: SDL_Event
while SDL_PollEvent(&event) ~= 0 do
switch event.type
case SDL_QUIT then
quit = true
case SDL_KEYDOWN then
local kevent = (@*SDL_KeyboardEvent)(&event)
local headdir = get_tile(headpos)
switch kevent.keysym.sym
case SDLK_UP then
if headdir ~= Direction.DOWN then
movedir = Direction.UP
end
case SDLK_DOWN then
if headdir ~= Direction.UP then
movedir = Direction.DOWN
end
case SDLK_RIGHT then
if headdir ~= Direction.LEFT then
movedir = Direction.RIGHT
end
case SDLK_LEFT then
if headdir ~= Direction.RIGHT then
movedir = Direction.LEFT
end
end
end
end
end
local function poll_game()
local now = SDL_GetTicks()
if now < nextmove then return end
nextmove = now + MOVE_DELAY
-- move the head
set_tile(headpos, movedir)
headpos = move_point(headpos, movedir)
-- check collision with map boundaries
if headpos.x >= GRID_SIZE or headpos.y >= GRID_SIZE or
headpos.x < 0 or headpos.y < 0 then
game_over()
return
end
-- check collisions with its body
if has_tile(headpos) then
game_over()
return
end
-- place head on next tile
set_tile(headpos, movedir)
-- check collision with apple
if headpos.x == applepos.x and headpos.y == applepos.y then
respawn_apple()
score = score + 1
print('SCORE', score)
else
-- eat tail
local taildir = get_tile(tailpos)
reset_tile(tailpos)
tailpos = move_point(tailpos, taildir)
end
end
local function draw_background(color: Color)
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255)
SDL_RenderClear(renderer)
end
local function draw_tile(pos: Point2D, color: Color)
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255)
local rect = SDL_Rect{
x = pos.x * TILE_SIZE,
y = pos.y * TILE_SIZE,
w = TILE_SIZE,
h = TILE_SIZE
}
SDL_RenderFillRect(renderer, &rect)
end
local function draw_apple()
draw_tile(applepos, COLOR_RED)
end
local function draw_snake()
for x=0,GRID_SIZE-1 do
for y=0,GRID_SIZE-1 do
local pos = Point2D{x=x,y=y}
if has_tile(pos) then -- snake is present at this tile
draw_tile(pos, COLOR_GREEN)
end
end
end
end
local function draw()
draw_background(COLOR_BLACK)
draw_apple()
draw_snake()
end
local function go()
-- init sdl
SDL_Init(SDL_INIT_VIDEO)
local window = SDL_CreateWindow("An SDL2 Window",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
SCREEN_SIZE, SCREEN_SIZE, SDL_WINDOW_OPENGL)
assert(window, "Could not create window")
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC)
assert(renderer, "Could not create renderer")
init_game()
-- draw loop
repeat
poll_events()
poll_game()
draw()
-- swap buffers
SDL_RenderPresent(renderer)
until quit
-- cleanup and finish
SDL_DestroyWindow(window)
SDL_DestroyRenderer(renderer)
SDL_Quit()
end
go()
https://github.com/edubart/nelua-lang
Nelua (stands for Native Extensible Lua) is a minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code.
Last modified 16 December 2024