Random Chitchat 2017

[ShadowCone]

I wonder if the "conversions" are actually right, cause if so it's awesome to have a larger audience but unfortunately no more downloads (or did they happen via github)

[sphinxc0re]

On Aug 22. there were over 3000 people on the website. You are right, it seems like the downloads didn't go up.

[sphinxc0re]

:D   2000 Stars!!!!

[NiLSPACE]

Nice

[Seadragon91]

"Can you trust your CPU?" 

The sandsifter audits x86 processors for hidden instructions and hardware bugs, by systematically generating machine code to search through a processor's instruction set, and monitoring execution for anomalies. Sandsifter has uncovered secret processor instructions from every major vendor; ubiquitous software bugs in disassemblers, assemblers, and emulators; flaws in enterprise hypervisors; and both benign and security-critical hardware bugs in x86 chips.

Source: https://github.com/xoreaxeaxeax/sandsifter

[Seadragon91]

The rank command doesn't work if authentication mode is off. I always get "tried to execute forbidden command" Trying to find the cause...

[Seadragon91]

Has been broken by the cUUID implementation.

Edit: Created an issue

Edit 2: A fix has been merged. Thanks to peterbell10

[xoft]

I've finally brought my new API idea from #252 ( https://forum.cuberite.org/thread-2727-p...l#pid28462 ) to a fully compilable and runnable life. It seems it's actually working, and additionally has a nice bonus of being ~7 % faster than the old style (tested with a single-signature API function). Adding and actually using an overload signature is a bit difficult to measure, but I assume it would perform even better than an equivalent old-style code; the old style performs unneeded double-checks which the new code doesn't do.
As for some real data:
Old style interface with only single signature: 3.012 seconds per 1000 000 API calls
New style interface, first signature used: 2.803 seconds per 1 000 000 API calls
New style interface, second signature used: 3.766 seconds per 1 000 000 API calls
I didn't test an old-style interface with multiple signatures. Anyway, the times show how unimportant the cost is - about 3 microseconds per call.

Because the cLuaState class is already quite large, I decided to put the new coed into a separate namespace-like class, cLuaStateParams. So this is an example code that actually works with the new style:

static int tolua_cServer_RegisterForgeMod(lua_State * a_LuaState)
{
	cLuaState L(a_LuaState);
	cServer * Server;
	AString Name, Version;
	UInt32 Protocol;
	switch (cLuaStateParams::Read(L,
		std::tie(cLuaStateParams::self(Server), Name, Version, Protocol),
		std::tie(cLuaStateParams::staticSelf<cServer>(), Name, Version, Protocol)
	))
	{
		case 0:
		{
			Server->RegisterForgeMod(Name, Version, Protocol);
			break;
		}
		case 1:
		{
			cServer::Get()->RegisterForgeMod(Name, Version, Protocol);
			break;
		}
	}
	return 0;
}

Now to see if the whole thing compiles under clang / gcc

[xoft]

Yeah, and gcc / clang totally have to break things, because they don't allow a reference to be bound to a temporary object:
std::tie(someFunctionReturningObject(), ...)
fails to compile because std::tie expects a reference and gcc / clang won't auto convert

[xoft]

Baaaah, why do the Linux tools always have to totally break my stuff (((
The code compiles and works great in MSVC, it doesn't use anything else than a bit of template magic, but no, gcc won't compile it, because reasons.
I'm afraid I'm at my wits' ends, I need help from someone who knows some advanced template-fu.
https://github.com/cuberite/cuberite/pull/3981