Index: head/Mk/Uses/compiler.mk
===================================================================
--- head/Mk/Uses/compiler.mk	(revision 468504)
+++ head/Mk/Uses/compiler.mk	(revision 468505)
@@ -1,272 +1,272 @@
 # $FreeBSD$
 #
 # Allows to determine the compiler being used
 #
 # Feature:	compiler
 # Usage:	USES=compiler or USES=compiler:ARGS
 # Valid ARGS:	env (default, implicit) c++0x c++11-lib c++11-lang c11 openmp nestedfct features
 #
 # c++0x:	The port needs a compiler understanding C++0X
 # c++11-lang:	The port needs a compiler understanding C++11
 # c++14-lang:	The port needs a compiler understanding C++14
 # gcc-c++11-lib:The port needs g++ compiler with a C++11 library
 # c++11-lib:	The port needs a compiler understanding C++11 and with a C++11 ready standard library
 # c11:		The port needs a compiler understanding C11
 # openmp:	The port needs a compiler understanding openmp
 # nestedfct:	The port needs a compiler understanding nested functions
 # features:	The port will determine the features supported by the default compiler
 #
 # Variable to test after <bsd.port.pre.mk>
 #
 # COMPILER_TYPE:	can be gcc or clang
 # ALT_COMPILER_TYPE:	can be gcc or clang depending on COMPILER_TYPE, only set if the base system has 2 compilers
 # COMPILER_VERSION:	first 2 digits of the version: 33 for clang 3.3.*, 47 for gcc 4.7.*
 # ALT_COMPILER_VERSION:	first 2 digits of the version: 33 for clang 3.3.*, 47 for gcc 4.7.* of the ALT_COMPILER_TYPE
 #
 # COMPILER_FEATURES:	the list of features supported by the compiler includes the standard C++ library.
 # CHOSEN_COMPILER_TYPE:	can be gcc or clang (type of compiler chosen by the framework)
 #
 # MAINTAINER: portmgr@FreeBSD.org
 
 .if !defined(_INCLUDE_USES_COMPILER_MK)
 _INCLUDE_USES_COMPILER_MK=	yes
 
 .if empty(compiler_ARGS)
 compiler_ARGS=	env
 .endif
 
 VALID_ARGS=	c++11-lib c++11-lang c++14-lang c11 features openmp env nestedfct c++0x gcc-c++11-lib
 
 _CC_hash:=	${CC:hash}
 _CXX_hash:=	${CXX:hash}
 
 .if ${compiler_ARGS} == gcc-c++11-lib
 _COMPILER_ARGS+=	features gcc-c++11-lib
 .elif ${compiler_ARGS} == c++11-lib
 _COMPILER_ARGS+=	features c++11-lib
 .elif ${compiler_ARGS} == c++0x
 _COMPILER_ARGS+=	features c++0x
 .elif ${compiler_ARGS} == c++11-lang
 _COMPILER_ARGS+=	features c++11-lang
 .elif ${compiler_ARGS} == c++14-lang
 _COMPILER_ARGS+=	features c++14-lang
 .elif ${compiler_ARGS} == c11
 _COMPILER_ARGS+=	features c11
 .elif ${compiler_ARGS} == features
 _COMPILER_ARGS+=	features
 .elif ${compiler_ARGS} == env
 _COMPILER_ARGS+=	env
 .elif ${compiler_ARGS} == openmp
 _COMPILER_ARGS+=	env openmp
 .elif ${compiler_ARGS} == nestedfct
 _COMPILER_ARGS+=	env nestedfct
 .else
 IGNORE=	Invalid argument "${compiler_ARGS}", valid arguments are: ${VALID_ARGS}
 _COMPILER_ARGS=	#
 .endif
 
 .if ${_COMPILER_ARGS:Mc++*} || ${_COMPILER_ARGS:Mc11}
 _COMPILER_ARGS+=	features
 .endif
 
 .if defined(_CCVERSION_${_CC_hash})
 _CCVERSION=	${_CCVERSION_${_CC_hash}}
 .else
 _CCVERSION!=	${CC} --version
 _CCVERSION_${_CC_hash}=	${_CCVERSION}
 PORTS_ENV_VARS+=	_CCVERSION_${_CC_hash}
 .endif
 COMPILER_VERSION=	${_CCVERSION:M[0-9].[0-9]*:tW:C/([0-9]).([0-9]).*/\1\2/g}
 .if ${_CCVERSION:Mclang}
 COMPILER_TYPE=	clang
 .else
 COMPILER_TYPE=	gcc
 .endif
 
 ALT_COMPILER_VERSION=	0
 ALT_COMPILER_TYPE=	none
 _ALTCCVERSION=		none
 .if defined(_ALTCCVERSION_${_CC_hash})
 _ALTCCVERSION=	${_ALTCCVERSION_${_CC_hash}}
 .else
 .if ${COMPILER_TYPE} == gcc && exists(/usr/bin/clang)
 .if ${ARCH} == amd64 || ${ARCH} == i386 # clang often non-default for a reason
 _ALTCCVERSION!=	/usr/bin/clang --version
 .endif
 .elif ${COMPILER_TYPE} == clang && exists(/usr/bin/gcc)
 _ALTCCVERSION!=	/usr/bin/gcc --version
 .endif
 _ALTCCVERSION_${_CC_hash}=	${_ALTCCVERSION}
 PORTS_ENV_VARS+=		_ALTCCVERSION_${_CC_hash}
 .endif
 
 ALT_COMPILER_VERSION=	${_ALTCCVERSION:M[0-9].[0-9]*:tW:C/([0-9]).([0-9]).*/\1\2/g}
 .if ${_ALTCCVERSION:Mclang}
 ALT_COMPILER_TYPE=	clang
 .elif ${_ALTCCVERSION} != none
 ALT_COMPILER_TYPE=	gcc
 .endif
 
 CHOSEN_COMPILER_TYPE=	${COMPILER_TYPE}
 
 .if ${_COMPILER_ARGS:Mopenmp}
 .if ${COMPILER_TYPE} == clang
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mnestedfct}
 .if ${COMPILER_TYPE} == clang
 USE_GCC=	any
 CHOSEN_COMPILER_TYPE=	gcc
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mfeatures}
 .if defined(_CXXINTERNAL_${_CXX_hash})
 _CXXINTERNAL=	${_CXXINTERNAL_${_CXX_hash}}
 .else
 _CXXINTERNAL!=	${CXX} -\#\#\# /dev/null 2>&1
 _CXXINTERNAL_${_CXX_hash}=	${_CXXINTERNAL}
 PORTS_ENV_VARS+=	_CXXINTERNAL_${_CXX_hash}
 .endif
 .if ${_CXXINTERNAL:M\"-lc++\"}
 COMPILER_FEATURES=	libc++
 .else
 COMPILER_FEATURES=	libstdc++
 .endif
 
 CSTD=	c89 c99 c11 gnu89 gnu99 gnu11
 CXXSTD=	c++98 c++0x c++11 c++14 gnu++98 gnu++11
 
 .for std in ${CSTD} ${CXXSTD}
 _LANG=c
 .if ${CXXSTD:M${std}}
 _LANG=c++
 .endif
 .if defined(CC_OUTPUT_${_CC_hash}_${std:hash})
 OUTPUT_${std}=	${CC_OUTPUT_${_CC_hash}_${std:hash}}
 .else
 OUTPUT_${std}!=	if ${CC} -std=${std} -c -x ${_LANG} /dev/null -o /dev/null 2>&1; then echo yes; fi; echo
 CC_OUTPUT_${_CC_hash}_${std:hash}=	${OUTPUT_${std}}
 PORTS_ENV_VARS+=			CC_OUTPUT_${_CC_hash}_${std:hash}
 .endif
 .if !${OUTPUT_${std}:M*error*}
 COMPILER_FEATURES+=	${std}
 .endif
 .endfor
 .endif
 
 .if ${_COMPILER_ARGS:Mc++11-lib}
 .if !${COMPILER_FEATURES:Mc++11}
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .elif ${COMPILER_TYPE} == clang && ${COMPILER_FEATURES:Mlibstdc++}
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mc++14-lang}
 .if !${COMPILER_FEATURES:Mc++14}
 .if (defined(FAVORITE_COMPILER) && ${FAVORITE_COMPILER} == gcc) || (${ARCH} != amd64 && ${ARCH} != i386) # clang not always supported on Tier-2
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .elif (${COMPILER_TYPE} == clang && ${COMPILER_VERSION} < 35) || ${COMPILER_TYPE} == gcc
 .if ${ALT_COMPILER_TYPE} == clang && ${ALT_COMPILER_VERSION} >= 35
 CPP=	clang-cpp
 CC=	clang
 CXX=	clang++
 CHOSEN_COMPILER_TYPE=	clang
 .else
