File 0002-memory-auto.m4-Replace-as_echo-with-AS_ECH... of Package tme

Overview Repositories Revisions Requests Users Attributes Meta

File 0002-memory-auto.m4-Replace-as_echo-with-AS_ECHO.patch of Package tme

From 2d48eba823b38d0d1f5a4bd7f92cf4998850f7f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Klaus=20K=C3=A4mpf?= <kkaempf@gmail.com>
Date: Thu, 3 Oct 2024 14:38:49 +0200
Subject: [PATCH 02/12] memory-auto.m4: Replace $as_echo with AS_ECHO[]
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Klaus Kämpf <kkaempf@gmail.com>
---
 libtme/memory-auto.m4 | 1204 ++++++++++++++++++++---------------------
 1 file changed, 602 insertions(+), 602 deletions(-)

diff --git a/libtme/memory-auto.m4 b/libtme/memory-auto.m4
index ff10bc0..e6799ad 100644
--- a/libtme/memory-auto.m4
+++ b/libtme/memory-auto.m4
@@ -153,8 +153,8 @@ for size in ${sizes}; do
     if test ${size} = 8; then continue; fi
 
     if test `expr ${size} \>= ${size_ifdef}` = 1; then
-	$as_echo ""
-	$as_echo "#ifdef TME_HAVE_INT${size}_T"
+	AS_ECHO([""])
+	AS_ECHO(["#ifdef TME_HAVE_INT${size}_T"])
     fi
 
     # emit the bus read and write slow functions:
@@ -180,25 +180,25 @@ for size in ${sizes}; do
 	# if we're making the header, just emit a prototype:
 	#
 	if $header; then
-	    $as_echo ""
-	    $as_echo "/* the bus ${size}-bit ${op} slow function: */"
-	    $as_echo "${op_return_type} tme_memory_bus_${op}${size} _TME_P((${op_const}tme_shared tme_uint${size}_t *${op_proto_operand}, tme_rwlock_t *, unsigned int, unsigned int));"
+	    AS_ECHO([""])
+	    AS_ECHO(["/* the bus ${size}-bit ${op} slow function: */"])
+	    AS_ECHO(["${op_return_type} tme_memory_bus_${op}${size} _TME_P((${op_const}tme_shared tme_uint${size}_t *${op_proto_operand}, tme_rwlock_t *, unsigned int, unsigned int));"])
 	    continue
 	fi
 
-	$as_echo ""
-	$as_echo "/* undefine the macro version of tme_memory_bus_${op}${size}: */"
-	$as_echo "#undef tme_memory_bus_${op}${size}"
-	$as_echo ""
-	$as_echo "/* the bus ${size}-bit ${op} slow function: */"
-	$as_echo ${op_return_type}
-	$as_echo "tme_memory_bus_${op}${size}(${op_const}tme_shared tme_uint${size}_t *mem${op_operand}, tme_rwlock_t *rwlock, unsigned int align_min, unsigned int bus_boundary)"
-	$as_echo "{"
-	$as_echo "  const unsigned int host_boundary = TME_MEMORY_BUS_BOUNDARY;"
-	$as_echo "  unsigned int size_skip;"
-	$as_echo "  unsigned int size_done;"
+	AS_ECHO([""])
+	AS_ECHO(["/* undefine the macro version of tme_memory_bus_${op}${size}: */"])
+	AS_ECHO(["#undef tme_memory_bus_${op}${size}"])
+	AS_ECHO([""])
+	AS_ECHO(["/* the bus ${size}-bit ${op} slow function: */"])
+	AS_ECHO([${op_return_type}])
+	AS_ECHO(["tme_memory_bus_${op}${size}(${op_const}tme_shared tme_uint${size}_t *mem${op_operand}, tme_rwlock_t *rwlock, unsigned int align_min, unsigned int bus_boundary)"])
+	AS_ECHO(["{"])
+	AS_ECHO(["  const unsigned int host_boundary = TME_MEMORY_BUS_BOUNDARY;"])
+	AS_ECHO(["  unsigned int size_skip;"])
+	AS_ECHO(["  unsigned int size_done;"])
 	if test ${op} = read; then
-	    $as_echo "  tme_uint${size}_t x;"
+	    AS_ECHO(["  tme_uint${size}_t x;"])
 	fi
 
 	# emit the locals for the possible host boundaries:
@@ -206,20 +206,20 @@ for size in ${sizes}; do
 	host_boundary=${host_boundary_largest}
 	while test ${host_boundary} != 4; do
 	    if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-		$as_echo "#ifdef TME_HAVE_INT${host_boundary}_T"
+		AS_ECHO(["#ifdef TME_HAVE_INT${host_boundary}_T"])
 	    fi
-	    $as_echo "  ${op_const}tme_shared tme_uint${host_boundary}_t *parts${host_boundary};"
-	    $as_echo "  tme_uint${host_boundary}_t part${host_boundary};"
+	    AS_ECHO(["  ${op_const}tme_shared tme_uint${host_boundary}_t *parts${host_boundary};"])
+	    AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary};"])
 	    if test ${op} = write; then
-		$as_echo "  tme_uint${host_boundary}_t part${host_boundary}_cmp;"
+		AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary}_cmp;"])
 	    fi
 	    if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-		$as_echo "#endif /* TME_HAVE_INT${host_boundary}_T */"
+		AS_ECHO(["#endif /* TME_HAVE_INT${host_boundary}_T */"])
 	    fi
 	    host_boundary=`expr ${host_boundary} / 2`
 	done
-	$as_echo ""
-	$as_echo_n "  assert (bus_boundary != 0 && bus_boundary <= host_boundary);"
+	AS_ECHO([""])
+	AS_ECHO_N(["  assert (bus_boundary != 0 && bus_boundary <= host_boundary);"])
 
 	# loop over the possible host boundaries:
 	#
@@ -237,24 +237,24 @@ for size in ${sizes}; do
 	    #
 	    if test ${host_boundary} != 8; then
 		if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-		    $as_echo ""
-		    $as_echo ""
-		    $as_echo "#ifdef TME_HAVE_INT${host_boundary}_T"
-		    $as_echo ""
-		    $as_echo_n " "
+		    AS_ECHO([""])
+		    AS_ECHO([""])
+		    AS_ECHO(["#ifdef TME_HAVE_INT${host_boundary}_T"])
+		    AS_ECHO([""])
+		    AS_ECHO_N([" "])
 		fi
-		$as_echo_n " if (host_boundary == sizeof(tme_uint${host_boundary}_t))"
+		AS_ECHO_N([" if (host_boundary == sizeof(tme_uint${host_boundary}_t))"])
 	    fi
-	    $as_echo " {"
+	    AS_ECHO([" {"])
 
-	    $as_echo ""
-	    $as_echo "    /* prepare to ${op} the first ${host_boundary}-bit part of the memory: */"
-	    $as_echo "    parts${host_boundary} = (${op_const}tme_shared tme_uint${host_boundary}_t *) (((tme_uintptr_t) mem) & (((tme_uintptr_t) 0) - (${host_boundary} / 8)));"
-	    $as_echo "    size_skip = (((unsigned int) (tme_uintptr_t) mem) % (${host_boundary} / 8)) * 8;"
-	    $as_echo "    size_done = 0;"
+	    AS_ECHO([""])
+	    AS_ECHO(["    /* prepare to ${op} the first ${host_boundary}-bit part of the memory: */"])
+	    AS_ECHO(["    parts${host_boundary} = (${op_const}tme_shared tme_uint${host_boundary}_t *) (((tme_uintptr_t) mem) & (((tme_uintptr_t) 0) - (${host_boundary} / 8)));"])
+	    AS_ECHO(["    size_skip = (((unsigned int) (tme_uintptr_t) mem) % (${host_boundary} / 8)) * 8;"])
+	    AS_ECHO(["    size_done = 0;"])
 
-	    $as_echo ""
-	    $as_echo "    /* ${op} the first ${host_boundary}-bit part of the memory: */"
+	    AS_ECHO([""])
+	    AS_ECHO(["    /* ${op} the first ${host_boundary}-bit part of the memory: */"])
 
 	    # emit two accesses.  if the worst number of boundaries
 	    # that this access could cross is one, the second access
@@ -268,37 +268,37 @@ for size in ${sizes}; do
 
 		# read this memory part:
 		#
-		$as_echo "${indent0}    part${host_boundary} = tme_memory_atomic_read${host_boundary}(parts${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"
+		AS_ECHO(["${indent0}    part${host_boundary} = tme_memory_atomic_read${host_boundary}(parts${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"])
 
 		# if this is a read:
 		#
 		if test ${op} = read; then
 
-		    $as_echo ""
-		    $as_echo "${indent0}    /* on a little-endian host, we shift off the skip"
-		    $as_echo "${indent0}       data on the right, and shift the remaining data"
-		    $as_echo "${indent0}       up into position in the result: */"
-		    $as_echo "${indent0}    if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"
-		    $as_echo "${indent0}      x ${access_or}= (((tme_uint${size}_t) (part${host_boundary} >> ${size_skip})) << ${size_done});"
-		    $as_echo "${indent0}    }"
-		    $as_echo ""
-		    $as_echo "${indent0}    /* on a big-endian host, we shift off the skip data"
-		    $as_echo "${indent0}       on the left, and shift the remaining data down"
-		    $as_echo "${indent0}       into position in the result: */"
+		    AS_ECHO([""])
+		    AS_ECHO(["${indent0}    /* on a little-endian host, we shift off the skip"])
+		    AS_ECHO(["${indent0}       data on the right, and shift the remaining data"])
+		    AS_ECHO(["${indent0}       up into position in the result: */"])
+		    AS_ECHO(["${indent0}    if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"])
+		    AS_ECHO(["${indent0}      x ${access_or}= (((tme_uint${size}_t) (part${host_boundary} >> ${size_skip})) << ${size_done});"])
+		    AS_ECHO(["${indent0}    }"])
+		    AS_ECHO([""])
+		    AS_ECHO(["${indent0}    /* on a big-endian host, we shift off the skip data"])
+		    AS_ECHO(["${indent0}       on the left, and shift the remaining data down"])
+		    AS_ECHO(["${indent0}       into position in the result: */"])
 		    #
 		    # NB: on a big-endian host, because the skip data
 		    # is on the left, the type of what we shift
 		    # depends on how this host boundary size compares
 		    # to the access size:
 		    #
-		    $as_echo "${indent0}    else {"
-		    $as_echo_n "${indent0}      x ${access_or}= "
+		    AS_ECHO(["${indent0}    else {"])
+		    AS_ECHO_N(["${indent0}      x ${access_or}= "])
 		    if test `expr ${host_boundary} \> ${size}` = 1; then
-			$as_echo "((part${host_boundary} << ${size_skip}) >> ((${host_boundary} - ${size}) + ${size_done}));"
+			AS_ECHO(["((part${host_boundary} << ${size_skip}) >> ((${host_boundary} - ${size}) + ${size_done}));"])
 		    else
-			$as_echo "((((tme_uint${size}_t) part${host_boundary}) << ((${size} - ${host_boundary}) + ${size_skip})) >> ${size_done});"
+			AS_ECHO(["((((tme_uint${size}_t) part${host_boundary}) << ((${size} - ${host_boundary}) + ${size_skip})) >> ${size_done});"])
 		    fi
-		    $as_echo "${indent0}    }"
+		    AS_ECHO(["${indent0}    }"])
 
 		# otherwise, this is a write:
 		#
@@ -306,46 +306,46 @@ for size in ${sizes}; do
 
 		    # start the compare-and-exchange do loop:
 		    #
