Merged in dev/macBuild (pull request #1)

Fix some issues when building on mac

Aaron R Robinson committed 9 years ago

Commit bf34adb2 parents db76c0c 0217bda13 files · +53 −50Browse files

Unified · Split

13 files

src/asm/type_signature.cpp +6 −6
src/compiler_settings.gypi +2 −1
src/include/disvm.h +3 −3
src/include/vm_asm.h +4 −4
src/vm/execution_table.cpp +2 −2
src/vm/stack.cpp +1 −1
src/vm/string.cpp +13 −13
src/vm/sys/Sysmod.cpp +3 −3
src/vm/sys/sys_utils.h +1 −1
src/vm/thread.cpp +1 −1
src/vm/tool_dispatch.cpp +1 −0
src/vm/vm.cpp +1 −1
src/vm/vm_memory.cpp +15 −14

@@ -138,11 +138,11 @@ sig_stream_t &disvm::assembly::sigkind::operator<<(sig_stream_t &os, const Tm &m · 137 unmodified lines
138	138	return os << m._s;
139	139	}
140	140
141		−const char Ttuple::begin = '(';
142		−const char Ttuple::end = ')';
	141	+template<> const char Ttuple::begin = '(';
	142	+template<> const char Ttuple::end = ')';
143	143
144		−const char Tmodule::begin = '{';
145		−const char Tmodule::end = '}';
	144	+template<> const char Tmodule::begin = '{';
	145	+template<> const char Tmodule::end = '}';
146	146
147	147	sig_stream_t &disvm::assembly::sigkind::operator<<(sig_stream_t &os, const Ttuple &t)
148	148	{
@@ -180,8 +180,8 @@ sig_stream_t &disvm::assembly::sigkind::operator<<(sig_stream_t &os, const Tadt_ · 31 unmodified lines
180	180	return os << t._s;
181	181	}
182	182
183		−const char Tnested_aggregate_type<type_id_t::adt>::begin = '(';
184		−const char Tnested_aggregate_type<type_id_t::adt>::end = ')';
	183	+template<> const char Tnested_aggregate_type<type_id_t::adt>::begin = '(';
	184	+template<> const char Tnested_aggregate_type<type_id_t::adt>::end = ')';
185	185
186	186	sig_stream_t &disvm::assembly::sigkind::operator<<(sig_stream_t &os, const Tnested_aggregate_type<type_id_t::adt> &a)
187	187	{

src/compiler_settings.gypi+2−1

@@ -5,7 +5,8 @@ · 4 unmodified lines
5	5	'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
6	6	'OTHER_CPLUSPLUSFLAGS' : ['-std=c++1y','-stdlib=libc++'],
7	7	'OTHER_LDFLAGS': ['-stdlib=libc++'],
8		− 'MACOSX_DEPLOYMENT_TARGET': '10.10'
	8	+ 'MACOSX_DEPLOYMENT_TARGET': '10.10',
	9	+ 'ARCHS': '$(ARCHS_STANDARD_32_BIT)'
9	10	}
10	11	}],
11	12	['OS=="win"', {

src/include/disvm.h+3−3

@@ -55,12 +55,12 @@ namespace disvm · 54 unmodified lines
55	55	class vm_t final
56	56	{
57	57	public: // static
58		− static const auto root_vm_thread_id = uint32_t{ 0 };
	58	+ static const uint32_t root_vm_thread_id = 0;
59	59
60		− static const auto default_system_thread_count = uint32_t{ 1 };
	60	+ static const uint32_t default_system_thread_count = 1;
61	61
62	62	// The Inferno implementation defined the thread quanta as 2048 (include/interp.h)
63		− static const auto default_thread_quanta = uint32_t{ 2048 };
	63	+ static const uint32_t default_thread_quanta = 2048;
64	64
65	65	public:
66	66	explicit vm_t(

src/include/vm_asm.h+4−4

@@ -137,7 +137,7 @@ namespace disvm · 136 unmodified lines
137	137	static Tbasic_aggregate_type create(const U &type)
138	138	{
139	139	sig_stream_t ss;
140		− ss << Tbasic_type::id << type;
	140	+ ss << Tbasic_type<ID>::id << type;
141	141
142	142	return Tbasic_aggregate_type{ ss };
143	143	}
@@ -209,7 +209,7 @@ namespace disvm · 65 unmodified lines
209	209	template<typename T1, typename T2, typename ...S>
210	210	void nested_type(sig_stream_t &ss, const T1 &t1, const T2 &t2, const S&...s)
211	211	{
212		− ss << t1 << sig_stream_t::type_delim;
	212	+ ss << t1 << sig_stream_t::delim;
213	213	nested_type(ss, t2, s...);
214	214	}
215	215
@@ -225,7 +225,7 @@ namespace disvm · 9 unmodified lines
225	225	static Tnested_aggregate_type create(const NT&... nestedTypes)
226	226	{
227	227	sig_stream_t ss;
228		− ss << Tbasic_type::id << Tnested_aggregate_type::begin;
	228	+ ss << Tbasic_type<ID>::id << Tnested_aggregate_type::begin;
229	229
230	230	nested_type(ss, nestedTypes...);
231	231
@@ -314,7 +314,7 @@ namespace disvm · 82 unmodified lines
314	314	}
315	315
316	316	private:
317		− Tadt(sig_stream_t &s) : Tnested_aggregate_type{ std::move(s) } { }
	317	+ Tadt(sig_stream_t &s) : Tnested_aggregate_type{ s } { }
318	318	};
319	319
320	320	sig_stream_t &operator<<(sig_stream_t &, const disvm::assembly::sigkind::Tnested_aggregate_type<type_id_t::adt> &);

src/vm/execution_table.cpp+2−2

@@ -708,7 +708,7 @@ namespace · 707 unmodified lines
708	708	const auto index = vt_ref<word_t>(r.mid);
709	709	const auto rune = str->get_rune(index);
710	710
711		− vt_ref<rune_t>(r.dest) = rune;
	711	+ vt_ref<runtime::rune_t>(r.dest) = rune;
712	712	}
713	713
714	714	// [SPEC] 'Insert Character' op code
@@ -721,7 +721,7 @@ namespace · 6 unmodified lines
721	721	// dst[src2] = src1
722	722	EXEC_DECL(insc)
723	723	{
724		− auto rune = vt_ref<rune_t>(r.src);
	724	+ auto rune = vt_ref<runtime::rune_t>(r.src);
725	725	auto index = vt_ref<word_t>(r.mid);
726	726	auto str = at_val<vm_string_t>(r.dest);
727	727	if (str == nullptr)

src/vm/stack.cpp+1−1

@@ -180,7 +180,7 @@ pointer_t vm_frame_t::fixed_point_register_2() const · 179 unmodified lines
180	180	vm_stack_t::vm_stack_t(std::size_t stack_extent)
181	181	: _mem{ std::make_unique<vm_stack_layout>(stack_extent) }
182	182	{
183		− assert(stack_extent != 0);
	183	+ assert(0 < stack_extent && stack_extent < static_cast<std::size_t>(std::numeric_limits<word_t>::max()));
184	184	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm stack\n");
185	185	}
186	186

src/vm/string.cpp+13−13

@@ -43,12 +43,12 @@ namespace · 42 unmodified lines
43	43
44	44	// Compare function for character types.
45	45	template <typename CharacterType1, typename CharacterType2>
46		− int _compare(word_t len, CharacterType1 s1, CharacterType2 s2)
	46	+ int _compare(word_t len, const CharacterType1 s1, const CharacterType2 s2)
47	47	{
48	48	for (auto i = word_t{ 0 }; i < len; ++i)
49	49	{
50		− const auto sc1 = static_cast<rune_t>(s1[i]);
51		− const auto sc2 = static_cast<rune_t>(s2[i]);
	50	+ const auto sc1 = static_cast<runtime::rune_t>(s1[i]);
	51	+ const auto sc2 = static_cast<runtime::rune_t>(s2[i]);
52	52
53	53	if (sc1 != sc2)
54	54	return (sc1 < sc2) ? (-1) : 1;
@@ -62,7 +62,7 @@ int vm_string_t::compare(const vm_string_t s1, const vm_string_t s2) · 7 unmodified lines
62	62	{
63	63	auto len_1 = word_t{ 0 };
64	64	auto scen_1 = ascii_idx;
65		− void *str_mem_1 = "";
	65	+ const void *str_mem_1 = "";
66	66	if (s1 != nullptr)
67	67	{
68	68	len_1 = s1->_length;
@@ -72,7 +72,7 @@ int vm_string_t::compare(const vm_string_t s1, const vm_string_t s2) · 3 unmodified lines
72	72
73	73	auto len_2 = word_t{ 0 };
74	74	auto scen_2 = ascii_idx;
75		− void *str_mem_2 = "";
	75	+ const void *str_mem_2 = "";
76	76	if (s2 != nullptr)
77	77	{
78	78	len_2 = s2->_length;
@@ -97,10 +97,10 @@ int vm_string_t::compare(const vm_string_t s1, const vm_string_t s2) · 18 unmodified lines
97	97	result = std::memcmp(str_mem_1, str_mem_2, min_length);
98	98	break;
99	99	case compare_case_t::ascii_rune:
100		− result = _compare(min_length, reinterpret_cast<char >(str_mem_1), reinterpret_cast<rune_t >(str_mem_2));
	100	+ result = _compare(min_length, reinterpret_cast<const char >(str_mem_1), reinterpret_cast<const runtime::rune_t >(str_mem_2));
101	101	break;
102	102	case compare_case_t::rune_ascii:
103		− result = _compare(min_length, reinterpret_cast<rune_t >(str_mem_1), reinterpret_cast<char >(str_mem_2));
	103	+ result = _compare(min_length, reinterpret_cast<const runtime::rune_t >(str_mem_1), reinterpret_cast<const char >(str_mem_2));
104	104	break;
105	105	}
106	106
@@ -128,10 +128,10 @@ namespace · 21 unmodified lines
128	128	}
129	129
130	130	template<>
131		− void copy_characters_to(rune_t dest, word_t dest_start, const rune_t source, word_t source_length)
	131	+ void copy_characters_to(runtime::rune_t dest, word_t dest_start, const runtime::rune_t source, word_t source_length)
132	132	{
133	133	assert(dest != nullptr && source != nullptr);
134		− std::memcpy((dest + dest_start), source, (source_length * sizeof(rune_t)));
	134	+ std::memcpy((dest + dest_start), source, (source_length * sizeof(runtime::rune_t)));
135	135	}
136	136
137	137	void combine(
@@ -146,14 +146,14 @@ namespace · 8 unmodified lines
146	146	{
147	147	if (dest_is_rune)
148	148	{
149		− auto dest_rune = reinterpret_cast<rune_t *>(dest);
	149	+ auto dest_rune = reinterpret_cast<runtime::rune_t *>(dest);
150	150	if (source1_is_rune)
151		− copy_characters_to(dest_rune, 0, reinterpret_cast<const rune_t *>(source1), source1_length);
	151	+ copy_characters_to(dest_rune, 0, reinterpret_cast<const runtime::rune_t *>(source1), source1_length);
152	152	else
153	153	copy_characters_to(dest_rune, 0, source1, source1_length);
154	154
155	155	if (source2_is_rune)
156		− copy_characters_to(dest_rune, source1_length, reinterpret_cast<const rune_t *>(source2), source2_length);
	156	+ copy_characters_to(dest_rune, source1_length, reinterpret_cast<const runtime::rune_t *>(source2), source2_length);
157	157	else
158	158	copy_characters_to(dest_rune, source1_length, source2, source2_length);
159	159	}
@@ -381,7 +381,7 @@ word_t vm_string_t::get_length() const · 221 unmodified lines
381	381	return _length;
382	382	}
383	383
384		−rune_t vm_string_t::get_rune(word_t index) const
	384	+runtime::rune_t vm_string_t::get_rune(word_t index) const
385	385	{
386	386	if (index < 0 && _length <= index)
387	387	throw index_out_of_range_memory{ 0, _length - 1, index };

src/vm/sys/Sysmod.cpp+3−3

@@ -293,7 +293,7 @@ Sys_byte2char(vm_registers_t &r, vm_t &vm) · 292 unmodified lines
293	293	fp.ret->t2 = 0;
294	294
295	295	auto state = utf8::decode_state_t::accept;
296		− auto result = rune_t{};
	296	+ auto result = runtime::rune_t{};
297	297	const auto buffer_len = buffer->get_length();
298	298	for (auto i = n; i < buffer_len; ++i)
299	299	{
@@ -326,7 +326,7 @@ Sys_char2byte(vm_registers_t &r, vm_t &vm) · 26 unmodified lines
326	326	if (buffer == nullptr \|\| n >= buffer->get_length())
327	327	throw out_of_range_memory{};
328	328
329		− const auto rune = static_cast<rune_t>(fp.c);
	329	+ const auto rune = static_cast<runtime::rune_t>(fp.c);
330	330
331	331	static_assert(Sys_UTFmax == sizeof(rune), "UTF max should be same size as rune");
332	332	uint8_t buffer_local[Sys_UTFmax];
@@ -689,7 +689,7 @@ Sys_stream(vm_registers_t &r, vm_t &vm) · 356 unmodified lines
689	689
690	690	namespace
691	691	{
692		− bool is_delim(const rune_t c, const vm_string_t &delim)
	692	+ bool is_delim(const runtime::rune_t c, const vm_string_t &delim)
693	693	{
694	694	const auto max = delim.get_length();
695	695	assert(max > 0);

src/vm/sys/sys_utils.h+1−1

@@ -8,7 +8,7 @@ · 7 unmodified lines
8	8	#define _DISVM_SRC_VM_SYS_SYS_UTILS_H_
9	9
10	10	#include <vector>
11		−#include <iosfwd>
	11	+#include <ios>
12	12	#include <memory>
13	13	#include <disvm.h>
14	14	#include <utils.h>

src/vm/thread.cpp+1−1

@@ -59,7 +59,7 @@ vm_registers_t::vm_registers_t( · 58 unmodified lines
59	59	, mp_base{ entry.mp_base }
60	60	, thread{ thread }
61	61	, pc{ entry.module->header.entry_pc }
62		− , stack{ entry.module->header.stack_extent }
	62	+ , stack{ static_cast<std::size_t>(entry.module->header.stack_extent) }
63	63	, tool_dispatch{ nullptr }
64	64	, src{ nullptr }
65	65	, mid{ nullptr }

src/vm/tool_dispatch.cpp+1−0

@@ -5,6 +5,7 @@ · 4 unmodified lines
5	5	//
6	6
7	7	#include <cassert>
	8	+#include <thread>
8	9	#include <vector>
9	10	#include <debug.h>
10	11	#include <disvm.h>

src/vm/vm.cpp+1−1

@@ -70,7 +70,7 @@ namespace · 69 unmodified lines
70	70	{
71	71	std::unique_ptr<runtime::vm_thread_t> _create_thread_safe(std::unique_ptr<runtime::vm_module_ref_t> &entry_module_ref)
72	72	{
73		− auto thread = std::make_unique<vm_thread_t>(*entry_module_ref, vm_t::root_vm_thread_id);
	73	+ auto thread = std::make_unique<vm_thread_t>(*entry_module_ref, disvm::vm_t::root_vm_thread_id);
74	74
75	75	// Now that the thread has been created and has inherited ownership of the pointer, relinquish the smart pointer's ownership.
76	76	entry_module_ref->release(); // decrement the vm alloc ref count

src/vm/vm_memory.cpp+15−14

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	7	#include <memory>
8	8	#include <atomic>
9	9	#include <bitset>
	10	+#include <cstdlib>
10	11	#include <mutex>
11	12	#include <limits>
12	13	#include <vector>
@@ -355,98 +356,98 @@ namespace · 342 unmodified lines
355	356	}
356	357
357	358	template<>
358		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<byte_t>()
	359	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<byte_t>()
359	360	{
360	361	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::byte, hidden_type_desc::deleter };
361	362	return t;
362	363	}
363	364
364	365	template<>
365		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<short_word_t>()
	366	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<short_word_t>()
366	367	{
367	368	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::short_word, hidden_type_desc::deleter };
368	369	return t;
369	370	}
370	371
371	372	template<>
372		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<word_t>()
	373	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<word_t>()
373	374	{
374	375	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::word, hidden_type_desc::deleter };
375	376	return t;
376	377	}
377	378
378	379	template<>
379		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<short_real_t>()
	380	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<short_real_t>()
380	381	{
381	382	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::short_real, hidden_type_desc::deleter };
382	383	return t;
383	384	}
384	385
385	386	template<>
386		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<real_t>()
	387	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<real_t>()
387	388	{
388	389	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::real, hidden_type_desc::deleter };
389	390	return t;
390	391	}
391	392
392	393	template<>
393		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<big_t>()
	394	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<big_t>()
394	395	{
395	396	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::big, hidden_type_desc::deleter };
396	397	return t;
397	398	}
398	399
399	400	template<>
400		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<pointer_t>()
	401	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<pointer_t>()
401	402	{
402	403	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::pointer, hidden_type_desc::deleter };
403	404	return t;
404	405	}
405	406
406	407	template<>
407		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_array_t>()
	408	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_array_t>()
408	409	{
409	410	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_array, hidden_type_desc::deleter };
410	411	return t;
411	412	}
412	413
413	414	template<>
414		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_list_t>()
	415	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_list_t>()
415	416	{
416	417	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_list, hidden_type_desc::deleter };
417	418	return t;
418	419	}
419	420
420	421	template<>
421		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_channel_t>()
	422	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_channel_t>()
422	423	{
423	424	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_channel, hidden_type_desc::deleter };
424	425	return t;
425	426	}
426	427
427	428	template<>
428		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_string_t>()
	429	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_string_t>()
429	430	{
430	431	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_string, hidden_type_desc::deleter };
431	432	return t;
432	433	}
433	434
434	435	template<>
435		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_module_ref_t>()
	436	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_module_ref_t>()
436	437	{
437	438	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_module_ref, hidden_type_desc::deleter };
438	439	return t;
439	440	}
440	441
441	442	template<>
442		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_stack_t>()
	443	+std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_stack_t>()
443	444	{
444	445	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_stack, hidden_type_desc::deleter };
445	446	return t;
446	447	}
447	448
448	449	template<>
449		−static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_thread_t>()
	450	+ std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_thread_t>()
450	451	{
451	452	static std::shared_ptr<const type_descriptor_t> t = { &hidden_type_desc::vm_thread, hidden_type_desc::deleter };
452	453	return t;