-BUILD_DEPENDS+=	${LOCALBASE}/bin/clang50:devel/llvm50
-CPP=	${LOCALBASE}/bin/clang-cpp50
-CC=	${LOCALBASE}/bin/clang50
-CXX=	${LOCALBASE}/bin/clang++50
+BUILD_DEPENDS+=	${LOCALBASE}/bin/clang60:devel/llvm60
+CPP=	${LOCALBASE}/bin/clang-cpp60
+CC=	${LOCALBASE}/bin/clang60
+CXX=	${LOCALBASE}/bin/clang++60
 CHOSEN_COMPILER_TYPE=	clang
 .endif
 .endif
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mc++11-lang}
 .if !${COMPILER_FEATURES:Mc++11}
 .if (defined(FAVORITE_COMPILER) && ${FAVORITE_COMPILER} == gcc) || (${ARCH} != amd64 && ${ARCH} != i386) # clang not always supported on Tier-2
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .elif ${COMPILER_TYPE} == gcc
 .if ${ALT_COMPILER_TYPE} == clang
 CPP=	clang-cpp
 CC=	clang
 CXX=	clang++
 CHOSEN_COMPILER_TYPE=	clang
 .else
-BUILD_DEPENDS+=	${LOCALBASE}/bin/clang50:devel/llvm50
-CPP=	${LOCALBASE}/bin/clang-cpp50
-CC=	${LOCALBASE}/bin/clang50
-CXX=	${LOCALBASE}/bin/clang++50
+BUILD_DEPENDS+=	${LOCALBASE}/bin/clang60:devel/llvm60
+CPP=	${LOCALBASE}/bin/clang-cpp60
+CC=	${LOCALBASE}/bin/clang60
+CXX=	${LOCALBASE}/bin/clang++60
 CHOSEN_COMPILER_TYPE=	clang
 .endif
 .endif
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mc++0x}
 .if !${COMPILER_FEATURES:Mc++0x}
 .if (defined(FAVORITE_COMPILER) && ${FAVORITE_COMPILER} == gcc) || (${ARCH} != amd64 && ${ARCH} != i386) # clang not always supported on Tier-2
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .elif ${COMPILER_TYPE} == gcc
 .if ${ALT_COMPILER_TYPE} == clang
 CPP=	clang-cpp
 CC=	clang
 CXX=	clang++
 CHOSEN_COMPILER_TYPE=	clang
 .else