-		    $as_echo "${indent0}    do {"
-		    $as_echo "${indent0}      part${host_boundary}_cmp = part${host_boundary};"
-		    $as_echo ""
-		    $as_echo "${indent0}      /* on a little-endian host, we clear with zeroes"
-		    $as_echo "${indent0}         shifted up past the skip data, and then we"
-		    $as_echo "${indent0}         insert the data shifted up past the skip data: */"
-		    $as_echo "${indent0}      if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"
-		    $as_echo "${indent0}        part${host_boundary} &= (_tme_memory_type_mask(tme_uint${host_boundary}_t, + 0) ^ (((tme_uint${host_boundary}_t) _tme_memory_type_mask(tme_uint${size}_t, << ${size_done})) << ${size_skip}));"
-		    $as_echo "${indent0}        part${host_boundary} |= (((tme_uint${host_boundary}_t) x) << ${size_skip});"
-		    $as_echo "${indent0}      }"
-		    $as_echo ""
-		    $as_echo "${indent0}      /* on a big-endian host, we clear with zeroes"
-		    $as_echo "${indent0}         shifted down past the skip data, and then we"
-		    $as_echo "${indent0}         insert the data shifted down past the skip data: */"
+		    AS_ECHO(["${indent0}    do {"])
+		    AS_ECHO(["${indent0}      part${host_boundary}_cmp = part${host_boundary};"])
+		    AS_ECHO([""])
+		    AS_ECHO(["${indent0}      /* on a little-endian host, we clear with zeroes"])
+		    AS_ECHO(["${indent0}         shifted up past the skip data, and then we"])
+		    AS_ECHO(["${indent0}         insert the data shifted up past the skip data: */"])
+		    AS_ECHO(["${indent0}      if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"])
+		    AS_ECHO(["${indent0}        part${host_boundary} &= (_tme_memory_type_mask(tme_uint${host_boundary}_t, + 0) ^ (((tme_uint${host_boundary}_t) _tme_memory_type_mask(tme_uint${size}_t, << ${size_done})) << ${size_skip}));"])
+		    AS_ECHO(["${indent0}        part${host_boundary} |= (((tme_uint${host_boundary}_t) x) << ${size_skip});"])
+		    AS_ECHO(["${indent0}      }"])
+		    AS_ECHO([""])
+		    AS_ECHO(["${indent0}      /* on a big-endian host, we clear with zeroes"])
+		    AS_ECHO(["${indent0}         shifted down past the skip data, and then we"])
+		    AS_ECHO(["${indent0}         insert the data shifted down past the skip data: */"])
 		    #
 		    # NB: on a big-endian host, because the skip data
 		    # is on the left, exactly how we shift depends on
 		    # how this host boundary size compares to the
 		    # access size:
 		    #
-		    $as_echo "${indent0}      else {"
+		    AS_ECHO(["${indent0}      else {"])
 		    if test `expr ${host_boundary} \> ${size}` = 1; then
-			$as_echo "${indent0}        part${host_boundary} &= ~((((tme_uint${host_boundary}_t) _tme_memory_type_mask(tme_uint${size}_t, + 0)) << ((${host_boundary} - ${size}) + ${size_done})) >> ${size_skip});"
-			$as_echo "${indent0}        part${host_boundary} |= ((((tme_uint${host_boundary}_t) x) << (${host_boundary} - ${size})) >> ${size_skip});"
+			AS_ECHO(["${indent0}        part${host_boundary} &= ~((((tme_uint${host_boundary}_t) _tme_memory_type_mask(tme_uint${size}_t, + 0)) << ((${host_boundary} - ${size}) + ${size_done})) >> ${size_skip});"])
+			AS_ECHO(["${indent0}        part${host_boundary} |= ((((tme_uint${host_boundary}_t) x) << (${host_boundary} - ${size})) >> ${size_skip});"])
 		    else
-			$as_echo "${indent0}        part${host_boundary} &= ~(_tme_memory_type_mask(tme_uint${host_boundary}_t, << ${size_done}) >> ${size_skip});"
-			$as_echo "${indent0}        part${host_boundary} |= (x >> ((${size} - ${host_boundary}) + ${size_skip}));"
+			AS_ECHO(["${indent0}        part${host_boundary} &= ~(_tme_memory_type_mask(tme_uint${host_boundary}_t, << ${size_done}) >> ${size_skip});"])
+			AS_ECHO(["${indent0}        part${host_boundary} |= (x >> ((${size} - ${host_boundary}) + ${size_skip}));"])
 		    fi
-		    $as_echo "${indent0}      }"
-		    $as_echo ""
-		    $as_echo "${indent0}      /* loop until we can atomically update this part: */"
-		    $as_echo "${indent0}      part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"
-		    $as_echo "${indent0}    } while (part${host_boundary} != part${host_boundary}_cmp);"
+		    AS_ECHO(["${indent0}      }"])
+		    AS_ECHO([""])
+		    AS_ECHO(["${indent0}      /* loop until we can atomically update this part: */"])
+		    AS_ECHO(["${indent0}      part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"])
+		    AS_ECHO(["${indent0}    } while (part${host_boundary} != part${host_boundary}_cmp);"])
 		    if test ${host_boundaries_worst} != 1 || test ${size_skip} != 0; then
-			$as_echo "${indent0}    if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"
-			$as_echo "${indent0}      x >>= (${host_boundary} - ${size_skip});"
-			$as_echo "${indent0}    }"
-			$as_echo "${indent0}    else {"
-			$as_echo "${indent0}      x <<= (${host_boundary} - ${size_skip});"
-			$as_echo "${indent0}    }"
+			AS_ECHO(["${indent0}    if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"])
+			AS_ECHO(["${indent0}      x >>= (${host_boundary} - ${size_skip});"])
+			AS_ECHO(["${indent0}    }"])
+			AS_ECHO(["${indent0}    else {"])
+			AS_ECHO(["${indent0}      x <<= (${host_boundary} - ${size_skip});"])
+			AS_ECHO(["${indent0}    }"])
 		    fi
 		fi
 
@@ -353,7 +353,7 @@ for size in ${sizes}; do
 		#
 		if test ${size_done} = 0; then
 
-		    $as_echo "    size_done = ${host_boundary} - size_skip;"
+		    AS_ECHO(["    size_done = ${host_boundary} - size_skip;"])
 		    size_done=size_done
 		    size_skip=0
 		    access_or='|'
@@ -373,77 +373,77 @@ for size in ${sizes}; do
 			#
 			if test ${op} = write; then
 			    if test `expr ${host_boundary} \< ${size}` = 1; then
-				$as_echo ""
+				AS_ECHO([""])
 				if test ${host_boundaries_worst} = 2; then
-				    $as_echo "    /* try to write one full ${host_boundary}-bit part of memory: */"
-				    $as_echo_n "    if (__tme_predict_true(size_done <= (${size} - ${host_boundary})))"
+				    AS_ECHO(["    /* try to write one full ${host_boundary}-bit part of memory: */"])
+				    AS_ECHO_N(["    if (__tme_predict_true(size_done <= (${size} - ${host_boundary})))"])
 				else
-				    $as_echo "    /* write as many full ${host_boundary}-bit parts of the memory as we can: */"
-				    $as_echo_n "    for (; size_done <= (${size} - ${host_boundary}); )"
+				    AS_ECHO(["    /* write as many full ${host_boundary}-bit parts of the memory as we can: */"])
+				    AS_ECHO_N(["    for (; size_done <= (${size} - ${host_boundary}); )"])
 				fi
-				$as_echo " {"
-				$as_echo ""
-				$as_echo "      /* make a boundary: */"
-				$as_echo "      tme_memory_barrier(mem, (${size} / 8), TME_MEMORY_BARRIER_${op_cap}_BEFORE_${op_cap});"
-				$as_echo ""
-				$as_echo "      /* write a full ${host_boundary}-bit part of memory: */"
-				$as_echo "      part${host_boundary} = (x >> ((TME_ENDIAN_NATIVE == TME_ENDIAN_BIG) * (${size} - ${host_boundary})));"
-				$as_echo "      parts${host_boundary}++;"
-				$as_echo "      tme_memory_atomic_write${host_boundary}(parts${host_boundary}, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"
-				$as_echo "      size_done += ${host_boundary};"
-				$as_echo "      if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"
-				$as_echo "        x >>= ${host_boundary};"
-				$as_echo "      }"
-				$as_echo "      else {"
-				$as_echo "        x <<= ${host_boundary};"
-				$as_echo "      }"
-				$as_echo "    }"
+				AS_ECHO([" {"])
+				AS_ECHO([""])
+				AS_ECHO(["      /* make a boundary: */"])
+				AS_ECHO(["      tme_memory_barrier(mem, (${size} / 8), TME_MEMORY_BARRIER_${op_cap}_BEFORE_${op_cap});"])
+				AS_ECHO([""])
+				AS_ECHO(["      /* write a full ${host_boundary}-bit part of memory: */"])
+				AS_ECHO(["      part${host_boundary} = (x >> ((TME_ENDIAN_NATIVE == TME_ENDIAN_BIG) * (${size} - ${host_boundary})));"])
+				AS_ECHO(["      parts${host_boundary}++;"])
+				AS_ECHO(["      tme_memory_atomic_write${host_boundary}(parts${host_boundary}, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"])
+				AS_ECHO(["      size_done += ${host_boundary};"])
+				AS_ECHO(["      if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"])
+				AS_ECHO(["        x >>= ${host_boundary};"])
+				AS_ECHO(["      }"])
+				AS_ECHO(["      else {"])
+				AS_ECHO(["        x <<= ${host_boundary};"])
+				AS_ECHO(["      }"])
+				AS_ECHO(["    }"])
 				access_if=true
 			    fi
 			fi
 		    fi
-		    $as_echo ""
+		    AS_ECHO([""])
 		    if $access_if; then
-			$as_echo "    /* ${op} at most one remaining ${host_boundary}-bit part of the memory: */"
-			$as_echo_n "    if (__tme_predict_false(size_done < ${size}))"
+			AS_ECHO(["    /* ${op} at most one remaining ${host_boundary}-bit part of the memory: */"])
+			AS_ECHO_N(["    if (__tme_predict_false(size_done < ${size}))"])
 		    else
-			$as_echo "    /* ${op} any remaining ${host_boundary}-bit parts of the memory: */"
-			$as_echo_n "    for (; size_done < ${size}; size_done += ${host_boundary})"
+			AS_ECHO(["    /* ${op} any remaining ${host_boundary}-bit parts of the memory: */"])
+			AS_ECHO_N(["    for (; size_done < ${size}; size_done += ${host_boundary})"])
 		    fi
-		    $as_echo " {"
-
-		    $as_echo ""
-		    $as_echo "      /* make a boundary: */"
-		    $as_echo "      tme_memory_barrier(mem, (${size} / 8), TME_MEMORY_BARRIER_${op_cap}_BEFORE_${op_cap});"
-		    $as_echo ""
-		    $as_echo "      /* ${op} the next ${host_boundary}-bit part of the memory: */"
-		    $as_echo "      parts${host_boundary}++;"
+		    AS_ECHO([" {"])
+
+		    AS_ECHO([""])
+		    AS_ECHO(["      /* make a boundary: */"])
+		    AS_ECHO(["      tme_memory_barrier(mem, (${size} / 8), TME_MEMORY_BARRIER_${op_cap}_BEFORE_${op_cap});"])
+		    AS_ECHO([""])
+		    AS_ECHO(["      /* ${op} the next ${host_boundary}-bit part of the memory: */"])
+		    AS_ECHO(["      parts${host_boundary}++;"])
 		    indent0="  "
 
 		# otherwise, this was the loop or second access:
 		#
 		else
-		    $as_echo "    }"
+		    AS_ECHO(["    }"])
 		    break
 		fi
 
 	    done
 
-	    $as_echo "  }"
+	    AS_ECHO(["  }"])
 
 	    # close this host boundary:
 	    #
 	    if test ${host_boundary} != 8; then
-		$as_echo ""
-		$as_echo_n "  else"
+		AS_ECHO([""])
+		AS_ECHO_N(["  else"])
 		if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-		    $as_echo ""
-		    $as_echo ""
-		    $as_echo_n "#endif /* TME_HAVE_INT${host_boundary}_T */"
+		    AS_ECHO([""])
+		    AS_ECHO([""])
+		    AS_ECHO_N(["#endif /* TME_HAVE_INT${host_boundary}_T */"])
 		    if test ${host_boundary} = ${size_ifdef}; then
