druntime: replaces top level version(..) branching by tags

druntime/Makefile

@@ -135,14 +135,47 @@ DRUNTIMESOLIB=$(DRUNTIMESO)$(DOTLIB)
 
 STDDOC=
 
+###############
+
+TAGGED_COPY_LIST_FILE:=mak/TAGGED_COPY
+TAGGED_SRCS_FILE:=$(ROOT)/GEN_SRCS
+TAGGED_COPY_FILE:=$(ROOT)/GEN_COPY
+
+ifeq (windows,$(OS))
+	# Tags order doesn't matter
+	TAGS:=windows
+else
+	TAGS:=$(OS),posix_threads
+endif
+
+TGEN_CMD:=./parse_tagged_hier.sh $(TAGGED_SRCS_FILE) $(TAGGED_COPY_LIST_FILE) $(TAGGED_COPY_FILE) $(IMPDIR) $(TAGS) config > /dev/null
+
+TAGGED_SRCS:=$(shell $(TGEN_CMD) && cat $(TAGGED_SRCS_FILE))
+
+# MacOS doesn't support .SHELLSTATUS
+ifneq ($(.SHELLSTATUS),)
+	ifneq ($(.SHELLSTATUS),0)
+	  $(error Tagged sources list generation failed)
+	endif
+endif
+
+TAGGED_COPY:=$(shell $(TGEN_CMD) && cat $(TAGGED_COPY_FILE))
+ifneq ($(.SHELLSTATUS),)
+	ifneq ($(.SHELLSTATUS),0)
+	  $(error Tagged copy list generation failed)
+	endif
+endif
+
+###############
+
 include mak/COPY
-COPY:=$(subst \,/,$(COPY))
+COPY:=$(subst \,/,$(COPY)) $(subst \,/,$(TAGGED_COPY))
 
 include mak/DOCS
 DOCS:=$(subst \,/,$(DOCS))
 
 include mak/SRCS
-SRCS:=$(subst \,/,$(SRCS))
+SRCS:=$(subst \,/,$(SRCS)) $(subst \,/,$(TAGGED_SRCS))
 
 # NOTE: trace.d and cover.d are not necessary for a successful build
 #       as both are used for debugging features (profiling and coverage)
@@ -353,6 +386,13 @@ import: copy
 
 copy: $(COPY)
 
+strip_first_dirs:=cut -d '/' -f4-
+IMP_PATH=$(IMPDIR)/$(shell echo $@ | $(strip_first_dirs))
+
+$(IMPDIR)/config/%.d : config/%.d
+	@mkdir -p $(dir $(IMP_PATH))
+	@cp $< $(IMP_PATH)
+
 $(IMPDIR)/%.di : src/%.di
 	@mkdir -p $(dir $@)
 	@cp $< $@
@@ -403,6 +443,11 @@ $(ROOT)/valgrind$(DOTOBJ) : src/etc/valgrind/valgrind.c src/etc/valgrind/valgrin
 	@mkdir -p `dirname $@`
 	$(CC) -c $(CFLAGS) $< -o$@
 
+################################################
+
+gen_tagged_srcs_clean:
+	rm -f $(TAGGED_SRCS_FILE) $(TAGGED_SRCS_FILE).disabled $(TAGGED_COPY_FILE)
+
 ######################## Create a shared library ##############################
 
 $(DRUNTIMESO) $(DRUNTIMESOLIB) dll: DFLAGS+=-version=Shared $(SHAREDFLAGS)
