lang/zig: correctly pass CXXFLAGS

and while here,
- set DPB_PROPERTIES=parallel (we are building llvm)
- rework on DESCR

lang/zig/Makefile

@@ -1,11 +1,15 @@
-# $OpenBSD: Makefile,v 1.2 2021/02/28 15:36:55 semarie Exp $
+# $OpenBSD: Makefile,v 1.3 2021/03/01 12:52:45 semarie Exp $
 
 # should be fine for ${LLVM_ARCHS}, but it needs insane amount of datasize
 ONLY_FOR_ARCHS =	amd64 arm64 powerpc64
 
+# build llvm as part of the port
+DPB_PROPERTIES =	parallel
+
 COMMENT =	zig compiler and toolchain
 
 DISTNAME =	zig-0.8.0pre1038
+REVISION =	0
 
 GH_ACCOUNT =	ziglang
 GH_PROJECT =	zig-bootstrap
@@ -33,11 +37,13 @@ SEPARATE_BUILD =	Yes
 
 CONFIGURE_STYLE =	none
 
+MAKE_ENV +=	CXXFLAGS="${CXXFLAGS}" \
+		MAKE_JOBS="${MAKE_JOBS}" \
+		WRKSRC="${WRKSRC}" \
+		WRKBUILD="${WRKBUILD}"
+
 # command to build/install/test
 BUILDCMD =	cd ${WRKBUILD} && exec ${SETENV} ${MAKE_ENV} \
-			WRKSRC="${WRKSRC}" \
-			WRKBUILD="${WRKBUILD}" \
-			MAKE_JOBS="${MAKE_JOBS}" \
 		    sh "${.CURDIR}/files/build.sh"
 
 pre-configure:

lang/zig/pkg/DESCR

@@ -1,35 +1,40 @@
 Zig is a general-purpose programming language and toolchain for
 maintaining robust, optimal, and reusable software.
 
+- Robust : behavior is correct even for edge cases such as out of
+  memory.
+- Optimal : write programs the best way they can behave and perform.
+- Reusable : the same code works in many environments which have
+  different constraints.
+- Maintainable : precisely communicate intent to the compiler and
+  other programmers. The language imposes a low overhead to reading
+  code and is resilient to changing requirements and environments.
+
+
 - Simple Language
 
 Focus on debugging your application rather than debugging your
 programming language knowledge.
 
-No hidden control flow.
-
-No hidden memory allocations.
-
-No preprocessor, no macros.
+  - No hidden control flow.
+  - No hidden memory allocations.
+  - No preprocessor, no macros.
 
 - Comptime
 
 A fresh approach to metaprogramming based on compile-time code
 execution and lazy evaluation.
 
-Call any function at compile-time.
-
-Manipulate types as values without runtime overhead.
-
-Comptime emulates the target architecture.
+  - Call any function at compile-time.
+  - Manipulate types as values without runtime overhead.
+  - Comptime emulates the target architecture.
 
 - Performance Meets Safety
 
 Write fast, clear code capable of handling all error conditions.
 
-The language gracefully guides your error handling logic.
-
-Configurable runtime checks help you strike a balance between
-performance and safety guarantees.
-
-Take advantage of vector types to express SIMD instructions portably.
+  - The language gracefully guides your error handling logic.
+  - Configurable runtime checks help you strike a balance between
+    performance and safety guarantees.
+  - Take advantage of vector types to express SIMD instructions
+    portably.