-			$as_echo ""
-			$as_echo ""
-			$as_echo_n " "
+			AS_ECHO([""])
+			AS_ECHO([""])
+			AS_ECHO_N([" "])
 		    fi
 		fi
 	    fi
@@ -453,16 +453,16 @@ for size in ${sizes}; do
 	    host_boundary=`expr ${host_boundary} / 2`
 	done
 	if test ${op} = read; then
-	    $as_echo ""
-	    $as_echo "  /* return the value read: */"
-	    $as_echo "  return (x);"
+	    AS_ECHO([""])
+	    AS_ECHO(["  /* return the value read: */"])
+	    AS_ECHO(["  return (x);"])
 	fi
-	$as_echo "}"
+	AS_ECHO(["}"])
     done
 
     if test `expr ${size} \>= ${size_ifdef}` = 1; then
-	$as_echo ""
-	$as_echo "#endif /* TME_HAVE_INT${size}_T */"
+	AS_ECHO([""])
+	AS_ECHO(["#endif /* TME_HAVE_INT${size}_T */"])
     fi
 
 done
@@ -497,86 +497,86 @@ for op in read write; do
     #
     if $header; then
 
-	$as_echo ""
-	$as_echo "/* the bus ${op} buffer function and default macro implementation: */"
+	AS_ECHO([""])
+	AS_ECHO(["/* the bus ${op} buffer function and default macro implementation: */"])
 
 	# emit the prototype:
 	#
-	$as_echo "void tme_memory_bus_${op}_buffer _TME_P((${op_const_mem}tme_shared tme_uint8_t *, ${op_const_buffer}tme_uint8_t *, unsigned long, tme_rwlock_t *, unsigned int, unsigned int));"
+	AS_ECHO(["void tme_memory_bus_${op}_buffer _TME_P((${op_const_mem}tme_shared tme_uint8_t *, ${op_const_buffer}tme_uint8_t *, unsigned long, tme_rwlock_t *, unsigned int, unsigned int));"])
 
 	# emit the default macro definition:
 	#
-	$as_echo "#define tme_memory_bus_${op}_buffer(mem, buffer, count, rwlock, align_min, bus_boundary) \\"
-	$as_echo "  do { \\"
-	$as_echo "    if (tme_thread_cooperative()) { \\"
-	$as_echo "      memcpy(${op_memcpy}, (count)); \\"
-	$as_echo "    } \\"
-	$as_echo "    else { \\"
-	$as_echo "      tme_memory_bus_${op}_buffer(((${op_const_mem}tme_shared tme_uint8_t *) ${op_audit_mem}(mem)), ((${op_const_buffer}tme_uint8_t *) ${op_audit_buffer}(buffer)), (count), (rwlock), (align_min), (bus_boundary)); \\"
-	$as_echo "    } \\"
-	$as_echo "  } while (/* CONSTCOND */ 0)"
+	AS_ECHO(["#define tme_memory_bus_${op}_buffer(mem, buffer, count, rwlock, align_min, bus_boundary) \\"])
+	AS_ECHO(["  do { \\"])
+	AS_ECHO(["    if (tme_thread_cooperative()) { \\"])
+	AS_ECHO(["      memcpy(${op_memcpy}, (count)); \\"])
+	AS_ECHO(["    } \\"])
+	AS_ECHO(["    else { \\"])
+	AS_ECHO(["      tme_memory_bus_${op}_buffer(((${op_const_mem}tme_shared tme_uint8_t *) ${op_audit_mem}(mem)), ((${op_const_buffer}tme_uint8_t *) ${op_audit_buffer}(buffer)), (count), (rwlock), (align_min), (bus_boundary)); \\"])
+	AS_ECHO(["    } \\"])
+	AS_ECHO(["  } while (/* CONSTCOND */ 0)"])
 
 	continue
     fi
 
     # start the function:
     #
-    $as_echo ""
-    $as_echo "/* undefine the macro version of tme_memory_bus_${op}_buffer: */"
-    $as_echo "#undef tme_memory_bus_${op}_buffer"
-    $as_echo ""
-    $as_echo "/* the bus ${op} buffer function: */"
-    $as_echo "void"
-    $as_echo "tme_memory_bus_${op}_buffer(${op_const_mem}tme_shared tme_uint8_t *mem, ${op_const_buffer}tme_uint8_t *buffer, unsigned long count, tme_rwlock_t *rwlock, unsigned int align_min, unsigned int bus_boundary)"
-    $as_echo "{"
-    $as_echo "  const unsigned int host_boundary = TME_MEMORY_BUS_BOUNDARY;"
-    $as_echo "  ${op_const_mem}tme_uint8_t *part_buffer;"
-    $as_echo "  unsigned int count_done;"
-    $as_echo "  unsigned int count_misaligned;"
-    $as_echo "  unsigned int bits_misaligned;"
+    AS_ECHO([""])
+    AS_ECHO(["/* undefine the macro version of tme_memory_bus_${op}_buffer: */"])
+    AS_ECHO(["#undef tme_memory_bus_${op}_buffer"])
+    AS_ECHO([""])
+    AS_ECHO(["/* the bus ${op} buffer function: */"])
+    AS_ECHO(["void"])
+    AS_ECHO(["tme_memory_bus_${op}_buffer(${op_const_mem}tme_shared tme_uint8_t *mem, ${op_const_buffer}tme_uint8_t *buffer, unsigned long count, tme_rwlock_t *rwlock, unsigned int align_min, unsigned int bus_boundary)"])
+    AS_ECHO(["{"])
+    AS_ECHO(["  const unsigned int host_boundary = TME_MEMORY_BUS_BOUNDARY;"])
+    AS_ECHO(["  ${op_const_mem}tme_uint8_t *part_buffer;"])
+    AS_ECHO(["  unsigned int count_done;"])
+    AS_ECHO(["  unsigned int count_misaligned;"])
+    AS_ECHO(["  unsigned int bits_misaligned;"])
 
     # emit the locals for the possible host boundaries:
     #
     host_boundary=${host_boundary_largest}
     while test ${host_boundary} != 4; do
 	if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-	    $as_echo "#ifdef TME_HAVE_INT${host_boundary}_T"
+	    AS_ECHO(["#ifdef TME_HAVE_INT${host_boundary}_T"])
 	fi
-	$as_echo "  ${op_const_mem}tme_shared tme_uint${host_boundary}_t *parts${host_boundary};"
-	$as_echo "  tme_uint${host_boundary}_t part${host_boundary}_buffer;"
-	$as_echo "  tme_uint${host_boundary}_t part${host_boundary};"
-	$as_echo "  tme_uint${host_boundary}_t part${host_boundary}_next;"
+	AS_ECHO(["  ${op_const_mem}tme_shared tme_uint${host_boundary}_t *parts${host_boundary};"])
+	AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary}_buffer;"])
+	AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary};"])
+	AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary}_next;"])
 	if test ${op} = write; then
-	    $as_echo "  tme_uint${host_boundary}_t part${host_boundary}_mask;"
-	    $as_echo "  tme_uint${host_boundary}_t part${host_boundary}_cmp;"
+	    AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary}_mask;"])
+	    AS_ECHO(["  tme_uint${host_boundary}_t part${host_boundary}_cmp;"])
 	fi
 	if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-	    $as_echo "#endif /* TME_HAVE_INT${host_boundary}_T */"
+	    AS_ECHO(["#endif /* TME_HAVE_INT${host_boundary}_T */"])
 	fi
 	host_boundary=`expr ${host_boundary} / 2`
     done
-    $as_echo ""
-    $as_echo "  assert (count != 0);"
-    $as_echo "  assert (bus_boundary != 0);"
+    AS_ECHO([""])
+    AS_ECHO(["  assert (count != 0);"])
+    AS_ECHO(["  assert (bus_boundary != 0);"])
     
-    $as_echo ""
-    $as_echo "  /* if we are locking for all memory accesses, lock memory"
-    $as_echo "     around a memcpy: */"
-    $as_echo "  if (TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0) {"
-    $as_echo "    tme_rwlock_${op_rwlock}lock(rwlock);"
-    $as_echo "    memcpy(${op_memcpy}, (count));"
-    $as_echo "    tme_rwlock_${op_rwlock}unlock(rwlock);"
-    $as_echo "  }"
-    $as_echo ""
-    $as_echo "  /* otherwise, if the emulated bus boundary is greater than the"
-    $as_echo "     host's bus boundary, we are forced to stop all other threads"
-    $as_echo "     around a memcpy: */"
-    $as_echo "  else if (__tme_predict_false(bus_boundary == 0"
-    $as_echo "                               || bus_boundary > host_boundary)) {"
-    $as_echo "    tme_thread_suspend_others();"
-    $as_echo "    memcpy(${op_memcpy}, (count) + (0 && align_min));"
-    $as_echo "    tme_thread_resume_others();"
-    $as_echo "  }"
+    AS_ECHO([""])
+    AS_ECHO(["  /* if we are locking for all memory accesses, lock memory"])
+    AS_ECHO(["     around a memcpy: */"])
+    AS_ECHO(["  if (TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0) {"])
+    AS_ECHO(["    tme_rwlock_${op_rwlock}lock(rwlock);"])
+    AS_ECHO(["    memcpy(${op_memcpy}, (count));"])
+    AS_ECHO(["    tme_rwlock_${op_rwlock}unlock(rwlock);"])
+    AS_ECHO(["  }"])
+    AS_ECHO([""])
+    AS_ECHO(["  /* otherwise, if the emulated bus boundary is greater than the"])
+    AS_ECHO(["     host's bus boundary, we are forced to stop all other threads"])
+    AS_ECHO(["     around a memcpy: */"])
+    AS_ECHO(["  else if (__tme_predict_false(bus_boundary == 0"])
+    AS_ECHO(["                               || bus_boundary > host_boundary)) {"])
+    AS_ECHO(["    tme_thread_suspend_others();"])
+    AS_ECHO(["    memcpy(${op_memcpy}, (count) + (0 && align_min));"])
+    AS_ECHO(["    tme_thread_resume_others();"])
+    AS_ECHO(["  }"])
 
     # loop over the possible host boundaries:
     #
@@ -587,15 +587,15 @@ for op in read write; do
 	# open this host boundary:
 	#
 	if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-	    $as_echo ""
-	    $as_echo "#ifdef TME_HAVE_INT${host_boundary}_T"
+	    AS_ECHO([""])
+	    AS_ECHO(["#ifdef TME_HAVE_INT${host_boundary}_T"])
 	fi
-	$as_echo ""
-	$as_echo_n "  else"
+	AS_ECHO([""])
+	AS_ECHO_N(["  else"])
 	if test ${host_boundary} != 8; then
-	    $as_echo_n " if (host_boundary == sizeof(tme_uint${host_boundary}_t))"
+	    AS_ECHO_N([" if (host_boundary == sizeof(tme_uint${host_boundary}_t))"])
 	fi
-	$as_echo " {"
+	AS_ECHO([" {"])
 
 	if test ${op} = write; then
 	    op_part_read="tme_memory_read${host_boundary}((const tme_uint${host_boundary}_t *) buffer, sizeof(tme_uint${host_boundary}_t))"
@@ -605,249 +605,249 @@ for op in read write; do
 	    op_part_write="tme_memory_write${host_boundary}((tme_uint${host_boundary}_t *) buffer, part${host_boundary}, sizeof(tme_uint${host_boundary}_t))"
 	fi
 