-BUILD_DEPENDS+=	${LOCALBASE}/bin/clang50:devel/llvm50
+BUILD_DEPENDS+=	${LOCALBASE}/bin/clang60:devel/llvm60
 CHOSEN_COMPILER_TYPE=	clang
-CPP=	${LOCALBASE}/bin/clang-cpp50
-CC=	${LOCALBASE}/bin/clang50
-CXX=	${LOCALBASE}/bin/clang++50
+CPP=	${LOCALBASE}/bin/clang-cpp60
+CC=	${LOCALBASE}/bin/clang60
+CXX=	${LOCALBASE}/bin/clang++60
 .endif
 .endif
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mc11}
 .if !${COMPILER_FEATURES:Mc11}
 .if (defined(FAVORITE_COMPILER) && ${FAVORITE_COMPILER} == gcc) || (${ARCH} != amd64 && ${ARCH} != i386) # clang not always supported on Tier-2
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .elif ${COMPILER_TYPE} == gcc
 .if ${ALT_COMPILER_TYPE} == clang
 CPP=	clang-cpp
 CC=	clang
 CXX=	clang++
 CHOSEN_COMPILER_TYPE=	clang
 .else
-BUILD_DEPENDS+=	${LOCALBASE}/bin/clang50:devel/llvm50
+BUILD_DEPENDS+=	${LOCALBASE}/bin/clang60:devel/llvm60
 CHOSEN_COMPILER_TYPE=	clang
