Add bitwise operations support

Signed-off-by: Dusan Borovcanin <[email protected]>

Author: dborovcanin

README.md

@@ -50,6 +50,7 @@ go get github.com/vadv/gopher-lua-libs
 * [xmlpath](/xmlpath) [gopkg.in/xmlpath.v2](https://gopkg.in/xmlpath.v2) port
 * [yaml](/yaml) [gopkg.in/yaml.v2](https://gopkg.in/yaml.v2) port
 * [zabbix](/zabbix) zabbix bot
+* [bit](/bit) bitwise operations
 
 
 ## Usage

bit/README.md

@@ -0,0 +1,16 @@
+# stats [![GoDoc](https://godoc.org/github.com/vadv/gopher-lua-libs/bit?bit.svg)](https://godoc.org/github.com/vadv/gopher-lua-libs/stats)
+
+## Usage
+
+```lua
+local stats = require("bit")
+
+local result, _ = bit.band(1, 0)
+print(result)
+-- Output: 0
+
+local result, _ = stats.lshift(10, 5)
+print(result)
+-- Output: 320
+```
+

bit/api.go

@@ -0,0 +1,82 @@
+// Package strings implements golang package montanaflynn/stats functionality for lua.
+package stats
+
+import (
+	"fmt"
+	"math"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+type op uint
+
+const (
+	and op = iota
+	or
+	not
+	xor
+	ls
+	rs
+)
+
+// ShiftLeft
+func Bitwise(kind op) lua.LGFunction {
+	return func(l *lua.LState) int {
+		if kind > rs {
+			l.Push(lua.LString("invalid type of operation"))
+			return 1
+		}
+		val1, val2, err := prepareParams(l)
+		if err != nil {
+			l.Push(lua.LString(err.Error()))
+			return 1
+		}
+		var ret uint32
+		switch kind {
+		case and:
+			ret = val1 & val2
+		case or:
+			ret = val1 | val2
+		case xor:
+			ret = val1 ^ val2
+		case ls:
+			ret = val1 << val2
+		case rs:
+			ret = val1 >> val2
+		}
+		l.Push(lua.LNumber(ret))
+		return 1
+	}
+}
+
+func Not(l *lua.LState) int {
+	val, err := intToU32(l.CheckInt(1))
+	if err != nil {
+		l.Push(lua.LString(err.Error()))
+		return 1
+	}
+	l.Push(lua.LNumber(^val))
+	return 1
+}
+
+func prepareParams(l *lua.LState) (val, pos uint32, err error) {
+	val, err = intToU32(l.CheckInt(1))
+	if err != nil {
+		return 0, 0, err
+	}
+	pos, err = intToU32(l.CheckInt(2))
+	if err != nil {
+		return 0, 0, err
+	}
+	return
+}
+
+func intToU32(i int) (uint32, error) {
+	if i < 0 {
+		return 0, fmt.Errorf("cannot convert negative int %d to uint32", i)
+	}
+	if i > math.MaxUint32 {
+		return 0, fmt.Errorf("int %d overflows uint32", i)
+	}
+	return uint32(i), nil
+}

bit/api_test.go

@@ -0,0 +1,11 @@
+package stats
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/vadv/gopher-lua-libs/tests"
+	"testing"
+)
+
+func TestApi(t *testing.T) {
+	assert.NotZero(t, tests.RunLuaTestFile(t, Preload, "./test/test_api.lua"))
+}

bit/loader.go

@@ -0,0 +1,28 @@
+package stats
+
+import lua "github.com/yuin/gopher-lua"
+
+// Preload adds stats to the given Lua state's package.preload table. After it
+// has been preloaded, it can be loaded using require:
+//
+//	local bit = require("bit")
+func Preload(l *lua.LState) {
+	l.PreloadModule("bit", Loader)
+}
+
+// Loader is the module loader function.
+func Loader(L *lua.LState) int {
+	t := L.NewTable()
+	L.SetFuncs(t, api)
+	L.Push(t)
+	return 1
+}
+
+var api = map[string]lua.LGFunction{
+	"band":   Bitwise(and),
+	"bor":    Bitwise(or),
+	"bxor":   Bitwise(xor),
+	"lshift": Bitwise(ls),
+	"rshift": Bitwise(rs),
+	"bnot":   Not,
+}

bit/test/test_api.lua

@@ -0,0 +1,55 @@
+local bit = require("bit")
+
+function Test_and(t)
+    local result, err = bit.band(1, 0)
+    assert(not err, err)
+    assert(result == 0, "and get: " .. tostring(result))
+    result, err = bit.band(5, 6)
+    assert(not err, err)
+    assert(result == 4, "and get: " .. tostring(result))
+end
+
+function Test_or(t)
+    local result, err = bit.bor(1, 0)
+    assert(not err, err)
+    assert(result == 1, "or get: " .. tostring(result))
+    result, err = bit.bor(5, 6)
+    assert(not err, err)
+    assert(result == 7, "or get: " .. tostring(result))
+end
+
+function Test_xor(t)
+    local result, err = bit.bxor(1, 0)
+    assert(not err, err)
+    assert(result == 1, "xor get: " .. tostring(result))
+    result, err = bit.bxor(5, 6)
+    assert(not err, err)
+    assert(result == 3, "xor get: " .. tostring(result))
+end
+
+function Test_left_shift(t)
+    local result, err = bit.lshift(1, 0)
+    assert(not err, err)
+    assert(result == 1, "left_shift get: " .. tostring(result))
+    result, err = bit.lshift(0xFF, 8)
+    assert(not err, err)
+    assert(result == 65280, "left_shift get: " .. tostring(result))
+end
+
+function Test_right_shift(t)
+    local result, err = bit.rshift(42, 2)
+    assert(not err, err)
+    assert(result == 10, "right_shift get: " .. tostring(result))
+    result, err = bit.rshift(0xFF, 4)
+    assert(not err, err)
+    assert(result == 15, "right_shift get: " .. tostring(result))
+end
+
+function Test_not(t)
+    local result, err = bit.bnot(65536)
+    assert(not err, err)
+    assert(result == 4294901759, "not get: " .. tostring(result))
+    result, err = bit.bnot(4294901759)
+    assert(not err, err)
+    assert(result == 65536, "not get: " .. tostring(result))
+end