aboutsummaryrefslogtreecommitdiff
path: root/src/porting.h
blob: 4d30a5970f2ffd20b66088d60d48a4b2c1fac89d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

/*
	Random portability stuff
*/

#pragma once

#ifdef _WIN32
	#ifdef _WIN32_WINNT
		#undef _WIN32_WINNT
	#endif
	#define _WIN32_WINNT 0x0501 // We need to do this before any other headers
		// because those might include sdkddkver.h which defines _WIN32_WINNT if not already set
#endif

#include <string>
#include <vector>
#include "irrlicht.h"
#include "irrlichttypes.h" // u32
#include "irrlichttypes_extrabloated.h"
#include "debug.h"
#include "constants.h"
#include "gettime.h"

#ifdef _MSC_VER
	#define SWPRINTF_CHARSTRING L"%S"
#else
	#define SWPRINTF_CHARSTRING L"%s"
#endif

//currently not needed
//template<typename T> struct alignment_trick { char c; T member; };
//#define ALIGNOF(type) offsetof (alignment_trick<type>, member)

#ifdef _WIN32
	#include <windows.h>

	#define sleep_ms(x) Sleep(x)
#else
	#include <unistd.h>
	#include <cstdint> //for uintptr_t

	// Use standard Posix macro for Linux
	#if (defined(linux) || defined(__linux)) && !defined(__linux__)
		#define __linux__
	#endif
	#if (defined(__linux__) || defined(__GNU__)) && !defined(_GNU_SOURCE)
		#define _GNU_SOURCE
	#endif

	#define sleep_ms(x) usleep(x*1000)
#endif

#ifdef _MSC_VER
	#define ALIGNOF(x) __alignof(x)
	#define strtok_r(x, y, z) strtok_s(x, y, z)
	#define strtof(x, y) (float)strtod(x, y)
	#define strtoll(x, y, z) _strtoi64(x, y, z)
	#define strtoull(x, y, z) _strtoui64(x, y, z)
	#define strcasecmp(x, y) stricmp(x, y)
	#define strncasecmp(x, y, n) strnicmp(x, y, n)
#else
	#define ALIGNOF(x) __alignof__(x)
#endif

#ifdef __MINGW32__
	#define strtok_r(x, y, z) mystrtok_r(x, y, z)
#endif

// strlcpy is missing from glibc.  thanks a lot, drepper.
// strlcpy is also missing from AIX and HP-UX because they aim to be weird.
// We can't simply alias strlcpy to MSVC's strcpy_s, since strcpy_s by
// default raises an assertion error and aborts the program if the buffer is
// too small.
#if defined(__FreeBSD__) || defined(__NetBSD__)    || \
	defined(__OpenBSD__) || defined(__DragonFly__) || \
	defined(__APPLE__)   ||                           \
	defined(__sun)       || defined(sun)           || \
	defined(__QNX__)     || defined(__QNXNTO__)
	#define HAVE_STRLCPY
#endif

// So we need to define our own.
#ifndef HAVE_STRLCPY
	#define strlcpy(d, s, n) mystrlcpy(d, s, n)
#endif

#define PADDING(x, y) ((ALIGNOF(y) - ((uintptr_t)(x) & (ALIGNOF(y) - 1))) & (ALIGNOF(y) - 1))

#if defined(__APPLE__)
	#include <mach-o/dyld.h>
	#include <CoreFoundation/CoreFoundation.h>
#endif

#ifndef _WIN32 // Posix
	#include <sys/time.h>
	#include <ctime>

#if defined(__MACH__) && defined(__APPLE__)
		#include <mach/clock.h>
		#include <mach/mach.h>
	#endif
#endif

