Lua: bit.compose, bit.binary_{ld,st}_*, bit.quotent

This commit is contained in:
Ilari Liusvaara 2014-01-30 02:34:49 +02:00
parent 9a9f58d747
commit 8670a7b01d
3 changed files with 171 additions and 0 deletions

65
lua.lyx
View file

@ -4115,6 +4115,71 @@ Syntax: number bit.swapsqword(number n)
Swap endianess of (un)signed integer <n>.
\end_layout
\begin_layout Subsection
bit.compose: Compose multi-byte number
\end_layout
\begin_layout Itemize
Syntax: number bit.compose(number n...)
\end_layout
\begin_layout Standard
Return
\begin_inset Formula $n_{1}+256n_{2}+256^{2}n_{3}+\ldots$
\end_inset
\end_layout
\begin_layout Subsection
bit.binary_ld_{{u,s}{8,16,24,32,64},float,double}{l,b}e: Load binary integer
\end_layout
\begin_layout Itemize
Syntax: number bit.binary_ld_<type>le(string str, number pos);
\end_layout
\begin_layout Itemize
Syntax: number bit.binary_ld_<type>be(string str, number pos);
\end_layout
\begin_layout Standard
Load little (*le) or big (*be) endian binary number from position <pos>
of string <str>.
Type may be one of: u8, u16, u24, u32, u64, s8, s16, s24, s32, s64, float,
double.
\end_layout
\begin_layout Subsection
bit.binary_st_{{u,s}{8,16,24,32,64},float,double}{l,b}e: Store binary integer
\end_layout
\begin_layout Itemize
Syntax: string bit.binary_st_<type>le(number x);
\end_layout
\begin_layout Itemize
Syntax: string bit.binary_st_<type>be(number x);
\end_layout
\begin_layout Standard
Store specified number <x> as binary in string and return the result.
Type may be one of: u8, u16, u24, u32, u64, s8, s16, s24, s32, s64, float,
double.
\end_layout
\begin_layout Subsection
bit.quotent: Integer quotent
\end_layout
\begin_layout Itemize
Syntax: number bit.quotent(number a, number b)
\end_layout
\begin_layout Standard
Calculate quotent a/b.
\end_layout
\begin_layout Standard
\begin_inset Newpage pagebreak
\end_inset

BIN
lua.pdf

Binary file not shown.

View file