-	$as_echo ""
-	$as_echo "    /* make a ${host_boundary}-bit pointer to the memory: */"
-	$as_echo "    parts${host_boundary} = (${op_const_mem}tme_shared tme_uint${host_boundary}_t *) mem;"
-	$as_echo ""
-	$as_echo "    /* if this pointer is not ${host_boundary}-bit aligned: */"
-	$as_echo "    if (__tme_predict_false((((tme_uintptr_t) parts${host_boundary}) % sizeof(tme_uint${host_boundary}_t)) != 0)) {"
-	$as_echo ""
-	$as_echo "      /* get the misalignment from the previous ${host_boundary}-bit boundary: */"
-	$as_echo "      count_misaligned = ((tme_uintptr_t) parts${host_boundary}) % sizeof(tme_uint${host_boundary}_t);"
-	$as_echo ""
-	$as_echo "      /* truncate this pointer to the previous ${host_boundary}-bit boundary: */"
-	$as_echo "      parts${host_boundary} = (${op_const_mem}tme_shared tme_uint${host_boundary}_t *) (((tme_uintptr_t) parts${host_boundary}) & (((tme_uintptr_t) 0) - sizeof(tme_uint${host_boundary}_t)));"
-	$as_echo ""
-	$as_echo "      /* get the number of bytes to ${op} in the first ${host_boundary}-bit memory part: */"
-	$as_echo "      count_done = sizeof(tme_uint${host_boundary}_t) - count_misaligned;"
-	$as_echo "      if (__tme_predict_false(count_done > count)) {"
-	$as_echo "        count_done = count;"
-	$as_echo "      }"
+	AS_ECHO([""])
+	AS_ECHO(["    /* make a ${host_boundary}-bit pointer to the memory: */"])
+	AS_ECHO(["    parts${host_boundary} = (${op_const_mem}tme_shared tme_uint${host_boundary}_t *) mem;"])
+	AS_ECHO([""])
+	AS_ECHO(["    /* if this pointer is not ${host_boundary}-bit aligned: */"])
+	AS_ECHO(["    if (__tme_predict_false((((tme_uintptr_t) parts${host_boundary}) % sizeof(tme_uint${host_boundary}_t)) != 0)) {"])
+	AS_ECHO([""])
+	AS_ECHO(["      /* get the misalignment from the previous ${host_boundary}-bit boundary: */"])
+	AS_ECHO(["      count_misaligned = ((tme_uintptr_t) parts${host_boundary}) % sizeof(tme_uint${host_boundary}_t);"])
+	AS_ECHO([""])
+	AS_ECHO(["      /* truncate this pointer to the previous ${host_boundary}-bit boundary: */"])
+	AS_ECHO(["      parts${host_boundary} = (${op_const_mem}tme_shared tme_uint${host_boundary}_t *) (((tme_uintptr_t) parts${host_boundary}) & (((tme_uintptr_t) 0) - sizeof(tme_uint${host_boundary}_t)));"])
+	AS_ECHO([""])
+	AS_ECHO(["      /* get the number of bytes to ${op} in the first ${host_boundary}-bit memory part: */"])
+	AS_ECHO(["      count_done = sizeof(tme_uint${host_boundary}_t) - count_misaligned;"])
+	AS_ECHO(["      if (__tme_predict_false(count_done > count)) {"])
+	AS_ECHO(["        count_done = count;"])
+	AS_ECHO(["      }"])
 
 	if test ${op} = write; then
-	    $as_echo ""
-	    $as_echo "      /* make a mask that clears for the data to write in the"
-	    $as_echo "         first ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary}_mask = 1;"
-	    $as_echo "      part${host_boundary}_mask = (part${host_boundary}_mask << (count_done * 8)) - 1;"
-	    $as_echo "      part${host_boundary}_mask"
-	    $as_echo "        <<= (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE"
-	    $as_echo "             ? (count_misaligned * 8)"
-	    $as_echo "             : (${host_boundary} - ((count_misaligned + count_done) * 8)));"
-	    $as_echo "      part${host_boundary}_mask = ~part${host_boundary}_mask;"
-	    $as_echo ""
-	    $as_echo "      /* copy from the buffer the bytes to write in the first"
-	    $as_echo "         ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary}_buffer = 0;"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* make a mask that clears for the data to write in the"])
+	    AS_ECHO(["         first ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary}_mask = 1;"])
+	    AS_ECHO(["      part${host_boundary}_mask = (part${host_boundary}_mask << (count_done * 8)) - 1;"])
+	    AS_ECHO(["      part${host_boundary}_mask"])
+	    AS_ECHO(["        <<= (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE"])
+	    AS_ECHO(["             ? (count_misaligned * 8)"])
+	    AS_ECHO(["             : (${host_boundary} - ((count_misaligned + count_done) * 8)));"])
+	    AS_ECHO(["      part${host_boundary}_mask = ~part${host_boundary}_mask;"])
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* copy from the buffer the bytes to write in the first"])
+	    AS_ECHO(["         ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary}_buffer = 0;"])
 	else
-	    $as_echo ""
-	    $as_echo "      /* read the first ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary}_buffer = ${op_part_read};"
-	    $as_echo "      parts${host_boundary}++;"
-	    $as_echo ""
-	    $as_echo "      /* copy to the buffer the bytes to read in the first"
-	    $as_echo "         ${host_boundary}-bit memory part: */"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* read the first ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary}_buffer = ${op_part_read};"])
+	    AS_ECHO(["      parts${host_boundary}++;"])
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* copy to the buffer the bytes to read in the first"])
+	    AS_ECHO(["         ${host_boundary}-bit memory part: */"])
 	fi
-	$as_echo "      part_buffer = ((tme_uint8_t *) &part${host_boundary}_buffer) + count_misaligned;"
-	$as_echo "      count -= count_done;"
-	$as_echo "      do {"
-	$as_echo "        ${op_copy};"
-	$as_echo "        part_buffer++;"
-	$as_echo "        buffer++;"
-	$as_echo "      } while (--count_done != 0);"
+	AS_ECHO(["      part_buffer = ((tme_uint8_t *) &part${host_boundary}_buffer) + count_misaligned;"])
+	AS_ECHO(["      count -= count_done;"])
+	AS_ECHO(["      do {"])
+	AS_ECHO(["        ${op_copy};"])
+	AS_ECHO(["        part_buffer++;"])
+	AS_ECHO(["        buffer++;"])
+	AS_ECHO(["      } while (--count_done != 0);"])
 
 	if test ${op} = write; then
-	    $as_echo ""
-	    $as_echo "      /* compare-and-exchange the first ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary} = ${op_part_read};"
-	    $as_echo "      do {"
-	    $as_echo "        part${host_boundary}_cmp = part${host_boundary};"
-	    $as_echo "        part${host_boundary} = (part${host_boundary} & part${host_boundary}_mask) | part${host_boundary}_buffer;"
-	    $as_echo "        part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"
-	    $as_echo "      } while (part${host_boundary} != part${host_boundary}_cmp);"
-	    $as_echo "      parts${host_boundary}++;"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* compare-and-exchange the first ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary} = ${op_part_read};"])
+	    AS_ECHO(["      do {"])
+	    AS_ECHO(["        part${host_boundary}_cmp = part${host_boundary};"])
+	    AS_ECHO(["        part${host_boundary} = (part${host_boundary} & part${host_boundary}_mask) | part${host_boundary}_buffer;"])
+	    AS_ECHO(["        part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"])
+	    AS_ECHO(["      } while (part${host_boundary} != part${host_boundary}_cmp);"])
+	    AS_ECHO(["      parts${host_boundary}++;"])
 	fi
-	$as_echo "    }"
-
-	$as_echo ""
-	$as_echo "    /* if we have full ${host_boundary}-bit parts to ${op}: */"
-	$as_echo "    if (__tme_predict_true(count >= sizeof(tme_uint${host_boundary}_t))) {"
-	$as_echo ""
-	$as_echo "      /* if the buffer is ${host_boundary}-bit aligned: */"
-	$as_echo "      if (__tme_predict_true((((tme_uintptr_t) buffer) % sizeof(tme_uint${host_boundary}_t)) == 0)) {"
-	$as_echo ""
-	$as_echo "        /* ${op} full ${host_boundary}-bit parts without shifting: */"
-	$as_echo "        do {"
-	$as_echo "          part${host_boundary} = ${op_part_read};"
-	$as_echo "          ${op_part_write};"
-	$as_echo ""
-	$as_echo "          /* advance: */"
-	$as_echo "          parts${host_boundary}++;"
-	$as_echo "          buffer += sizeof(tme_uint${host_boundary}_t);"
-	$as_echo "          count -= sizeof(tme_uint${host_boundary}_t);"
-	$as_echo "        } while (count >= sizeof(tme_uint${host_boundary}_t));"
-	$as_echo "      }"
-	$as_echo ""
-	$as_echo "      /* otherwise, the buffer is not ${host_boundary}-bit aligned: */"
-	$as_echo "      else {"
-	$as_echo ""
-	$as_echo "        /* get the misalignment to the next ${host_boundary}-bit boundary: */"
-	$as_echo "        count_misaligned = (sizeof(tme_uint${host_boundary}_t) - ((unsigned int) (tme_uintptr_t) buffer)) % sizeof(tme_uint${host_boundary}_t);"
+	AS_ECHO(["    }"])
+
+	AS_ECHO([""])
+	AS_ECHO(["    /* if we have full ${host_boundary}-bit parts to ${op}: */"])
+	AS_ECHO(["    if (__tme_predict_true(count >= sizeof(tme_uint${host_boundary}_t))) {"])
+	AS_ECHO([""])
+	AS_ECHO(["      /* if the buffer is ${host_boundary}-bit aligned: */"])
+	AS_ECHO(["      if (__tme_predict_true((((tme_uintptr_t) buffer) % sizeof(tme_uint${host_boundary}_t)) == 0)) {"])
+	AS_ECHO([""])
+	AS_ECHO(["        /* ${op} full ${host_boundary}-bit parts without shifting: */"])
+	AS_ECHO(["        do {"])
+	AS_ECHO(["          part${host_boundary} = ${op_part_read};"])
+	AS_ECHO(["          ${op_part_write};"])
+	AS_ECHO([""])
+	AS_ECHO(["          /* advance: */"])
+	AS_ECHO(["          parts${host_boundary}++;"])
+	AS_ECHO(["          buffer += sizeof(tme_uint${host_boundary}_t);"])
+	AS_ECHO(["          count -= sizeof(tme_uint${host_boundary}_t);"])
+	AS_ECHO(["        } while (count >= sizeof(tme_uint${host_boundary}_t));"])
+	AS_ECHO(["      }"])
+	AS_ECHO([""])
+	AS_ECHO(["      /* otherwise, the buffer is not ${host_boundary}-bit aligned: */"])
+	AS_ECHO(["      else {"])
+	AS_ECHO([""])
+	AS_ECHO(["        /* get the misalignment to the next ${host_boundary}-bit boundary: */"])
+	AS_ECHO(["        count_misaligned = (sizeof(tme_uint${host_boundary}_t) - ((unsigned int) (tme_uintptr_t) buffer)) % sizeof(tme_uint${host_boundary}_t);"])
 	if test ${op} = write; then
-	    $as_echo ""
-	    $as_echo "        /* copy from the buffer until it is aligned: */"
-	    $as_echo "        part${host_boundary}_buffer = 0;"
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* copy from the buffer until it is aligned: */"])
+	    AS_ECHO(["        part${host_boundary}_buffer = 0;"])
 	else
-	    $as_echo ""
-	    $as_echo "        /* read the next ${host_boundary}-bit memory part: */"
-	    $as_echo "        part${host_boundary}_buffer = ${op_part_read};"
-	    $as_echo "        parts${host_boundary}++;"
-	    $as_echo ""
-	    $as_echo "        /* copy to the buffer until it is aligned: */"
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* read the next ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["        part${host_boundary}_buffer = ${op_part_read};"])
+	    AS_ECHO(["        parts${host_boundary}++;"])
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* copy to the buffer until it is aligned: */"])
 	fi