namespace porting
{

/*
	Signal handler (grabs Ctrl-C on POSIX systems)
*/

void signal_handler_init();
// Returns a pointer to a bool.
// When the bool is true, program should quit.
bool * signal_handler_killstatus();

/*
	Path of static data directory.
*/
extern std::string path_share;

/*
	Directory for storing user data. Examples:
	Windows: "C:\Documents and Settings\user\Application Data\<PROJECT_NAME>"
	Linux: "~/.<PROJECT_NAME>"
	Mac: "~/Library/Application Support/<PROJECT_NAME>"
*/
extern std::string path_user;

/*
	Path to gettext locale files
*/
extern std::string path_locale;

/*
	Path to directory for storing caches.
*/
extern std::string path_cache;

/*
	Get full path of stuff in data directory.
	Example: "stone.png" -> "../data/stone.png"
*/
std::string getDataPath(const char *subpath);

/*
	Move cache folder from path_user to the
	system cache location if possible.
*/
void migrateCachePath();

/*
	Initialize path_*.
*/
void initializePaths();

/*
	Return system information
	e.g. "Linux/3.12.7 x86_64"
*/
std::string get_sysinfo();


// Monotonic counter getters.

#ifdef _WIN32 // Windows

extern double perf_freq;

inline u64 os_get_time(double mult)
{
	LARGE_INTEGER t;
	QueryPerformanceCounter(&t);
	return static_cast<double>(t.QuadPart) / (perf_freq / mult);
}

// Resolution is <1us.
inline u64 getTimeS() { return os_get_time(1); }
inline u64 getTimeMs() { return os_get_time(1000); }
inline u64 getTimeUs() { return os_get_time(1000*1000); }
inline u64 getTimeNs() { return os_get_time(1000*1000*1000); }

#else // Posix

inline void os_get_clock(struct timespec *ts)
{
#if defined(__MACH__) && defined(__APPLE__)
// From http://stackoverflow.com/questions/5167269/clock-gettime-alternative-in-mac-os-x
// OS X does not have clock_gettime, use clock_get_time
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;
#elif defined(CLOCK_MONOTONIC_RAW)
	clock_gettime(CLOCK_MONOTONIC_RAW, ts);
#elif defined(_POSIX_MONOTONIC_CLOCK)
	clock_gettime(CLOCK_MONOTONIC, ts);
#else
	struct timeval tv;
	gettimeofday(&tv, NULL);
	TIMEVAL_TO_TIMESPEC(&tv, ts);
#endif
}

inline u64 getTimeS()
{
	struct timespec ts;
	os_get_clock(&ts);
	return ts.tv_sec;
}

inline u64 getTimeMs()
{
	struct timespec ts;
	os_get_clock(&ts);
	return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}

inline u64 getTimeUs()
{
	struct timespec ts;
	os_get_clock(&ts);
	return ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
}

inline u64 getTimeNs()
{
	struct timespec ts;
	os_get_clock(&ts);
	return ts.tv_sec * 1000000000 + ts.tv_nsec;
}

#endif

inline u64 getTime(TimePrecision prec)
{
	switch (prec) {
	case PRECISION_SECONDS: return getTimeS();
	case PRECISION_MILLI:   return getTimeMs();
	case PRECISION_MICRO:   return getTimeUs();
	case PRECISION_NANO:    return getTimeNs();
	}
	FATAL_ERROR("Called getTime with invalid time precision");
}

/**
 * Delta calculation function arguments.
 * @param old_time_ms old time for delta calculation
 * @param new_time_ms new time for delta calculation
 * @return positive delta value
 */
inline u64 getDeltaMs(u64 old_time_ms, u64 new_time_ms)
{
	if (new_time_ms >= old_time_ms) {
		return (new_time_ms - old_time_ms);
	}

	return (old_time_ms - new_time_ms);
}

inline const char *getPlatformName()
{
	return
#if defined(ANDROID)
	"Android"
#elif defined(__linux__)
	"Linux"
#elif defined(_WIN32) || defined(_WIN64)
	"Windows"
#elif defined(__DragonFly__) || defined(__FreeBSD__) || \
		defined(__NetBSD__) || defined(__OpenBSD__)
	"BSD"
#elif defined(__APPLE__) && defined(__MACH__)
	#if TARGET_OS_MAC
		"OSX"
	#elif TARGET_OS_IPHONE
		"iOS"
	#else
		"Apple"
	#endif
#elif defined(_AIX)
	"AIX"
#elif defined(__hpux)
	"HP-UX"
#elif defined(__sun) || defined(sun)
	#if defined(__SVR4)
		"Solaris"
	#else
		"SunOS"
	#endif
#elif defined(__CYGWIN__)
	"Cygwin"
#elif defined(__unix__) || defined(__unix)
	#if defined(_POSIX_VERSION)
		"Posix"
	#else
		"Unix"
	#endif
#else
	"?"
#endif
	;
}

bool secure_rand_fill_buf(void *buf, size_t len);

// This attaches to the parents process console, or creates a new one if it doesnt exist.
void attachOrCreateConsole();

int mt_snprintf(char *buf, const size_t buf_size, const char *fmt, ...);
} // namespace porting

