docs: Improve code snippets in release notes

docs/markdown/Release-notes-for-0.43.0.md

@@ -26,20 +26,22 @@ object can be used as a source file for other Targets, this will create a
 dependency on the original `CustomTarget`, but will only insert the generated
 file corresponding to the index value of the `CustomTarget`'s `output` keyword.
 
-    c = CustomTarget(
+```meson
-      ...
+c = custom_target(
-      output : ['out.h', 'out.c'],
+  ...
-    )
+  output : ['out.h', 'out.c'],
-    lib1 = static_library(
+)
-      'lib1',
+lib1 = static_library(
-      [lib1_sources, c[0]],
+  'lib1',
-      ...
+  [lib1_sources, c[0]],
-    )
+  ...
-    exec = executable(
+)
-      'executable',
+exec = executable(
-      c[1],
+  'executable',
-      link_with : lib1,
+  c[1],
-    )
+  link_with : lib1,
+)
+```
 
 # Can override executables in the cross file
 
@@ -47,39 +49,47 @@ The cross file can now be used for overriding the result of
 `find_program`. As an example if you want to find the `objdump`
 command and have the following definition in your cross file:
 
-    [binaries]
+```ini
-    ...
+[binaries]
-    objdump = '/usr/bin/arm-linux-gnueabihf-objdump-6'
+...
+objdump = '/usr/bin/arm-linux-gnueabihf-objdump-6'
+```
 
 Then issuing the command `find_program('objdump')` will return the
 version specified in the cross file. If you need the build machine's
 objdump, you can specify the `native` keyword like this:
 
-    native_objdump = find_program('objdump', native : true)
+```meson
+native_objdump = find_program('objdump', native : true)
+```
 
 # Easier handling of supported compiler arguments
 
 A common pattern for handling multiple desired compiler arguments, was to
 test their presence and add them to an array one-by-one, e.g.:
 
-    warning_flags_maybe = [
+```meson
-      '-Wsomething',
+warning_flags_maybe = [
-      '-Wanother-thing',
+  '-Wsomething',
-      '-Wno-the-other-thing',
+  '-Wanother-thing',
-    ]
+  '-Wno-the-other-thing',
-    warning_flags = []
+]
-    foreach flag : warning_flags_maybe
+warning_flags = []
-      if cc.has_argument(flag)
+foreach flag : warning_flags_maybe
-        warning_flags += flag
+  if cc.has_argument(flag)
-      endif
+    warning_flags += flag
-    endforeach
+  endif
-    cc.add_project_argument(warning_flags)
+endforeach
+cc.add_project_argument(warning_flags)
+```
 
 A helper has been added for the foreach/has_argument pattern, so you can
 now simply do:
 
-    warning_flags = [ ... ]
+```meson
-    flags = cc.get_supported_flags(warning_flags)
+warning_flags = [ ... ]
+flags = cc.get_supported_flags(warning_flags)
+```
 
 # Better support for shared libraries in non-system paths
 
@@ -93,12 +103,14 @@ This means that e.g. supporting prebuilt libraries shipped with your
 source or provided by subprojects or wrap definitions by writing a
 build file like this:
 
-    project('myprebuiltlibrary', 'c')
+```meson
-    
+project('myprebuiltlibrary', 'c')
-    cc = meson.get_compiler('c')
+
-    prebuilt = cc.find_library('mylib', dirs : meson.current_source_dir())
+cc = meson.get_compiler('c')
-    mydep = declare_dependency(include_directories : include_directories('.'),
+prebuilt = cc.find_library('mylib', dirs : meson.current_source_dir())
-                               dependencies : prebuilt)
+mydep = declare_dependency(include_directories : include_directories('.'),
+                           dependencies : prebuilt)
+```
 
 Then you can use the dependency object in the same way as any other.