@ -224,6 +224,62 @@ namespace
return 1;
}
int bit_compose(lua::state& L, lua::parameters& P)
{
uint64_t res = 0;
uint8_t shift = 0;
while(P.more()) {
uint64_t t;
P(t);
res |= (t << shift);
shift += 8;
}
L.pushnumber(res);
return 1;
}
template<typename T, bool littleendian>
int bit_ldbinarynumber(lua::state& L, lua::parameters& P)
{
T val;
char buffer[sizeof(T)];
size_t pos;
const char* str;
size_t len;
str = L.tolstring(P.skip(), len);
P(pos);
if(pos + sizeof(T) > len)
throw std::runtime_error(P.get_fname() + ": Offset out of range");
L.pushnumber(serialization::read_endian<T>(str + pos, littleendian ? -1 : 1));
return 1;
}
template<typename T, bool littleendian>
int bit_stbinarynumber(lua::state& L, lua::parameters& P)
{
T val;
char buffer[sizeof(T)];
P(val);
serialization::write_endian<T>(buffer, val, littleendian ? -1 : 1);
L.pushlstring(buffer, sizeof(T));
return 1;
}
int bit_quotent(lua::state& L, lua::parameters& P)
{
int64_t a, b;
P(a, b);
L.pushnumber(a / b);
return 1;
}
class lua_bit_dummy {};
lua::_class<lua_bit_dummy> bitops(lua_class_pure, "*bit", {
{"flagdecode", flagdecode_core<false>},
@ -256,5 +312,55 @@ namespace
{"popcount", bit_popcount},
{"clshift", bit_cshift<false>},
{"crshift", bit_cshift<true>},
{"compose", bit_compose},
{"quotent", bit_quotent},
{"binary_ld_u8be", bit_ldbinarynumber<uint8_t, false>},
{"binary_ld_s8be", bit_ldbinarynumber<int8_t, false>},
{"binary_ld_u16be", bit_ldbinarynumber<uint16_t, false>},
{"binary_ld_s16be", bit_ldbinarynumber<int16_t, false>},
{"binary_ld_u24be", bit_ldbinarynumber<ss_uint24_t, false>},
{"binary_ld_s24be", bit_ldbinarynumber<ss_int24_t, false>},
{"binary_ld_u32be", bit_ldbinarynumber<uint32_t, false>},
{"binary_ld_s32be", bit_ldbinarynumber<int32_t, false>},
{"binary_ld_u64be", bit_ldbinarynumber<uint64_t, false>},
{"binary_ld_s64be", bit_ldbinarynumber<int64_t, false>},
{"binary_ld_floatbe", bit_ldbinarynumber<float, false>},
{"binary_ld_doublebe", bit_ldbinarynumber<double, false>},
{"binary_ld_u8le", bit_ldbinarynumber<uint8_t, true>},
{"binary_ld_s8le", bit_ldbinarynumber<int8_t, true>},
{"binary_ld_u16le", bit_ldbinarynumber<uint16_t, true>},
{"binary_ld_s16le", bit_ldbinarynumber<int16_t, true>},
{"binary_ld_u24le", bit_ldbinarynumber<ss_uint24_t, true>},
{"binary_ld_s24le", bit_ldbinarynumber<ss_int24_t, true>},
{"binary_ld_u32le", bit_ldbinarynumber<uint32_t, true>},
{"binary_ld_s32le", bit_ldbinarynumber<int32_t, true>},
{"binary_ld_u64le", bit_ldbinarynumber<uint64_t, true>},
{"binary_ld_s64le", bit_ldbinarynumber<int64_t, true>},
{"binary_ld_floatle", bit_ldbinarynumber<float, true>},
{"binary_ld_doublele", bit_ldbinarynumber<double, true>},
{"binary_st_u8be", bit_stbinarynumber<uint8_t, false>},
{"binary_st_s8be", bit_stbinarynumber<int8_t, false>},
{"binary_st_u16be", bit_stbinarynumber<uint16_t, false>},
{"binary_st_s16be", bit_stbinarynumber<int16_t, false>},
{"binary_st_u24be", bit_stbinarynumber<ss_uint24_t, false>},
{"binary_st_s24be", bit_stbinarynumber<ss_int24_t, false>},
{"binary_st_u32be", bit_stbinarynumber<uint32_t, false>},
{"binary_st_s32be", bit_stbinarynumber<int32_t, false>},
{"binary_st_u64be", bit_stbinarynumber<uint64_t, false>},
{"binary_st_s64be", bit_stbinarynumber<int64_t, false>},
{"binary_st_floatbe", bit_stbinarynumber<float, false>},
{"binary_st_doublebe", bit_stbinarynumber<double, false>},
{"binary_st_u8le", bit_stbinarynumber<uint8_t, true>},
{"binary_st_s8le", bit_stbinarynumber<int8_t, true>},
{"binary_st_u16le", bit_stbinarynumber<uint16_t, true>},
{"binary_st_s16le", bit_stbinarynumber<int16_t, true>},
{"binary_st_u24le", bit_stbinarynumber<ss_uint24_t, true>},
{"binary_st_s24le", bit_stbinarynumber<ss_int24_t, true>},
{"binary_st_u32le", bit_stbinarynumber<uint32_t, true>},
{"binary_st_s32le", bit_stbinarynumber<int32_t, true>},
{"binary_st_u64le", bit_stbinarynumber<uint64_t, true>},
{"binary_st_s64le", bit_stbinarynumber<int64_t, true>},
{"binary_st_floatle", bit_stbinarynumber<float, true>},
{"binary_st_doublele", bit_stbinarynumber<double, true>},
});
}