-	$as_echo "        part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);"
-	$as_echo "        count_done = count_misaligned;"
-	$as_echo "        count -= count_misaligned;"
-	$as_echo "        do {"
-	$as_echo "          ${op_copy};"
-	$as_echo "          part_buffer++;"
-	$as_echo "          buffer++;"
-	$as_echo "        } while (--count_done != 0);"
-
-	$as_echo ""
-	$as_echo "        /* ${op} full ${host_boundary}-bit words with shifting: */"
-	$as_echo "        bits_misaligned = count_misaligned * 8;"
+	AS_ECHO(["        part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);"])
+	AS_ECHO(["        count_done = count_misaligned;"])
+	AS_ECHO(["        count -= count_misaligned;"])
+	AS_ECHO(["        do {"])
+	AS_ECHO(["          ${op_copy};"])
+	AS_ECHO(["          part_buffer++;"])
+	AS_ECHO(["          buffer++;"])
+	AS_ECHO(["        } while (--count_done != 0);"])
+
+	AS_ECHO([""])
+	AS_ECHO(["        /* ${op} full ${host_boundary}-bit words with shifting: */"])
+	AS_ECHO(["        bits_misaligned = count_misaligned * 8;"])
 	if test ${op} = write; then
 	    op_shift=bits_misaligned
 	    op_shift_next="(${host_boundary} - bits_misaligned)"
-	    $as_echo "        part${host_boundary} = part${host_boundary}_buffer;"
+	    AS_ECHO(["        part${host_boundary} = part${host_boundary}_buffer;"])
 	else
 	    op_shift="(${host_boundary} - bits_misaligned)"
 	    op_shift_next=bits_misaligned
-	    $as_echo "        part${host_boundary}"
-	    $as_echo "          = (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE"
-	    $as_echo "             ? (part${host_boundary}_buffer >> ${op_shift_next})"
-	    $as_echo "             : (part${host_boundary}_buffer << ${op_shift_next}));"
+	    AS_ECHO(["        part${host_boundary}"])
+	    AS_ECHO(["          = (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE"])
+	    AS_ECHO(["             ? (part${host_boundary}_buffer >> ${op_shift_next})"])
+	    AS_ECHO(["             : (part${host_boundary}_buffer << ${op_shift_next}));"])
 	fi
-	$as_echo "        for (; count >= sizeof(tme_uint${host_boundary}_t); ) {"
-	$as_echo "          part${host_boundary}_next = ${op_part_read};"
-	$as_echo "          if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"
-	$as_echo "            part${host_boundary} |= (part${host_boundary}_next << ${op_shift});"
-	$as_echo "            ${op_part_write};"
-	$as_echo "            part${host_boundary} = (part${host_boundary}_next >> ${op_shift_next});"
-	$as_echo "          }"
-	$as_echo "          else {"
-	$as_echo "            part${host_boundary} |= (part${host_boundary}_next >> ${op_shift});"
-	$as_echo "            ${op_part_write};"
-	$as_echo "            part${host_boundary} = (part${host_boundary}_next << ${op_shift_next});"
-	$as_echo "          }"
-	$as_echo ""
-	$as_echo "          /* advance: */"
-	$as_echo "          parts${host_boundary}++;"
-	$as_echo "          buffer += sizeof(tme_uint${host_boundary}_t);"
-	$as_echo "          count -= sizeof(tme_uint${host_boundary}_t);"
-	$as_echo "        }"
-
-	$as_echo ""
-	$as_echo "        /* calculate how many more bytes there are to ${op} in this"
-	$as_echo "           ${host_boundary}-bit memory part: */"
-	$as_echo "        count_done = sizeof(tme_uint${host_boundary}_t) - count_misaligned;"
-	$as_echo "        part${host_boundary}_buffer = part${host_boundary};"
+	AS_ECHO(["        for (; count >= sizeof(tme_uint${host_boundary}_t); ) {"])
+	AS_ECHO(["          part${host_boundary}_next = ${op_part_read};"])
+	AS_ECHO(["          if (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE) {"])
+	AS_ECHO(["            part${host_boundary} |= (part${host_boundary}_next << ${op_shift});"])
+	AS_ECHO(["            ${op_part_write};"])
+	AS_ECHO(["            part${host_boundary} = (part${host_boundary}_next >> ${op_shift_next});"])
+	AS_ECHO(["          }"])
+	AS_ECHO(["          else {"])
+	AS_ECHO(["            part${host_boundary} |= (part${host_boundary}_next >> ${op_shift});"])
+	AS_ECHO(["            ${op_part_write};"])
+	AS_ECHO(["            part${host_boundary} = (part${host_boundary}_next << ${op_shift_next});"])
+	AS_ECHO(["          }"])
+	AS_ECHO([""])
+	AS_ECHO(["          /* advance: */"])
+	AS_ECHO(["          parts${host_boundary}++;"])
+	AS_ECHO(["          buffer += sizeof(tme_uint${host_boundary}_t);"])
+	AS_ECHO(["          count -= sizeof(tme_uint${host_boundary}_t);"])
+	AS_ECHO(["        }"])
+
+	AS_ECHO([""])
+	AS_ECHO(["        /* calculate how many more bytes there are to ${op} in this"])
+	AS_ECHO(["           ${host_boundary}-bit memory part: */"])
+	AS_ECHO(["        count_done = sizeof(tme_uint${host_boundary}_t) - count_misaligned;"])
+	AS_ECHO(["        part${host_boundary}_buffer = part${host_boundary};"])
 	if test ${op} = write; then
-	    $as_echo ""
-	    $as_echo "        /* if we can't write one more full ${host_boundary}-bit memory part: */"
-	    $as_echo "        if (count_done > count) {"
-	    $as_echo ""
-	    $as_echo "          /* we will reread this data to write below: */"
-	    $as_echo "          buffer -= count_misaligned;"
-	    $as_echo "          count += count_misaligned;"
-	    $as_echo "        }"
-	    $as_echo ""
-	    $as_echo "        /* otherwise, we can write one more full ${host_boundary}-bit memory part: */"
-	    $as_echo "        else {"
-	    $as_echo ""
-	    $as_echo "          /* copy from the buffer until we have the full ${host_boundary}-bit part: */"
-	    $as_echo "          part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer) + count_misaligned;"
-	    $as_echo "          count -= count_done;"
-	    $as_echo "          do {"
-	    $as_echo "            ${op_copy};"
-	    $as_echo "            part_buffer++;"
-	    $as_echo "            buffer++;"
-	    $as_echo "          } while (--count_done != 0);"
-	    $as_echo ""
-	    $as_echo "          /* write the last full ${host_boundary}-bit memory part: */"
-	    $as_echo "          part${host_boundary} = part${host_boundary}_buffer;"
-	    $as_echo "          ${op_part_write};"
-	    $as_echo "        }"
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* if we can't write one more full ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["        if (count_done > count) {"])
+	    AS_ECHO([""])
+	    AS_ECHO(["          /* we will reread this data to write below: */"])
+	    AS_ECHO(["          buffer -= count_misaligned;"])
+	    AS_ECHO(["          count += count_misaligned;"])
+	    AS_ECHO(["        }"])
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* otherwise, we can write one more full ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["        else {"])
+	    AS_ECHO([""])
+	    AS_ECHO(["          /* copy from the buffer until we have the full ${host_boundary}-bit part: */"])
+	    AS_ECHO(["          part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer) + count_misaligned;"])
+	    AS_ECHO(["          count -= count_done;"])
+	    AS_ECHO(["          do {"])
+	    AS_ECHO(["            ${op_copy};"])
+	    AS_ECHO(["            part_buffer++;"])
+	    AS_ECHO(["            buffer++;"])
+	    AS_ECHO(["          } while (--count_done != 0);"])
+	    AS_ECHO([""])
+	    AS_ECHO(["          /* write the last full ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["          part${host_boundary} = part${host_boundary}_buffer;"])
+	    AS_ECHO(["          ${op_part_write};"])
+	    AS_ECHO(["        }"])
 	else
-	    $as_echo ""
-	    $as_echo "        /* copy to the buffer the remaining bytes in this ${host_boundary}-bit part: */"
-	    $as_echo "        if (count_done > count) {"
-	    $as_echo "          count_done = count;"
-	    $as_echo "        }"
-	    $as_echo "        part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);"
-	    $as_echo "        count -= count_done;"
-	    $as_echo "        do {"
-	    $as_echo "          ${op_copy};"
-	    $as_echo "          part_buffer++;"
-	    $as_echo "          buffer++;"
-	    $as_echo "        } while (--count_done != 0);"
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* copy to the buffer the remaining bytes in this ${host_boundary}-bit part: */"])
+	    AS_ECHO(["        if (count_done > count) {"])
+	    AS_ECHO(["          count_done = count;"])
+	    AS_ECHO(["        }"])
+	    AS_ECHO(["        part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);"])
+	    AS_ECHO(["        count -= count_done;"])
+	    AS_ECHO(["        do {"])
+	    AS_ECHO(["          ${op_copy};"])
+	    AS_ECHO(["          part_buffer++;"])
+	    AS_ECHO(["          buffer++;"])
+	    AS_ECHO(["        } while (--count_done != 0);"])
 	fi
-	$as_echo "      }"
-	$as_echo "    }"
-
-	$as_echo ""
-	$as_echo "    /* if we still have bytes to ${op}: */"
-	$as_echo "    if (__tme_predict_false(count > 0)) {"
-	$as_echo ""
-	$as_echo "      /* we must have less than a full ${host_boundary}-bit part to ${op}: */"
-	$as_echo "      assert (count < sizeof(tme_uint${host_boundary}_t));"
+	AS_ECHO(["      }"])
+	AS_ECHO(["    }"])
+
+	AS_ECHO([""])
+	AS_ECHO(["    /* if we still have bytes to ${op}: */"])
+	AS_ECHO(["    if (__tme_predict_false(count > 0)) {"])
+	AS_ECHO([""])
+	AS_ECHO(["      /* we must have less than a full ${host_boundary}-bit part to ${op}: */"])
+	AS_ECHO(["      assert (count < sizeof(tme_uint${host_boundary}_t));"])
 	if test ${op} = write; then
-	    $as_echo ""
-	    $as_echo "      /* make a mask that clears for the data to write in the last"
-	    $as_echo "         ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary}_mask"
-	    $as_echo "        = (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE"
-	    $as_echo "           ? _tme_memory_type_mask(tme_uint${host_boundary}_t, << (count * 8))"
-	    $as_echo "           : _tme_memory_type_mask(tme_uint${host_boundary}_t, >> (count * 8)));"
-	    $as_echo ""
-	    $as_echo "      /* copy from the buffer the bytes to write in the last"
-	    $as_echo "         ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary}_buffer = 0;"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* make a mask that clears for the data to write in the last"])
+	    AS_ECHO(["         ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary}_mask"])
+	    AS_ECHO(["        = (TME_ENDIAN_NATIVE == TME_ENDIAN_LITTLE"])
+	    AS_ECHO(["           ? _tme_memory_type_mask(tme_uint${host_boundary}_t, << (count * 8))"])
+	    AS_ECHO(["           : _tme_memory_type_mask(tme_uint${host_boundary}_t, >> (count * 8)));"])
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* copy from the buffer the bytes to write in the last"])
+	    AS_ECHO(["         ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary}_buffer = 0;"])
 	else
-	    $as_echo ""
-	    $as_echo "      /* read the last ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary}_buffer = ${op_part_read};"
-	    $as_echo ""
-	    $as_echo "      /* copy to the buffer the bytes to read in the first"
-	    $as_echo "         ${host_boundary}-bit memory part: */"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* read the last ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary}_buffer = ${op_part_read};"])
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* copy to the buffer the bytes to read in the first"])
+	    AS_ECHO(["         ${host_boundary}-bit memory part: */"])
 	fi
-	$as_echo "      part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);"
-	$as_echo "      count_done = count;"
-	$as_echo "      do {"
-	$as_echo "        ${op_copy};"
-	$as_echo "        part_buffer++;"
-	$as_echo "        buffer++;"
-	$as_echo "      } while (--count_done != 0);"
+	AS_ECHO(["      part_buffer = ((${op_const_mem}tme_uint8_t *) &part${host_boundary}_buffer);"])
+	AS_ECHO(["      count_done = count;"])
+	AS_ECHO(["      do {"])
+	AS_ECHO(["        ${op_copy};"])
+	AS_ECHO(["        part_buffer++;"])
+	AS_ECHO(["        buffer++;"])
+	AS_ECHO(["      } while (--count_done != 0);"])
 	if test ${op} = write; then
-	    $as_echo ""
-	    $as_echo "      /* compare-and-exchange the last ${host_boundary}-bit memory part: */"
-	    $as_echo "      part${host_boundary} = ${op_part_read};"
-	    $as_echo "      do {"
-	    $as_echo "        part${host_boundary}_cmp = part${host_boundary};"
-	    $as_echo "        part${host_boundary} = (part${host_boundary} & part${host_boundary}_mask) | part${host_boundary}_buffer;"
-	    $as_echo "        part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"
-	    $as_echo "      } while (part${host_boundary} != part${host_boundary}_cmp);"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* compare-and-exchange the last ${host_boundary}-bit memory part: */"])
+	    AS_ECHO(["      part${host_boundary} = ${op_part_read};"])
+	    AS_ECHO(["      do {"])
+	    AS_ECHO(["        part${host_boundary}_cmp = part${host_boundary};"])
+	    AS_ECHO(["        part${host_boundary} = (part${host_boundary} & part${host_boundary}_mask) | part${host_boundary}_buffer;"])
+	    AS_ECHO(["        part${host_boundary} = tme_memory_atomic_cx${host_boundary}(parts${host_boundary}, part${host_boundary}_cmp, part${host_boundary}, rwlock, sizeof(tme_uint${host_boundary}_t));"])
+	    AS_ECHO(["      } while (part${host_boundary} != part${host_boundary}_cmp);"])
 	fi
-	$as_echo "    }"
+	AS_ECHO(["    }"])
 	
 	# close this host boundary:
 	#
-	$as_echo ""
-	$as_echo "  }"
+	AS_ECHO([""])
+	AS_ECHO(["  }"])
 	if test `expr ${host_boundary} \>= ${size_ifdef}` = 1; then
-	    $as_echo ""
-	    $as_echo "#endif /* TME_HAVE_INT${host_boundary}_T */"
+	    AS_ECHO([""])
+	    AS_ECHO(["#endif /* TME_HAVE_INT${host_boundary}_T */"])
 	fi
 
 	# advance:
@@ -855,7 +855,7 @@ for op in read write; do
 	host_boundary=`expr ${host_boundary} / 2`
     done
 
-    $as_echo "}"
+    AS_ECHO(["}"])
 done
 
 # permute for the different sizes:
@@ -863,8 +863,8 @@ done
 for size in ${sizes}; do
 
     if test `expr ${size} \>= ${size_ifdef}` = 1; then
-	$as_echo ""
-	$as_echo "#ifdef TME_HAVE_INT${size}_T"
+	AS_ECHO([""])
+	AS_ECHO(["#ifdef TME_HAVE_INT${size}_T"])
     fi
 
     # permute for the different types of memory read and write macros.
@@ -936,29 +936,29 @@ for size in ${sizes}; do
 
 	    # start the macro:
 	    #
-	    $as_echo ""
-	    $as_echo "/* the default ${size}-bit memory ${type_user} ${op} macro: */"
-	    $as_echo "#define tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min${type_bus_boundary}) \\"
-	    $as_echo "${op_open}" | tr '@' '\n'
+	    AS_ECHO([""])
+	    AS_ECHO(["/* the default ${size}-bit memory ${type_user} ${op} macro: */"])
+	    AS_ECHO(["#define tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min${type_bus_boundary}) \\"])
+	    AS_ECHO(["${op_open}"]) | tr '@' '\n'
 
 	    # dispatch on the macro type:
 	    #
 	    case ${type_user} in
 
 	    plain)