-CPP=	${LOCALBASE}/bin/clang-cpp50
-CC=	${LOCALBASE}/bin/clang50
-CXX=	${LOCALBASE}/bin/clang++50
+CPP=	${LOCALBASE}/bin/clang-cpp60
+CC=	${LOCALBASE}/bin/clang60
+CXX=	${LOCALBASE}/bin/clang++60
 .endif
 .endif
 .endif
 .endif
 
 .if ${_COMPILER_ARGS:Mgcc-c++11-lib}
 USE_GCC=	yes
 CHOSEN_COMPILER_TYPE=	gcc
 .if ${COMPILER_FEATURES:Mlibc++}
 CXXFLAGS+=	-nostdinc++ -isystem /usr/include/c++/v1
 LDFLAGS+=	-L${WRKDIR}
 
 _USES_configure+=	200:gcc-libc++-configure
 gcc-libc++-configure:
 	@${LN} -fs /usr/lib/libc++.so ${WRKDIR}/libstdc++.so
 .endif
 .endif
 
 .endif
Index: head/devel/godot/Makefile
===================================================================
--- head/devel/godot/Makefile	(revision 468504)
+++ head/devel/godot/Makefile	(revision 468505)
@@ -1,114 +1,114 @@
 # Created by: Shane Ambler <FreeBSD@Shaneware.biz>
 # $FreeBSD$
 
 PORTNAME=	godot
 PORTVERSION=	3.0.2
 DISTVERSIONSUFFIX= -stable
 CATEGORIES=	devel games
 
 MAINTAINER=	FreeBSD@Shaneware.biz
 COMMENT?=	Game runtime engine
 
 LICENSE=		MIT CC-BY-3.0
 LICENSE_COMB=		multi
 LICENSE_FILE_CC-BY-3.0=	${WRKSRC}/LOGO_LICENSE.md
 LICENSE_FILE_MIT=	${WRKSRC}/LICENSE.txt
 
 BUILD_DEPENDS=	yasm:devel/yasm
 LIB_DEPENDS=	libfreetype.so:print/freetype2 \
 		libpng.so:graphics/png
 RUN_DEPENDS=	xdg-user-dir:devel/xdg-user-dirs \
 		xdg-open:devel/xdg-utils \
 		xmessage:x11/xmessage
 
 USE_GITHUB=	yes
 GH_ACCOUNT=	godotengine
 