@@ -562,7 +607,7 @@ install: target
 	cp -r import/* '$(INSTALL_DIR)'/src/druntime/import/
 endif
 
-clean: $(addsuffix /.clean,$(ADDITIONAL_TESTS))
+clean: $(addsuffix /.clean,$(ADDITIONAL_TESTS)) gen_tagged_srcs_clean
 	rm -rf $(ROOT_OF_THEM_ALL) $(IMPDIR) $(DOC_OUTPUT_DIR) druntime.zip
 
 test/%/.clean: test/%/Makefile

druntime/config/posix_threads/core/sync/event_impl.d

@@ -0,0 +1,115 @@
+module core.sync.event_impl;
+
+import core.internal.abort : abort;
+import core.sys.posix.pthread;
+import core.sys.posix.sys.types;
+import core.sys.posix.time;
+import core.time;
+
+package:
+
+nothrow @nogc:
+
+struct EventHandler
+{
+    pthread_mutex_t m_mutex;
+    pthread_cond_t m_cond;
+    bool initalized;
+    bool m_state;
+    bool m_manualReset;
+}
+
+EventHandler create(bool manualReset, bool initialState)
+{
+    EventHandler h;
+
+    pthread_mutex_init(cast(pthread_mutex_t*) &(h.m_mutex), null) == 0 ||
+        abort("Error: pthread_mutex_init failed.");
+
+    static if ( is( typeof( pthread_condattr_setclock ) ) )
+    {
+        pthread_condattr_t attr = void;
+        pthread_condattr_init(&attr) == 0 ||
+            abort("Error: pthread_condattr_init failed.");
+        pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0 ||
+            abort("Error: pthread_condattr_setclock failed.");
+        pthread_cond_init(&(h.m_cond), &attr) == 0 ||
+            abort("Error: pthread_cond_init failed.");
+        pthread_condattr_destroy(&attr) == 0 ||
+            abort("Error: pthread_condattr_destroy failed.");
+    }
+    else
+    {
+        pthread_cond_init(&(h.m_cond), null) == 0 ||
+            abort("Error: pthread_cond_init failed.");
+    }
+
+    h.m_state = initialState;
+    h.m_manualReset = manualReset;
+    h.initalized = true;
+
+    return h;
+}
+
+void destroy(ref EventHandler h)
+{
+    pthread_mutex_destroy(&(h.m_mutex)) == 0 ||
+        abort("Error: pthread_mutex_destroy failed.");
+
+    pthread_cond_destroy(&(h.m_cond)) == 0 ||
+        abort("Error: pthread_cond_destroy failed.");
+
+    h.initalized = false;
+}
+
+void set(ref EventHandler h)
+{
+    h.mutexLock;
+    h.m_state = true;
+    pthread_cond_broadcast(&(h.m_cond));
+    h.mutexUnlock;
+}
+
+void reset(ref EventHandler h)
+{
+    h.mutexLock;
+    h.m_state = false;
+    h.mutexUnlock;
+}
+
+bool wait(ref EventHandler h)
+{
+    return h.wait(Duration.max);
+}
+
+bool wait(ref EventHandler h, Duration tmout)
+{
+    h.mutexLock;
+
+    int result = 0;
+    if (!h.m_state)
+    {
+        if (tmout == Duration.max)
+        {
+            result = pthread_cond_wait(&(h.m_cond), &(h.m_mutex));
+        }
+        else
+        {
+            import core.sync.config;
+
+            timespec t = void;
+            mktspec(t, tmout);
+
+            result = pthread_cond_timedwait(&(h.m_cond), &(h.m_mutex), &t);
+        }
+    }
+    if (result == 0 && !h.m_manualReset)
+        h.m_state = false;
+
+    h.mutexUnlock;
+
+    return result == 0;
+}
+
+private void mutexLock(ref EventHandler h) { pthread_mutex_lock(&(h.m_mutex)); }
+private void mutexUnlock(ref EventHandler h) { pthread_mutex_unlock(&(h.m_mutex)); }

druntime/config/windows/core/sync/event_impl.d

@@ -0,0 +1,60 @@
+module core.sync.event_impl;
+
+import core.internal.abort : abort;
+import core.sys.windows.basetsd /+: HANDLE +/;
+import core.sys.windows.winerror /+: WAIT_TIMEOUT +/;
+import core.sys.windows.winbase /+: CreateEvent, CloseHandle, SetEvent, ResetEvent,
+    WaitForSingleObject, INFINITE, WAIT_OBJECT_0+/;
+import core.time;
+
+package:
+
+nothrow @nogc:
+
+alias EventHandler = HANDLE;
+
+bool initalized(in EventHandler h) { return h !is null; }
+
+EventHandler create(bool manualReset, bool initialState)
+{
+    HANDLE m_event = CreateEvent(null, manualReset, initialState, null);
+    m_event || abort("Error: CreateEvent failed.");
+
+    return m_event;
+}
+
+void destroy(ref EventHandler m_event)
+{
+    CloseHandle(m_event);
+    m_event = null;
+}
+
+void set(EventHandler m_event)
+{
+    SetEvent(m_event);
+}
+
+void reset(EventHandler m_event)
+{
+    ResetEvent(m_event);
+}
+
+bool wait(EventHandler m_event)
+{
+    return m_event && WaitForSingleObject(m_event, INFINITE) == WAIT_OBJECT_0;
+}
+
+bool wait(EventHandler m_event, Duration tmout)
+{
+    auto maxWaitMillis = dur!("msecs")(uint.max - 1);
+
+    while (tmout > maxWaitMillis)
+    {
+        auto res = WaitForSingleObject(m_event, uint.max - 1);
+        if (res != WAIT_TIMEOUT)
+            return res == WAIT_OBJECT_0;
+        tmout -= maxWaitMillis;
+    }
+    auto ms = cast(uint)(tmout.total!"msecs");
+    return WaitForSingleObject(m_event, ms) == WAIT_OBJECT_0;
+}

druntime/mak/TAGGED_COPY

@@ -0,0 +1 @@
+core\sync\event_impl.d

druntime/parse_tagged_hier.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+DST_FILE=$1
+SRC_COPY_FILE=$2
+DST_COPY_FILE=$3
+IMPDIR=$4
+TAGS=$5
+SRC_DIR=$6
+
+if [[ ! -d ${SRC_DIR} ]]; then
+    echo "Tags dir '${SRC_DIR}' not found" >&2
+    exit 1
+fi
+
+if [[ -f ${DST_FILE} ]]; then
+    echo "Tagged sources list already generated"
+    exit 0
+fi
+
+TAGS_LIST=($(echo "$TAGS" | tr "," "\n"))
+
+echo -e "\nTags will be applied: $TAGS"
+
+APPLIED=""
+
+function applyTaggedFiles {
+    TAG=$1
+    SRC_TAG_DIR=${SRC_DIR}/${TAG}
+
+    if [[ ! -d ${SRC_TAG_DIR} ]]; then
+        echo "Warning: tag '${TAG}' doesn't corresponds to any subdirectory inside of '${SRC_DIR}', skip" >&2
+    else
+        SRC_FILES_LIST+=($(find ${SRC_TAG_DIR} -type f ))
+
+        pushd ${SRC_TAG_DIR} > /dev/null
+        MAYBE_COPY_LIST+=($(find * -type f ))
+        popd > /dev/null
+    fi
+
+    APPLIED+=" $TAG"
+
+    echo "Currently applied tags:$APPLIED"
+}
+
+for tag in "${TAGS_LIST[@]}"
+do
+    applyTaggedFiles ${tag}
+done
+
+LINES_TO_COPY=$(grep -v '^$' ${SRC_COPY_FILE} | sort | uniq | wc -l)
+COPIED=0
+
+mkdir -p $(dirname ${DST_FILE})
+mkdir -p $(dirname ${DST_COPY_FILE})
+echo -ne > ${DST_FILE}
+echo -ne > ${DST_COPY_FILE}
+
+for i in "${!SRC_FILES_LIST[@]}"
+do
+    echo ${SRC_FILES_LIST[$i]} >> ${DST_FILE}
+
+    maybe_copy=$(echo ${MAYBE_COPY_LIST[$i]} | tr '/' '\\')
+
+    # Adds copy entry if file mentioned in the list
+    grep -F "$maybe_copy" ${SRC_COPY_FILE} > /dev/null && {
+        echo ${IMPDIR}'/'${SRC_FILES_LIST[$i]} >> ${DST_COPY_FILE}
+        COPIED=$((COPIED+1))
+    }
+done
+
+if [ $COPIED -ne $LINES_TO_COPY ]; then
+    echo "File '$SRC_COPY_FILE' contains $LINES_TO_COPY meaningful line(s), but to '$DST_COPY_FILE' added $COPIED line(s)" >&2
+
+    mv ${DST_FILE} "$DST_FILE.disabled"
+    echo "File '$DST_FILE' to '$DST_FILE.disabled' to avoid considering that tags parsing process was sucessfully done" >&2
+    exit 1
+fi
+
+echo "All tags applied"