-		$as_echo "${op_indent0}/* if we know at compile time that the memory is aligned \\"
-		$as_echo "${op_indent0}   enough to ${op} directly, do the single direct ${op}. \\"
-		$as_echo "${op_indent0}\\"
-		$as_echo "${op_indent0}   otherwise, if we know at compile time that the memory \\"
-		$as_echo "${op_indent0}   is less aligned than the smallest acceptable parts size, \\"
-		$as_echo "${op_indent0}   test if the memory is aligned enough to ${op} directly, \\"
-		$as_echo "${op_indent0}   and do the single direct ${op} if it is: */ \\"
-		$as_echo "${op_indent0}(__tme_predict_true((_TME_ALIGNOF_INT${size}_T == 1 \\"
-		$as_echo "${op_indent0}                     || (align_min) >= _TME_ALIGNOF_INT${size}_T) \\"
-		$as_echo "${op_indent0}                    || ((align_min) < TME_MEMORY_ALIGNMENT_ACCEPT(tme_uint${size}_t) \\"
-		$as_echo "${op_indent0}                        && _tme_memory_address_test(mem, _TME_ALIGNOF_INT${size}_T - 1, align_min) == 0))) \\"
-		$as_echo "${op_then}"
-		$as_echo "${op_indent2}_tme_memory_${op}(tme_uint${size}_t, tme_uint${size}_t, mem, 0${op_x})${op_semi} \\"
+		AS_ECHO(["${op_indent0}/* if we know at compile time that the memory is aligned \\"])
+		AS_ECHO(["${op_indent0}   enough to ${op} directly, do the single direct ${op}. \\"])
+		AS_ECHO(["${op_indent0}\\"])
+		AS_ECHO(["${op_indent0}   otherwise, if we know at compile time that the memory \\"])
+		AS_ECHO(["${op_indent0}   is less aligned than the smallest acceptable parts size, \\"])
+		AS_ECHO(["${op_indent0}   test if the memory is aligned enough to ${op} directly, \\"])
+		AS_ECHO(["${op_indent0}   and do the single direct ${op} if it is: */ \\"])
+		AS_ECHO(["${op_indent0}(__tme_predict_true((_TME_ALIGNOF_INT${size}_T == 1 \\"])
+		AS_ECHO(["${op_indent0}                     || (align_min) >= _TME_ALIGNOF_INT${size}_T) \\"])
+		AS_ECHO(["${op_indent0}                    || ((align_min) < TME_MEMORY_ALIGNMENT_ACCEPT(tme_uint${size}_t) \\"])
+		AS_ECHO(["${op_indent0}                        && _tme_memory_address_test(mem, _TME_ALIGNOF_INT${size}_T - 1, align_min) == 0))) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO(["${op_indent2}_tme_memory_${op}(tme_uint${size}_t, tme_uint${size}_t, mem, 0${op_x})${op_semi} \\"])
 
 		# loop over the possible part sizes:
 		#
@@ -975,7 +975,7 @@ for size in ${sizes}; do
 
 			# we will just access all parts of this size:
 			#
-			$as_echo "${op_else}" | tr '@' '\n'
+			AS_ECHO(["${op_else}"]) | tr '@' '\n'
 
 		    # otherwise, this is not the last possible part
 		    # size:
@@ -989,10 +989,10 @@ for size in ${sizes}; do
 			# size, we will just access all parts of this
 			# size:
 			#
-			$as_echo "${op_else_if}" | tr '@' '\n'
-			$as_echo "${op_indent1}((TME_MEMORY_ALIGNMENT_ACCEPT(tme_uint${size}_t) <= sizeof(tme_uint${size_part}_t)) \\"
-			$as_echo "${op_indent1} && ((align_min) <= sizeof(tme_uint${size_part}_t))) \\"
-			$as_echo "${op_then}"
+			AS_ECHO(["${op_else_if}"]) | tr '@' '\n'
+			AS_ECHO(["${op_indent1}((TME_MEMORY_ALIGNMENT_ACCEPT(tme_uint${size}_t) <= sizeof(tme_uint${size_part}_t)) \\"])
+			AS_ECHO(["${op_indent1} && ((align_min) <= sizeof(tme_uint${size_part}_t))) \\"])
+			AS_ECHO(["${op_then}"])
 		    fi
 
 		    # we always emit one set of partial accesses, all
@@ -1013,13 +1013,13 @@ for size in ${sizes}; do
 
 			    # emit one partial transfer:
 			    #
-			    $as_echo_n "${op_indent2}"
+			    AS_ECHO_N(["${op_indent2}"])
 			    op_delim=${op_semi}
 			    if test ${op} = read; then
-				if test ${size_done} = 0; then $as_echo_n '('; else $as_echo_n ' | '; fi
+				if test ${size_done} = 0; then AS_ECHO_N(['(']); else AS_ECHO_N([' | ']); fi
 				if test `expr ${size_done} + ${size_now}` = ${size}; then op_delim=')'; fi
 			    fi
-			    $as_echo "_tme_memory${type}_${op}(tme_uint${size}_t, tme_uint${size_now}_t, mem, (${size_done} / 8)${op_x})${op_delim} \\"
+			    AS_ECHO(["_tme_memory${type}_${op}(tme_uint${size}_t, tme_uint${size_now}_t, mem, (${size_done} / 8)${op_x})${op_delim} \\"])
 
 			    # advance:
 			    #
@@ -1045,112 +1045,112 @@ for size in ${sizes}; do
 			if test ${size_part} = ${size}; then
 			    break
 			fi
-			$as_echo "${op_else_if}" | tr '@' '\n'
-			$as_echo "${op_indent1}(_tme_memory_address_test(mem, sizeof(tme_uint${size_now}_t), align_min) != 0) \\"
-			$as_echo "${op_then}"
+			AS_ECHO(["${op_else_if}"]) | tr '@' '\n'
+			AS_ECHO(["${op_indent1}(_tme_memory_address_test(mem, sizeof(tme_uint${size_now}_t), align_min) != 0) \\"])
+			AS_ECHO(["${op_then}"])
 		    done
 		done
 		;;
 
 	    atomic)
-		$as_echo "${op_indent0}/* if threads are cooperative, do a plain ${op}: */ \\"
-		$as_echo "${op_indent0}(tme_thread_cooperative()) \\"
-		$as_echo "${op_then}"
-		$as_echo_n "${op_indent2}tme_memory_${op}${size}("
+		AS_ECHO(["${op_indent0}/* if threads are cooperative, do a plain ${op}: */ \\"])
+		AS_ECHO(["${op_indent0}(tme_thread_cooperative()) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO_N(["${op_indent2}tme_memory_${op}${size}("])
 		# this strips off the tme_shared qualifier:
 		#
 		if test ${op} = read; then
-		    $as_echo_n "(_tme_const tme_uint${size}_t *) _tme_audit_type(mem, tme_uint${size}_t *)"
+		    AS_ECHO_N(["(_tme_const tme_uint${size}_t *) _tme_audit_type(mem, tme_uint${size}_t *)"])
 		else
-		    $as_echo_n "(tme_uint${size}_t *) _tme_cast_pointer_shared(tme_uint${size}_t *, tme_uint${size}_t *, mem)"
+		    AS_ECHO_N(["(tme_uint${size}_t *) _tme_cast_pointer_shared(tme_uint${size}_t *, tme_uint${size}_t *, mem)"])
 		fi
-		$as_echo "${op_x}, align_min)${op_semi} \\"
-
-		$as_echo "${op_indent1}/* otherwise, if we aren't locking for all memory accesses, and we can \\"
-		$as_echo "${op_indent1}   make direct ${size}-bit accesses, and this memory is aligned \\"
-		$as_echo "${op_indent1}   enough to make a single direct atomic access, do the single \\"
-		$as_echo "${op_indent1}   direct atomic ${op}: */ \\"
-		$as_echo "${op_else_if}" | tr '@' '\n'
-		$as_echo "${op_indent1}(__tme_predict_true(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) != 0 \\"
-		$as_echo "${op_indent1}                    && TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) != 0 \\"
-		$as_echo "${op_indent1}                    && _tme_memory_address_test(mem, TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) - 1, align_min) == 0)) \\"
-		$as_echo "${op_then}"
-		$as_echo "${op_indent2}(*_tme_audit_type(mem, tme_uint${size}_t *)) \\"
+		AS_ECHO(["${op_x}, align_min)${op_semi} \\"])
+
+		AS_ECHO(["${op_indent1}/* otherwise, if we aren't locking for all memory accesses, and we can \\"])
+		AS_ECHO(["${op_indent1}   make direct ${size}-bit accesses, and this memory is aligned \\"])
+		AS_ECHO(["${op_indent1}   enough to make a single direct atomic access, do the single \\"])
+		AS_ECHO(["${op_indent1}   direct atomic ${op}: */ \\"])
+		AS_ECHO(["${op_else_if}"]) | tr '@' '\n'
+		AS_ECHO(["${op_indent1}(__tme_predict_true(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) != 0 \\"])
+		AS_ECHO(["${op_indent1}                    && TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) != 0 \\"])
+		AS_ECHO(["${op_indent1}                    && _tme_memory_address_test(mem, TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) - 1, align_min) == 0)) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO(["${op_indent2}(*_tme_audit_type(mem, tme_uint${size}_t *)) \\"])
 		if test ${op} = write; then
-		    $as_echo "${op_indent2}  = (x); \\"
+		    AS_ECHO(["${op_indent2}  = (x); \\"])
 		fi
-		$as_echo "${op_indent1}/* otherwise, we must do a slow indirect atomic ${op}: */ \\"
-		$as_echo "${op_else}" | tr '@' '\n'
-		$as_echo "${op_indent2}tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min)${op_semi} \\"
+		AS_ECHO(["${op_indent1}/* otherwise, we must do a slow indirect atomic ${op}: */ \\"])
+		AS_ECHO(["${op_else}"]) | tr '@' '\n'
+		AS_ECHO(["${op_indent2}tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min)${op_semi} \\"])
 		;;
 
 	    bus)
-		$as_echo "${op_indent0}/* if threads are cooperative, do a plain ${op}: */ \\"
-		$as_echo "${op_indent0}(tme_thread_cooperative()) \\"
-		$as_echo "${op_then}"
-		$as_echo_n "${op_indent2}tme_memory_${op}${size}("
+		AS_ECHO(["${op_indent0}/* if threads are cooperative, do a plain ${op}: */ \\"])
+		AS_ECHO(["${op_indent0}(tme_thread_cooperative()) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO_N(["${op_indent2}tme_memory_${op}${size}("])
 		# this strips off the tme_shared qualifier:
 		#
 		if test ${op} = read; then
-		    $as_echo_n "(_tme_const tme_uint${size}_t *) _tme_audit_type(mem, tme_uint${size}_t *)"
+		    AS_ECHO_N(["(_tme_const tme_uint${size}_t *) _tme_audit_type(mem, tme_uint${size}_t *)"])
 		else
-		    $as_echo_n "(tme_uint${size}_t *) _tme_cast_pointer_shared(tme_uint${size}_t *, tme_uint${size}_t *, mem)"
+		    AS_ECHO_N(["(tme_uint${size}_t *) _tme_cast_pointer_shared(tme_uint${size}_t *, tme_uint${size}_t *, mem)"])
 		fi
-		$as_echo "${op_x}, align_min)${op_semi} \\"
-
-		$as_echo "${op_indent1}/* otherwise, if we aren't locking for all memory accesses, the \\"
-		$as_echo "${op_indent1}   host supports misaligned ${size}-bit accesses, the host's bus \\"
-		$as_echo "${op_indent1}   boundary is greater than or equal to the emulated bus \\"
-		$as_echo "${op_indent1}   boundary, and this memory is aligned enough, do a single \\"
-		$as_echo "${op_indent1}   direct bus ${op}: */ \\"
-		$as_echo "${op_else_if}" | tr '@' '\n'
-		$as_echo "${op_indent1}(__tme_predict_true(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) != 0 \\"
-		$as_echo "${op_indent1}                    && _TME_ALIGNOF_INT${size}_T < sizeof(tme_uint${size}_t) \\"
-		$as_echo "${op_indent1}                    && TME_MEMORY_BUS_BOUNDARY >= (bus_boundary) \\"
-		$as_echo "${op_indent1}                    && _tme_memory_address_test(mem, _TME_ALIGNOF_INT${size}_T - 1, align_min) == 0)) \\"
-		$as_echo "${op_then}"
-		$as_echo "${op_indent2}(*_tme_audit_type(mem, tme_uint${size}_t *)) \\"
+		AS_ECHO(["${op_x}, align_min)${op_semi} \\"])
+
+		AS_ECHO(["${op_indent1}/* otherwise, if we aren't locking for all memory accesses, the \\"])
+		AS_ECHO(["${op_indent1}   host supports misaligned ${size}-bit accesses, the host's bus \\"])
+		AS_ECHO(["${op_indent1}   boundary is greater than or equal to the emulated bus \\"])
+		AS_ECHO(["${op_indent1}   boundary, and this memory is aligned enough, do a single \\"])
+		AS_ECHO(["${op_indent1}   direct bus ${op}: */ \\"])
+		AS_ECHO(["${op_else_if}"]) | tr '@' '\n'
+		AS_ECHO(["${op_indent1}(__tme_predict_true(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) != 0 \\"])
+		AS_ECHO(["${op_indent1}                    && _TME_ALIGNOF_INT${size}_T < sizeof(tme_uint${size}_t) \\"])
+		AS_ECHO(["${op_indent1}                    && TME_MEMORY_BUS_BOUNDARY >= (bus_boundary) \\"])
+		AS_ECHO(["${op_indent1}                    && _tme_memory_address_test(mem, _TME_ALIGNOF_INT${size}_T - 1, align_min) == 0)) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO(["${op_indent2}(*_tme_audit_type(mem, tme_uint${size}_t *)) \\"])
 		if test ${op} = write; then
-		    $as_echo "${op_indent2}  = (x); \\"
+		    AS_ECHO(["${op_indent2}  = (x); \\"])
 		fi
 
-		$as_echo "${op_indent1}/* otherwise, if we're locking for all memory accesses, or \\"
-		$as_echo "${op_indent1}   if this memory must cross at least one host bus boundary \\"
-		$as_echo "${op_indent1}   and the host bus boundary is less than the emulated bus \\"
-		$as_echo "${op_indent1}   boundary, do a slow indirect atomic ${op}: */ \\"
-		$as_echo "${op_else_if}" | tr '@' '\n'
-		$as_echo "${op_indent1}(__tme_predict_false(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0 \\"
-		$as_echo "${op_indent1}                     || (sizeof(tme_uint${size}_t) > TME_MEMORY_BUS_BOUNDARY \\"
-		$as_echo "${op_indent1}                         && TME_MEMORY_BUS_BOUNDARY < (bus_boundary)))) \\"
-		$as_echo "${op_then}"
-		$as_echo "${op_indent2}tme_memory_atomic_${op}${size}(mem${op_x}, lock, align_min)${op_semi} \\"
-
-		$as_echo "${op_indent1}/* otherwise, if the memory is not larger than the emulated \\"
-		$as_echo "${op_indent1}   bus boundary, or if size-alignment would mean an atomic \\"
-		$as_echo "${op_indent1}   host access and it is size-aligned, do a single atomic \\"
-		$as_echo "${op_indent1}   ${op}, which may be direct or slow: */ \\"
-		$as_echo "${op_else_if}" | tr '@' '\n'
-		$as_echo "${op_indent1}(__tme_predict_true((sizeof(tme_uint${size}_t) <= (bus_boundary) \\"
-		$as_echo "${op_indent1}                     || (TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) != 0 \\"
-		$as_echo "${op_indent1}                         && TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) <= sizeof(tme_uint${size}_t))) \\"
-		$as_echo "${op_indent1}                    && _tme_memory_address_test(mem, sizeof(tme_uint${size}_t) - 1, align_min) == 0)) \\"
-		$as_echo "${op_then}"
-		$as_echo "${op_indent2}tme_memory_atomic_${op}${size}(mem${op_x}, lock, sizeof(tme_uint${size}_t))${op_semi} \\"
-		$as_echo "${op_indent1}/* otherwise, we must do a slow bus ${op}: */ \\"
-		$as_echo "${op_else}" | tr '@' '\n'
-		$as_echo "${op_indent2}tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min, bus_boundary)${op_semi} \\"
+		AS_ECHO(["${op_indent1}/* otherwise, if we're locking for all memory accesses, or \\"])
+		AS_ECHO(["${op_indent1}   if this memory must cross at least one host bus boundary \\"])
+		AS_ECHO(["${op_indent1}   and the host bus boundary is less than the emulated bus \\"])
+		AS_ECHO(["${op_indent1}   boundary, do a slow indirect atomic ${op}: */ \\"])
+		AS_ECHO(["${op_else_if}"]) | tr '@' '\n'
+		AS_ECHO(["${op_indent1}(__tme_predict_false(TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0 \\"])
+		AS_ECHO(["${op_indent1}                     || (sizeof(tme_uint${size}_t) > TME_MEMORY_BUS_BOUNDARY \\"])
+		AS_ECHO(["${op_indent1}                         && TME_MEMORY_BUS_BOUNDARY < (bus_boundary)))) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO(["${op_indent2}tme_memory_atomic_${op}${size}(mem${op_x}, lock, align_min)${op_semi} \\"])
+
+		AS_ECHO(["${op_indent1}/* otherwise, if the memory is not larger than the emulated \\"])
+		AS_ECHO(["${op_indent1}   bus boundary, or if size-alignment would mean an atomic \\"])
+		AS_ECHO(["${op_indent1}   host access and it is size-aligned, do a single atomic \\"])
+		AS_ECHO(["${op_indent1}   ${op}, which may be direct or slow: */ \\"])
+		AS_ECHO(["${op_else_if}"]) | tr '@' '\n'
+		AS_ECHO(["${op_indent1}(__tme_predict_true((sizeof(tme_uint${size}_t) <= (bus_boundary) \\"])
+		AS_ECHO(["${op_indent1}                     || (TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) != 0 \\"])
+		AS_ECHO(["${op_indent1}                         && TME_MEMORY_ALIGNMENT_ATOMIC(tme_uint${size}_t) <= sizeof(tme_uint${size}_t))) \\"])
+		AS_ECHO(["${op_indent1}                    && _tme_memory_address_test(mem, sizeof(tme_uint${size}_t) - 1, align_min) == 0)) \\"])
+		AS_ECHO(["${op_then}"])
+		AS_ECHO(["${op_indent2}tme_memory_atomic_${op}${size}(mem${op_x}, lock, sizeof(tme_uint${size}_t))${op_semi} \\"])
+		AS_ECHO(["${op_indent1}/* otherwise, we must do a slow bus ${op}: */ \\"])
+		AS_ECHO(["${op_else}"]) | tr '@' '\n'
+		AS_ECHO(["${op_indent2}tme_memory${type}_${op}${size}(mem${op_x}${type_lock}, align_min, bus_boundary)${op_semi} \\"])
 		;;
 
 	    esac
 
 	    # close this macro:
 	    #
-	    $as_echo "${op_close}" | tr '@' '\n'
+	    AS_ECHO(["${op_close}"]) | tr '@' '\n'
 	done
     done
 
-    $as_echo ""
-    $as_echo "/* the ${size}-bit atomic operations: */"
+    AS_ECHO([""])
+    AS_ECHO(["/* the ${size}-bit atomic operations: */"])
 
     # the atomic operations.  NB that cx, read, and write are
     # deliberately at the end and in that order, to allow all earlier
@@ -1205,142 +1205,142 @@ for size in ${sizes}; do
 	# if we're making the header, just emit a prototype:
 	#
 	if $header; then
-	    $as_echo "${op_rval} tme_memory_atomic_${op}${size} _TME_P((${op_const}tme_shared tme_uint${size}_t *${op_proto_operand}, tme_rwlock_t *, unsigned int));"
+	    AS_ECHO(["${op_rval} tme_memory_atomic_${op}${size} _TME_P((${op_const}tme_shared tme_uint${size}_t *${op_proto_operand}, tme_rwlock_t *, unsigned int));"])
 	    continue
 	fi
 
-	$as_echo ""
-	$as_echo "/* undefine any macro version of tme_memory_atomic_${op}${size}: */"
-	$as_echo "#undef tme_memory_atomic_${op}${size}"
-	$as_echo ""
-	$as_echo "/* the ${size}-bit atomic ${op} function: */"
-	$as_echo "${op_rval}"
-	$as_echo "tme_memory_atomic_${op}${size}(${op_const}tme_shared tme_uint${size}_t *memory,"
+	AS_ECHO([""])
+	AS_ECHO(["/* undefine any macro version of tme_memory_atomic_${op}${size}: */"])
+	AS_ECHO(["#undef tme_memory_atomic_${op}${size}"])
+	AS_ECHO([""])
+	AS_ECHO(["/* the ${size}-bit atomic ${op} function: */"])
+	AS_ECHO(["${op_rval}"])
+	AS_ECHO(["tme_memory_atomic_${op}${size}(${op_const}tme_shared tme_uint${size}_t *memory,"])
 	if test ${op} = cx; then
-	    $as_echo "                        tme_uint${size}_t value_cmp,"
+	    AS_ECHO(["                        tme_uint${size}_t value_cmp,"])
 	fi
 	if test "x${op_proto_operand}" != x; then
-	    $as_echo "                        tme_uint${size}_t ${op_operand},"
+	    AS_ECHO(["                        tme_uint${size}_t ${op_operand},"])
 	fi
-	$as_echo "                        tme_rwlock_t *rwlock,"
-	$as_echo "                        unsigned int align_min)"
-	$as_echo "{"
+	AS_ECHO(["                        tme_rwlock_t *rwlock,"])
+	AS_ECHO(["                        unsigned int align_min)"])
+	AS_ECHO(["{"])
 	if test ${op} != write; then
-	    $as_echo "  tme_uint${size}_t value_read;"
+	    AS_ECHO(["  tme_uint${size}_t value_read;"])
 	fi
 	if test "x${op_operation}" != x; then
-	    $as_echo "  tme_uint${size}_t value_written;"
+	    AS_ECHO(["  tme_uint${size}_t value_written;"])
 	fi
 	if test ${op} = read || test ${op} = write || test ${op} = cx; then :; else
-	    $as_echo "  tme_uint${size}_t value_read_verify;"
+	    AS_ECHO(["  tme_uint${size}_t value_read_verify;"])
 	fi
-	$as_echo ""
-	$as_echo "  /* if we can't make direct accesses at all, all atomic"
-	$as_echo "     accesses must be done under lock.  (when threads are"
-	$as_echo "     cooperative the actual locking isn't needed): */"
-	$as_echo "  if (TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0) {"
-	$as_echo "    if (!tme_thread_cooperative()) {"
+	AS_ECHO([""])
+	AS_ECHO(["  /* if we can't make direct accesses at all, all atomic"])
+	AS_ECHO(["     accesses must be done under lock.  (when threads are"])
+	AS_ECHO(["     cooperative the actual locking isn't needed): */"])
+	AS_ECHO(["  if (TME_MEMORY_ALIGNMENT_ATOMIC(TME_MEMORY_TYPE_COMMON) == 0) {"])
+	AS_ECHO(["    if (!tme_thread_cooperative()) {"])
 	if test ${op} = read; then
-	    $as_echo "      tme_rwlock_rdlock(rwlock);"
+	    AS_ECHO(["      tme_rwlock_rdlock(rwlock);"])
 	else
-	    $as_echo "      tme_rwlock_wrlock(rwlock);"
+	    AS_ECHO(["      tme_rwlock_wrlock(rwlock);"])
 	fi
-	$as_echo "    }"
+	AS_ECHO(["    }"])
 	if test ${op} != write; then
-	    $as_echo "    value_read = tme_memory_read${size}((_tme_const tme_uint${size}_t *) memory, align_min);"
+	    AS_ECHO(["    value_read = tme_memory_read${size}((_tme_const tme_uint${size}_t *) memory, align_min);"])
 	fi
 	if test ${op} = cx; then
-	    $as_echo "    if (value_read == value_cmp) {"
+	    AS_ECHO(["    if (value_read == value_cmp) {"])
 	fi
 	if test "x${op_operation}" != x; then
-	    $as_echo "    value_written = ${op_operation};"
+	    AS_ECHO(["    value_written = ${op_operation};"])
 	fi
 	if test ${op} != read; then
-	    $as_echo "${op_indent}    tme_memory_write${size}((tme_uint${size}_t *) memory, value_written, align_min);"
+	    AS_ECHO(["${op_indent}    tme_memory_write${size}((tme_uint${size}_t *) memory, value_written, align_min);"])
 	fi
 	if test "x${op_indent}" != x; then
-	    $as_echo "    }"
+	    AS_ECHO(["    }"])
 	fi
-	$as_echo "    if (!tme_thread_cooperative()) {"
+	AS_ECHO(["    if (!tme_thread_cooperative()) {"])
 	if test ${op} = read; then
-	    $as_echo "      tme_rwlock_rdunlock(rwlock);"
+	    AS_ECHO(["      tme_rwlock_rdunlock(rwlock);"])
 	else
-	    $as_echo "      tme_rwlock_wrunlock(rwlock);"
+	    AS_ECHO(["      tme_rwlock_wrunlock(rwlock);"])
 	fi
-	$as_echo "    }"
-	$as_echo "  }"
-	$as_echo ""
-	$as_echo "  /* otherwise, threads are not cooperative and this host CPU"
-	$as_echo "     can make atomic accesses to at least the most common memory"
-	$as_echo "     size."
-	$as_echo ""
-	$as_echo "     in that case, the only reason this function should get"
-	$as_echo "     called is if the host CPU can't do an atomic ${size}-bit"
-	$as_echo "     ${op} at all, or if it can't do it at this alignment."
+	AS_ECHO(["    }"])
+	AS_ECHO(["  }"])
+	AS_ECHO([""])
+	AS_ECHO(["  /* otherwise, threads are not cooperative and this host CPU"])
+	AS_ECHO(["     can make atomic accesses to at least the most common memory"])
+	AS_ECHO(["     size."])
+	AS_ECHO([""])
+	AS_ECHO(["     in that case, the only reason this function should get"])
+	AS_ECHO(["     called is if the host CPU can't do an atomic ${size}-bit"])
+	AS_ECHO(["     ${op} at all, or if it can't do it at this alignment."])
 	if test ${op} = read || test ${op} = write || test ${op} = cx; then
-	    $as_echo ""
-	    $as_echo "     we assume that these problematic atomic ${op}s are rare,"
-	    $as_echo "     and to emulate them we simply stop all other threads while"
-	    $as_echo "     doing the ${op}: */"
-	    $as_echo "  else {"
-	    $as_echo "    tme_thread_suspend_others();"
+	    AS_ECHO([""])
+	    AS_ECHO(["     we assume that these problematic atomic ${op}s are rare,"])
+	    AS_ECHO(["     and to emulate them we simply stop all other threads while"])
+	    AS_ECHO(["     doing the ${op}: */"])
+	    AS_ECHO(["  else {"])
+	    AS_ECHO(["    tme_thread_suspend_others();"])
 	    if test ${op} != write; then
-		$as_echo "    value_read = tme_memory_read${size}((_tme_const tme_uint${size}_t *) memory, align_min);"
+		AS_ECHO(["    value_read = tme_memory_read${size}((_tme_const tme_uint${size}_t *) memory, align_min);"])
 	    fi
 	    if test ${op} = cx; then
-		$as_echo "    if (value_read == value_cmp) {"
+		AS_ECHO(["    if (value_read == value_cmp) {"])
 	    fi
 	    if test ${op} != read; then
-		$as_echo "${op_indent}    tme_memory_write${size}((tme_uint${size}_t *) memory, value_written, align_min);"
+		AS_ECHO(["${op_indent}    tme_memory_write${size}((tme_uint${size}_t *) memory, value_written, align_min);"])
 	    fi
 	    if test "x${op_indent}" != x; then
-		$as_echo "    }"
+		AS_ECHO(["    }"])
 	    fi
-	    $as_echo "    tme_thread_resume_others();"
-	    $as_echo "  }"
+	    AS_ECHO(["    tme_thread_resume_others();"])
+	    AS_ECHO(["  }"])
 	else
-	    $as_echo ""
-	    $as_echo "     we emulate the atomic ${size}-bit ${op} with a compare-and-exchange: */"
-	    $as_echo "  else {"
-	    $as_echo ""
-	    $as_echo "    /* do an atomic read of the memory: */"
-	    $as_echo "    value_read = tme_memory_atomic_read${size}(memory, rwlock, align_min);"
-	    $as_echo ""
-	    $as_echo "    /* spin the ${op} in a compare-and-exchange loop: */"
-	    $as_echo "    for (;;) {"
+	    AS_ECHO([""])
+	    AS_ECHO(["     we emulate the atomic ${size}-bit ${op} with a compare-and-exchange: */"])
+	    AS_ECHO(["  else {"])
+	    AS_ECHO([""])
+	    AS_ECHO(["    /* do an atomic read of the memory: */"])
+	    AS_ECHO(["    value_read = tme_memory_atomic_read${size}(memory, rwlock, align_min);"])
+	    AS_ECHO([""])
+	    AS_ECHO(["    /* spin the ${op} in a compare-and-exchange loop: */"])
+	    AS_ECHO(["    for (;;) {"])
 	    if test "x${op_operation}" != x; then
-		$as_echo ""
-		$as_echo "      /* make the value to write: */"
-		$as_echo "      value_written = ${op_operation};"
+		AS_ECHO([""])
+		AS_ECHO(["      /* make the value to write: */"])
+		AS_ECHO(["      value_written = ${op_operation};"])
 	    fi
-	    $as_echo ""
-	    $as_echo "      /* try the compare-and-exchange: */"
-	    $as_echo "      value_read_verify = tme_memory_atomic_cx${size}(memory, value_read, value_written, rwlock, align_min);"
-	    $as_echo ""
-	    $as_echo "      /* if the compare-and-exchange failed: */"
-	    $as_echo "      if (__tme_predict_false(value_read_verify != value_read)) {"
-	    $as_echo ""
-	    $as_echo "        /* loop with the new value read from the memory: */"
-	    $as_echo "        value_read = value_read_verify;"
-	    $as_echo "        continue;"
-	    $as_echo "      }"
-	    $as_echo ""
-	    $as_echo "      /* stop now: */"
-	    $as_echo "      break;"
-	    $as_echo "    }"
-	    $as_echo "  }"
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* try the compare-and-exchange: */"])
+	    AS_ECHO(["      value_read_verify = tme_memory_atomic_cx${size}(memory, value_read, value_written, rwlock, align_min);"])
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* if the compare-and-exchange failed: */"])
+	    AS_ECHO(["      if (__tme_predict_false(value_read_verify != value_read)) {"])
+	    AS_ECHO([""])
+	    AS_ECHO(["        /* loop with the new value read from the memory: */"])
+	    AS_ECHO(["        value_read = value_read_verify;"])
+	    AS_ECHO(["        continue;"])
+	    AS_ECHO(["      }"])
+	    AS_ECHO([""])
+	    AS_ECHO(["      /* stop now: */"])
+	    AS_ECHO(["      break;"])
+	    AS_ECHO(["    }"])
+	    AS_ECHO(["  }"])
 	fi
 	if test ${op} != write; then
-	    $as_echo ""
-	    $as_echo "  /* return the value read: */"
-	    $as_echo "  return (value_read);"
+	    AS_ECHO([""])
+	    AS_ECHO(["  /* return the value read: */"])
+	    AS_ECHO(["  return (value_read);"])
 	fi
-	$as_echo "}"
+	AS_ECHO(["}"])
     done
 
     if test `expr ${size} \>= ${size_ifdef}` = 1; then
-	$as_echo ""
-	$as_echo "#endif /* TME_HAVE_INT${size}_T */"
+	AS_ECHO([""])
+	AS_ECHO(["#endif /* TME_HAVE_INT${size}_T */"])
     fi
 
 done
-- 
2.47.0

Places

File 0002-memory-auto.m4-Replace-as_echo-with-AS_ECHO.patch of Package tme

Places