-# on 10.4 using clang34 fails - so we want to use clang50
-# gl already needs clang50 so this shouldn't add any overhead
+# on 10.4 using clang34 fails - so we want to use clang60
+# gl already needs clang60 so this shouldn't add any overhead
 USES=		compiler:c++14-lang pkgconfig scons ssl
 USE_XORG=	x11 xcursor xi xinerama xrandr
 USE_GL=		gl glew glu
 
 MAKE_ARGS+=		platform=x11 builtin_libpng=False builtin_openssl=False
 MAKE_ARGS+=		${MAKE_ARGS_${CHOSEN_COMPILER_TYPE}}
 MAKE_ARGS_clang=	use_llvm=True
 CXXFLAGS+=		-DRTAUDIO_ENABLED
 CXXFLAGS_i386=		${CXXFLAGS_i386_${CHOSEN_COMPILER_TYPE}}
 CXXFLAGS_i386_gcc=	-march=i586
 CXXFLAGS_aarch64=	-DNO_THREADS
 CXXFLAGS_sparc64=	-DNO_THREADS
 CXXFLAGS_mips=		-DNO_THREADS
 CXXFLAGS_mips64=	-DNO_THREADS
 
 # option MONO can be built but is not stable enough to use yet
 # for now leave it out as an option
 OPTIONS_DEFINE=		EXAMPLES TOOLS
 OPTIONS_DEFAULT=	OSS
 # Moved to devel/godot-tools
 OPTIONS_EXCLUDE?=	EXAMPLES TOOLS
 OPTIONS_GROUP=		AUDIO
 OPTIONS_GROUP_AUDIO=	ALSA OSS PULSEAUDIO
 
 AUDIO_DESC=		Audio support
 ALSA_LIB_DEPENDS=	libasound.so:audio/alsa-lib
 ALSA_MAKE_ARGS=		alsa=True
 EXAMPLES_GH_PROJECT=	godot-demo-projects:DEMOS
 # master at 31/1
 EXAMPLES_GH_TAGNAME=	d69cc10a0b8a:DEMOS
 EXAMPLES_PORTEXAMPLES=	*
 # while mono support can build it isn't stable enough to be used yet
 MONO_LIB_DEPENDS=	libmonosgen-2.0.so:lang/mono
 MONO_MAKE_ARGS=		module_mono_enabled=True
 OSS_MAKE_ARGS=		oss=True
 PULSEAUDIO_LIB_DEPENDS=	libpulse-simple.so:audio/pulseaudio
 PULSEAUDIO_MAKE_ARGS=	pulseaudio=True
 TOOLS_DESC=		Include development tools (IDE)
 TOOLS_MAKE_ARGS=	target=release_debug tools=True
 TOOLS_MAKE_ARGS_OFF=	target=release tools=False
 TOOLS_DESKTOP_ENTRIES=	"Godot" "${COMMENT}" "${GODOTFILE}" \
 			"${GODOTFILE}" "Development;IDE;" ""
 TOOLS_PLIST_FILES=	share/pixmaps/${GODOTFILE}.png \
 			share/pixmaps/${GODOTFILE}.svg
 
 GODOTFILE=		${PORTNAME}${PKGNAMESUFFIX}
 PLIST_FILES=		bin/${GODOTFILE}
 
 .ifmake makesum
 # Always include optional distfiles
 .MAKEFLAGS:	WITH="${OPTIONS_DEFINE}" OPTIONS_EXCLUDE=
 .endif
 
 post-patch:
 	@${REINPLACE_CMD} -e 's|custom_build|${OPSYS}_Ports_build|' \
 		${WRKSRC}/methods.py
 	@${REINPLACE_CMD} -e 's|/usr/bin|${PREFIX}/bin|' \
 		${WRKSRC}/platform/x11/os_x11.cpp
 
 pre-build-MONO-on:
 	@(cd ${WRKSRC} && ${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_FLAGS} \
 		${_MAKE_JOBS} ${MAKE_ARGS:C,^${DESTDIRNAME}=.*,,g} \
 		target=release_debug tools=True mono_glue=False)
 	@(cd ${WRKSRC} && ${FIND} ${WRKSRC}/bin -name 'godot*' -exec {} \
 		--generate-mono-glue modules/mono/glue \; && \
 		${FIND} ${WRKSRC}/bin -name 'godot*' -delete)
 
 # The official godot binary name reflects options used to compile
 # We just want a simple name matching the portname
 # This gives us bin/godot for runtime and bin/godot-tools for the IDE
 do-install:
 	@${RM} ${WRKSRC}/bin/*.debugsymbols
 	cd ${WRKSRC}/bin && ${INSTALL_PROGRAM} godot.x11* \
 		${STAGEDIR}/${PREFIX}/bin/${GODOTFILE}
 
 do-install-EXAMPLES-on:
 	(cd ${WRKSRC_DEMOS} && ${COPYTREE_SHARE} "${PORTEXAMPLES}" \
 		${STAGEDIR}${EXAMPLESDIR})
 
 do-install-TOOLS-on:
 	${INSTALL_DATA} ${WRKSRC}/icon.png \
 		${STAGEDIR}${PREFIX}/share/pixmaps/${GODOTFILE}.png
 	${INSTALL_DATA} ${WRKSRC}/icon.svg \
 		${STAGEDIR}${PREFIX}/share/pixmaps/${GODOTFILE}.svg
 
 .include <bsd.port.mk>