#ifdef __ANDROID__
#include "porting_android.h"
#endif
<boolean> -- When set, we will automatically re-set the route (designated by routeset) }, [2] = { -- Variant: end of track-circuited area (initial state of TC) ts_id = nil, -- this is the indication for end_of_interlocking section_free = <boolean>, --this can be set by an exit node via mesecons or atlatc, -- or from the tc formspec. } } Track section [id] = { name = "Some human-readable name" tc_breaks = { <signal specifier>,... } -- Bounding TC's (signal specifiers) -- Can be direct ends (auto-detected), conflicting routes or TCBs that are too far away from each other route = { origin = <signal>, -- route origin entry = <sigd>, -- supposed train entry point rsn = <string>, first = <bool> } route_post = { locks = {[n] = <pts>} next = <sigd> } -- Set whenever a route has been set through this TC. It saves the origin tcb id and side -- (=the origin signal). rsn is some description to be shown to the user -- first says whether to clear the routesetting status from the origin signal. -- locks contains the positions where locks are held by this ts. -- 'route' is cleared when train enters the section, while 'route_post' cleared when train leaves section. trains = {<id>, ...} -- Set whenever a train (or more) reside in this TC } Signal specifier (sigd) (a pair of TCB/Side): {p = <pos>, s = <1/2>} Signal Assignments: reverse lookup of signals assigned to TCBs signal_assignments = { [<signal pts>] = <sigd> } ]] -- function ildb.create_tcb(pos) local new_tcb = { [1] = {}, [2] = {}, } local pts = advtrains.roundfloorpts(pos) if not track_circuit_breaks[pts] then track_circuit_breaks[pts] = new_tcb return true else return false end end function ildb.get_tcb(pos) local pts = advtrains.roundfloorpts(pos) return track_circuit_breaks[pts] end function ildb.get_tcbs(sigd) local tcb = ildb.get_tcb(sigd.p) if not tcb then return nil end return tcb[sigd.s] end function ildb.create_ts(sigd) local tcbs = ildb.get_tcbs(sigd) local id = advtrains.random_id() while track_sections[id] do id = advtrains.random_id() end track_sections[id] = { name = "Section "..id, tc_breaks = { sigd } } tcbs.ts_id = id end function ildb.get_ts(id) return track_sections[id] end -- various helper functions handling sigd's local sigd_equal = advtrains.interlocking.sigd_equal local function insert_sigd_nodouble(list, sigd) for idx, cmp in pairs(list) do if sigd_equal(sigd, cmp) then return end end table.insert(list, sigd) end -- This function will actually handle the node that is in connid direction from the node at pos -- so, this needs the conns of the node at pos, since these are already calculated local function traverser(found_tcbs, pos, conns, connid, count, brk_when_found_n) local adj_pos, adj_connid, conn_idx, nextrail_y, next_conns = advtrains.get_adjacent_rail(pos, conns, connid, advtrains.all_tracktypes) if not adj_pos then --atdebug("Traverser found end-of-track at",pos, connid) return end -- look whether there is a TCB here if #next_conns == 2 then --if not, don't even try! local tcb = ildb.get_tcb(adj_pos) if tcb then -- done with this branch --atdebug("Traverser found tcb at",adj_pos, adj_connid) insert_sigd_nodouble(found_tcbs, {p=adj_pos, s=adj_connid}) return end end -- recursion abort condition if count > TRAVERSER_LIMIT then --atdebug("Traverser hit counter at",adj_pos, adj_connid) return true end -- continue traversing local counter_hit = false for nconnid, nconn in ipairs(next_conns) do if adj_connid ~= nconnid then counter_hit = counter_hit or traverser(found_tcbs, adj_pos, next_conns, nconnid, count + 1, brk_when_found_n) if brk_when_found_n and #found_tcbs>=brk_when_found_n then break end end end return counter_hit end -- Merges the TS with merge_id into root_id and then deletes merge_id local function merge_ts(root_id, merge_id) local rts = ildb.get_ts(root_id) local mts = ildb.get_ts(merge_id) if not mts then return end -- This may be the case when sync_tcb_neighbors -- inserts the same id twice. do nothing. if not ildb.may_modify_ts(rts) then return false end if not ildb.may_modify_ts(mts) then return false end -- cobble together the list of TCBs for _, msigd in ipairs(mts.tc_breaks) do local tcbs = ildb.get_tcbs(msigd) if tcbs then insert_sigd_nodouble(rts.tc_breaks, msigd) tcbs.ts_id = root_id end advtrains.interlocking.show_tcb_marker(msigd.p) end -- done track_sections[merge_id] = nil end local lntrans = { "A", "B" } local function sigd_to_string(sigd) return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s] end -- Check for near TCBs and connect to their TS if they have one, and syncs their data. function ildb.sync_tcb_neighbors(pos, connid) local found_tcbs = { {p = pos, s = connid} } local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes) if not node_ok then error("update_tcb_neighbors but node is NOK: "..minetest.pos_to_string(pos)) end --atdebug("Traversing from ",pos, connid) local counter_hit = traverser(found_tcbs, pos, conns, connid, 0) local ts_id local list_eoi = {} local list_ok = {} local list_mismatch = {} local ts_to_merge = {} for idx, sigd in pairs(found_tcbs) do local tcbs = ildb.get_tcbs(sigd) if not tcbs.ts_id then --atdebug("Sync: put",sigd_to_string(sigd),"into list_eoi") table.insert(list_eoi, sigd) elseif not ts_id and tcbs.ts_id then if not ildb.get_ts(tcbs.ts_id) then atwarn("Track section database is inconsistent, there's no TS with ID=",tcbs.ts_id) tcbs.ts_id = nil table.insert(list_eoi, sigd) else --atdebug("Sync: put",sigd_to_string(sigd),"into list_ok") ts_id = tcbs.ts_id table.insert(list_ok, sigd) end elseif ts_id and tcbs.ts_id and tcbs.ts_id ~= ts_id then atwarn("Track section database is inconsistent, sections share track!") atwarn("Merging",tcbs.ts_id,"into",ts_id,".") table.insert(list_mismatch, sigd) table.insert(ts_to_merge, tcbs.ts_id) end end if ts_id then local ts = ildb.get_ts(ts_id) for _, sigd in ipairs(list_eoi) do local tcbs = ildb.get_tcbs(sigd) tcbs.ts_id = ts_id table.insert(ts.tc_breaks, sigd) advtrains.interlocking.show_tcb_marker(sigd.p) end for _, mts in ipairs(ts_to_merge) do merge_ts(ts_id, mts) end end end function ildb.link_track_sections(merge_id, root_id) if merge_id == root_id then return end merge_ts(root_id, merge_id) end function ildb.remove_from_interlocking(sigd) local tcbs = ildb.get_tcbs(sigd) if not ildb.may_modify_tcbs(tcbs) then return false end if tcbs.ts_id then local tsid = tcbs.ts_id local ts = ildb.get_ts(tsid) if not ts then tcbs.ts_id = nil return true end -- remove entry from the list local idx = 1 while idx <= #ts.tc_breaks do local cmp = ts.tc_breaks[idx] if sigd_equal(sigd, cmp) then table.remove(ts.tc_breaks, idx) else idx = idx + 1 end end tcbs.ts_id = nil --ildb.sync_tcb_neighbors(sigd.p, sigd.s) if #ts.tc_breaks == 0 then track_sections[tsid] = nil end end advtrains.interlocking.show_tcb_marker(sigd.p) if tcbs.signal then return false end return true end function ildb.remove_tcb(pos) local pts = advtrains.roundfloorpts(pos) if not track_circuit_breaks[pts] then return end for connid=1,2 do if not ildb.remove_from_interlocking({p=pos, s=connid}) then return false end end track_circuit_breaks[pts] = nil return true end function ildb.dissolve_ts(ts_id) local ts = ildb.get_ts(ts_id) if not ildb.may_modify_ts(ts) then return false end local tcbr = advtrains.merge_tables(ts.tc_breaks) for _,sigd in ipairs(tcbr) do ildb.remove_from_interlocking(sigd) end -- Note: ts gets removed in the moment of the removal of the last TCB. return true end -- Returns true if it is allowed to modify any property of a track section, such as -- - removing TCBs -- - merging and dissolving sections -- As of now the action will be denied if a route is set or if a train is in the section. function ildb.may_modify_ts(ts) if ts.route or ts.route_post or (ts.trains and #ts.trains>0) then return false end return true end function ildb.may_modify_tcbs(tcbs) if tcbs.ts_id then local ts = ildb.get_ts(tcbs.ts_id) if ts and not ildb.may_modify_ts(ts) then return false end end return true end -- Utilize the traverser to find the track section at the specified position -- Returns: -- ts_id, origin - the first found ts and the sigd of the found tcb -- nil - there were no TCBs in TRAVERSER_MAX range of the position -- false - the first found TCB stated End-Of-Interlocking, or track ends were reached function ildb.get_ts_at_pos(pos) local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes) if not node_ok then error("get_ts_at_pos but node is NOK: "..minetest.pos_to_string(pos)) end local limit_hit = false local found_tcbs = {} for connid, conn in ipairs(conns) do -- Note: a breadth-first-search would be better for performance limit_hit = limit_hit or traverser(found_tcbs, pos, conns, connid, 0, 1) if #found_tcbs >= 1 then local tcbs = ildb.get_tcbs(found_tcbs[1]) local ts if tcbs.ts_id then return tcbs.ts_id, found_tcbs[1] else return false end end end if limit_hit then -- there was at least one limit hit return nil else -- all traverser ends were track ends return false end end -- returns the sigd the signal at pos belongs to, if this is known function ildb.get_sigd_for_signal(pos) local pts = advtrains.roundfloorpts(pos) local sigd = signal_assignments[pts] if sigd then if not ildb.get_tcbs(sigd) then signal_assignments[pts] = nil return nil end return sigd end return nil end function ildb.set_sigd_for_signal(pos, sigd) local pts = advtrains.roundfloorpts(pos) signal_assignments[pts] = sigd end -- checks if a signal is influencing here function ildb.get_ip_signal(pts, connid) if influence_points[pts] then return influence_points[pts][connid] end end -- Tries to get aspect to obey here, if there -- is a signal ip at this location -- auto-clears invalid assignments function ildb.get_ip_signal_asp(pts, connid) local p = ildb.get_ip_signal(pts, connid) if p then local asp = advtrains.interlocking.signal_get_aspect(p) if not asp then atlog("Clearing orphaned signal influence point", pts, "/", connid) ildb.clear_ip_signal(pts, connid) return nil end return asp, p end return nil end -- set signal assignment. function ildb.set_ip_signal(pts, connid, spos) if not influence_points[pts] then influence_points[pts] = {} end influence_points[pts][connid] = spos end -- clear signal assignment. function ildb.clear_ip_signal(pts, connid) influence_points[pts][connid] = nil for _,_ in pairs(influence_points[pts]) do return end influence_points[pts] = nil end function ildb.get_ip_by_signalpos(spos) for pts,tab in pairs(influence_points) do for connid,pos in pairs(tab) do if vector.equals(pos, spos) then return pts, connid end end end end -- clear signal assignment given the signal position function ildb.clear_ip_by_signalpos(spos) local pts, connid = ildb.get_ip_by_signalpos(spos) if pts then ildb.clear_ip_signal(pts, connid) end end advtrains.interlocking.db = ildb