Use default m4 quote character in asm files, part 3

Update x86 files.

8 files changed, 238 insertions, 238 deletions

diff --git a/x86/aes-decrypt-internal.asm b/x86/aes-decrypt-internal.asm
index ff535b6a..730ce2ed 100644
--- a/x86/aes-decrypt-internal.asm
+++ b/x86/aes-decrypt-internal.asm
@@ -1,6 +1,6 @@
 C x86/aes-decrypt-internal.asm
 
-ifelse(<
+ifelse(`
    Copyright (C) 2001, 2002, 2005, Rafael R. Sevilla, Niels Möller
    Copyright (C) 2008, 2013 Niels Möller
 
@@ -29,35 +29,35 @@ ifelse(<
    You should have received copies of the GNU General Public License and
    the GNU Lesser General Public License along with this program.  If
    not, see http://www.gnu.org/licenses/.
->)
+')
 
-include_src(<x86/aes.m4>)
+include_src(`x86/aes.m4')
 
 C Register usage:
 
 C AES state
-define(<SA>,<%eax>)
-define(<SB>,<%ebx>)
-define(<SC>,<%ecx>)
-define(<SD>,<%edx>)
+define(`SA',`%eax')
+define(`SB',`%ebx')
+define(`SC',`%ecx')
+define(`SD',`%edx')
 
 C Primary use of these registers. They're also used temporarily for other things.
-define(<T>,<%ebp>)
-define(<TMP>,<%edi>)
-define(<KEY>,<%esi>)
-
-define(<PARAM_ROUNDS>,	<40(%esp)>)
-define(<PARAM_KEYS>,	<44(%esp)>)
-define(<PARAM_TABLE>,	<48(%esp)>)
-define(<PARAM_LENGTH>,	<52(%esp)>)
-define(<PARAM_DST>,	<56(%esp)>)
-define(<PARAM_SRC>,	<60(%esp)>)
-
-define(<FRAME_KEY>,	<16(%esp)>)
-define(<FRAME_COUNT>,	<12(%esp)>)
-define(<TA>,		<8(%esp)>)
-define(<TB>,		<4(%esp)>)
-define(<TC>,		<(%esp)>)
+define(`T',`%ebp')
+define(`TMP',`%edi')
+define(`KEY',`%esi')
+
+define(`PARAM_ROUNDS',	`40(%esp)')
+define(`PARAM_KEYS',	`44(%esp)')
+define(`PARAM_TABLE',	`48(%esp)')
+define(`PARAM_LENGTH',	`52(%esp)')
+define(`PARAM_DST',	`56(%esp)')
+define(`PARAM_SRC',	`60(%esp)')
+
+define(`FRAME_KEY',	`16(%esp)')
+define(`FRAME_COUNT',	`12(%esp)')
+define(`TA',		`8(%esp)')
+define(`TB',		`4(%esp)')
+define(`TC',		`(%esp)')
 
 C The aes state is kept in %eax, %ebx, %ecx and %edx
 C
diff --git a/x86/aes-encrypt-internal.asm b/x86/aes-encrypt-internal.asm
index 934158f7..0a12b002 100644
--- a/x86/aes-encrypt-internal.asm
+++ b/x86/aes-encrypt-internal.asm
@@ -1,6 +1,6 @@
 C x86/aes-encrypt-internal.asm
 
-ifelse(<
+ifelse(`
    Copyright (C) 2001, 2002, 2005, Rafael R. Sevilla, Niels Möller
    Copyright (C) 2008, 2013 Niels Möller
 
@@ -29,35 +29,35 @@ ifelse(<
    You should have received copies of the GNU General Public License and
    the GNU Lesser General Public License along with this program.  If
    not, see http://www.gnu.org/licenses/.
->)
+')
 
-include_src(<x86/aes.m4>)
+include_src(`x86/aes.m4')
 
 C Register usage:
 
 C AES state
-define(<SA>,<%eax>)
-define(<SB>,<%ebx>)
-define(<SC>,<%ecx>)
-define(<SD>,<%edx>)
+define(`SA',`%eax')
+define(`SB',`%ebx')
+define(`SC',`%ecx')
+define(`SD',`%edx')
 
 C Primary use of these registers. They're also used temporarily for other things.
-define(<T>,<%ebp>)
-define(<TMP>,<%edi>)
-define(<KEY>,<%esi>)
-
-define(<PARAM_ROUNDS>,	<40(%esp)>)
-define(<PARAM_KEYS>,	<44(%esp)>)
-define(<PARAM_TABLE>,	<48(%esp)>)
-define(<PARAM_LENGTH>,	<52(%esp)>)
-define(<PARAM_DST>,	<56(%esp)>)
-define(<PARAM_SRC>,	<60(%esp)>)
-
-define(<FRAME_KEY>,	<16(%esp)>)
-define(<FRAME_COUNT>,	<12(%esp)>)
-define(<TA>,		<8(%esp)>)
-define(<TB>,		<4(%esp)>)
-define(<TC>,		<(%esp)>)
+define(`T',`%ebp')
+define(`TMP',`%edi')
+define(`KEY',`%esi')
+
+define(`PARAM_ROUNDS',	`40(%esp)')
+define(`PARAM_KEYS',	`44(%esp)')
+define(`PARAM_TABLE',	`48(%esp)')
+define(`PARAM_LENGTH',	`52(%esp)')
+define(`PARAM_DST',	`56(%esp)')
+define(`PARAM_SRC',	`60(%esp)')
+
+define(`FRAME_KEY',	`16(%esp)')
+define(`FRAME_COUNT',	`12(%esp)')
+define(`TA',		`8(%esp)')
+define(`TB',		`4(%esp)')
+define(`TC',		`(%esp)')
 
 C The aes state is kept in %eax, %ebx, %ecx and %edx
 C
diff --git a/x86/aes.m4 b/x86/aes.m4
index 3507e856..5d2550d0 100644
--- a/x86/aes.m4
+++ b/x86/aes.m4
@@ -3,7 +3,7 @@ dnl Loads the next block of data from src, and add the subkey pointed
 dnl to by key.
 dnl Note that x86 allows unaligned accesses.
 dnl Would it be preferable to interleave the loads and stores?
-define(<AES_LOAD>, <
+define(`AES_LOAD', `
 	movl	($5),$1
 	movl	4($5),$2
 	movl	8($5),$3
@@ -12,14 +12,14 @@ define(<AES_LOAD>, <
 	xorl	($6),$1
 	xorl	4($6),$2
 	xorl	8($6),$3
-	xorl	12($6),$4>)dnl
+	xorl	12($6),$4')dnl
 
 dnl AES_STORE(a, b, c, d, key, dst)
 dnl Adds the subkey to a, b, c, d,
 dnl and stores the result in the area pointed to by dst.
 dnl Note that x86 allows unaligned accesses.
 dnl Would it be preferable to interleave the loads and stores?
-define(<AES_STORE>, <
+define(`AES_STORE', `
 	xorl	($5),$1
 	xorl	4($5),$2
 	xorl	8($5),$3
@@ -28,58 +28,58 @@ define(<AES_STORE>, <
 	movl	$1,($6)
 	movl	$2,4($6)
 	movl	$3,8($6)
-	movl	$4,12($6)>)dnl
+	movl	$4,12($6)')dnl
 
 dnl AES_ROUND(table,a,b,c,d,out,ptr)
 dnl Computes one word of the AES round. Leaves result in $6.
-define(<AES_ROUND>, <
+define(`AES_ROUND', `
 	movzbl	LREG($2), $7
 	movl	AES_TABLE0 ($1, $7, 4),$6
 	movzbl	HREG($3), $7
 	xorl	AES_TABLE1 ($1, $7, 4),$6
 	movl	$4,$7
-	shrl	<$>16,$7
-	andl	<$>0xff,$7
+	shrl	`$'16,$7
+	andl	`$'0xff,$7
 	xorl	AES_TABLE2 ($1, $7, 4),$6
 	movl	$5,$7
-	shrl	<$>24,$7
-	xorl	AES_TABLE3 ($1, $7, 4),$6>)dnl
+	shrl	`$'24,$7
+	xorl	AES_TABLE3 ($1, $7, 4),$6')dnl
 
 dnl AES_FINAL_ROUND(a, b, c, d, table, out, tmp)
 dnl Computes one word of the final round.
 dnl Note that we have to quote $ in constants.
-define(<AES_FINAL_ROUND>, <
+define(`AES_FINAL_ROUND', `
 	movzbl	LREG($1),$6
 	movzbl	($5, $6), $6
 	movl	$2,$7
-	andl	<$>0x0000ff00,$7
+	andl	`$'0x0000ff00,$7
 	orl	$7, $6
 	movl	$3,$7
-	andl	<$>0x00ff0000,$7
+	andl	`$'0x00ff0000,$7
 	orl	$7, $6
 	movl	$4,$7
-	andl	<$>0xff000000,$7
+	andl	`$'0xff000000,$7
 	orl	$7, $6
-	roll	<$>8, $6>)dnl
+	roll	`$'8, $6')dnl
 
 dnl AES_SUBST_BYTE(A, B, C, D, table, ptr)
 dnl Substitutes the least significant byte of
 dnl each of eax, ebx, ecx and edx, and also rotates
 dnl the words one byte to the left.
 dnl Uses that AES_SBOX == 0
-define(<AES_SUBST_BYTE>, <
+define(`AES_SUBST_BYTE', `
 	movzbl  LREG($1),$6
 	movb	($5, $6),LREG($1)
-	roll	<$>8,$1
+	roll	`$'8,$1
 
 	movzbl  LREG($2),$6
 	movb	($5, $6),LREG($2)
-	roll	<$>8,$2
+	roll	`$'8,$2
 
 	movzbl  LREG($3),$6
 	movb	($5, $6),LREG($3)
-	roll	<$>8,$3
+	roll	`$'8,$3
 
 	movzbl  LREG($4),$6
 	movb	($5, $6),LREG($4)
-	roll	<$>8,$4>)dnl
+	roll	`$'8,$4')dnl
diff --git a/x86/arcfour-crypt.asm b/x86/arcfour-crypt.asm
index df3fe869..e03df8e9 100644
--- a/x86/arcfour-crypt.asm
+++ b/x86/arcfour-crypt.asm
@@ -1,6 +1,6 @@
 C x86/arcfour-crypt.asm
 
-ifelse(<
+ifelse(`
    Copyright (C) 2004, Niels Möller
 
    This file is part of GNU Nettle.
@@ -28,7 +28,7 @@ ifelse(<
    You should have received copies of the GNU General Public License and
    the GNU Lesser General Public License along with this program.  If
    not, see http://www.gnu.org/licenses/.
->)
+')
 
 	.file "arcfour-crypt.asm"
 
diff --git a/x86/camellia-crypt-internal.asm b/x86/camellia-crypt-internal.asm
index ce8c57f0..395f561d 100644
--- a/x86/camellia-crypt-internal.asm
+++ b/x86/camellia-crypt-internal.asm
@@ -1,6 +1,6 @@
 C x86/camellia-crypt-internal.asm
 
-ifelse(<
+ifelse(`
    Copyright (C) 2010, Niels Möller
 
    This file is part of GNU Nettle.
@@ -28,58 +28,58 @@ ifelse(<
    You should have received copies of the GNU General Public License and
    the GNU Lesser General Public License along with this program.  If
    not, see http://www.gnu.org/licenses/.
->)
+')
 
 C Register usage:
 
 C Camellia state, 128-bit value in little endian order.
 C L0, H0 corresponds to D1 in the spec and i0 in the C implementation.
 C while L1, H1 corresponds to D2/i1.
-define(<L0>,<%eax>)
-define(<H0>,<%ebx>)
-define(<L1>,<%ecx>)
-define(<H1>,<%edx>)
+define(`L0',`%eax')
+define(`H0',`%ebx')
+define(`L1',`%ecx')
+define(`H1',`%edx')
 
-define(<TMP>,<%ebp>)
-define(<KEY>,<%esi>)
-define(<T>,<%edi>)
+define(`TMP',`%ebp')
+define(`KEY',`%esi')
+define(`T',`%edi')
 
 C Locals on the stack
 
-define(<FRAME_L0>,	<(%esp)>)
-define(<FRAME_H0>,	<4(%esp)>)
-define(<FRAME_L1>,	<8(%esp)>)
-define(<FRAME_H1>,	<12(%esp)>)
-define(<FRAME_CNT>,	<16(%esp)>)
+define(`FRAME_L0',	`(%esp)')
+define(`FRAME_H0',	`4(%esp)')
+define(`FRAME_L1',	`8(%esp)')
+define(`FRAME_H1',	`12(%esp)')
+define(`FRAME_CNT',	`16(%esp)')
 	
 C Arguments on stack.
-define(<FRAME_NKEYS>,	<40(%esp)>)
-define(<FRAME_KEYS>,	<44(%esp)>)
-define(<FRAME_TABLE>,	<48(%esp)>)
-define(<FRAME_LENGTH>,	<52(%esp)>)
-define(<FRAME_DST>,	<56(%esp)>)
-define(<FRAME_SRC>,	<60(%esp)>)
-
-define(<SP1110>, <(T,$1,4)>)
-define(<SP0222>, <1024(T,$1,4)>)
-define(<SP3033>, <2048(T,$1,4)>)
-define(<SP4404>, <3072(T,$1,4)>)
+define(`FRAME_NKEYS',	`40(%esp)')
+define(`FRAME_KEYS',	`44(%esp)')
+define(`FRAME_TABLE',	`48(%esp)')
+define(`FRAME_LENGTH',	`52(%esp)')
+define(`FRAME_DST',	`56(%esp)')
+define(`FRAME_SRC',	`60(%esp)')
+
+define(`SP1110', `(T,$1,4)')
+define(`SP0222', `1024(T,$1,4)')
+define(`SP3033', `2048(T,$1,4)')
+define(`SP4404', `3072(T,$1,4)')
 
 C ROUND(xl, xh, yl, yh, key-offset)
 C xl and xh are rotated 16 bits at the end
 C yl and yh are read from stack, and left in registers
-define(<ROUND>, <
+define(`ROUND', `
 	movzbl	LREG($1), TMP
 	movl	SP1110(TMP), $4
 	movzbl	HREG($1), TMP
 	xorl	SP4404(TMP), $4
-	roll	<$>16, $1
+	roll	`$'16, $1
 
 	movzbl	LREG($2), TMP
 	movl	SP4404(TMP), $3
 	movzbl	HREG($2), TMP
 	xorl	SP3033(TMP), $3
-	roll	<$>16, $2
+	roll	`$'16, $2
 
 	movzbl	LREG($1), TMP
 	xorl	SP3033(TMP), $4
@@ -95,58 +95,58 @@ define(<ROUND>, <
 	xorl	$5 + 4(KEY), $3
 
 	xorl	$3, $4
-	rorl	<$>8, $3
+	rorl	`$'8, $3
 	xorl	$4, $3
 
 	xorl	FRAME_$3, $3
 	xorl	FRAME_$4, $4
->)
+')
 
 C Six rounds, with inputs and outputs in registers.
-define(<ROUND6>, <
+define(`ROUND6', `
 	movl	L0, FRAME_L0
 	movl	H0, FRAME_H0
 	movl	L1, FRAME_L1
 	movl	H1, FRAME_H1
 
-	ROUND(L0,H0,<L1>,<H1>,0)
+	ROUND(L0,H0,`L1',`H1',0)
 	movl	L1, FRAME_L1
 	movl	H1, FRAME_H1
-	ROUND(L1,H1,<L0>,<H0>,8)
+	ROUND(L1,H1,`L0',`H0',8)
 	movl	L0, FRAME_L0
 	movl	H0, FRAME_H0
-	ROUND(L0,H0,<L1>,<H1>,16)
+	ROUND(L0,H0,`L1',`H1',16)
 	movl	L1, FRAME_L1
 	movl	H1, FRAME_H1
-	ROUND(L1,H1,<L0>,<H0>,24)
+	ROUND(L1,H1,`L0',`H0',24)
 	movl	L0, FRAME_L0
 	movl	H0, FRAME_H0
-	ROUND(L0,H0,<L1>,<H1>,32)
-	ROUND(L1,H1,<L0>,<H0>,40)
-	roll	<$>16, L1
-	roll	<$>16, H1
->)
+	ROUND(L0,H0,`L1',`H1',32)
+	ROUND(L1,H1,`L0',`H0',40)
+	roll	`$'16, L1
+	roll	`$'16, H1
+')
 
 C FL(x0, x1, key-offset)
-define(<FL>, <
+define(`FL', `
 	movl	$3 + 4(KEY), TMP
 	andl	$2, TMP
-	roll	<$>1, TMP
+	roll	`$'1, TMP
 	xorl	TMP, $1
 	movl	$3(KEY), TMP
 	orl	$1, TMP
 	xorl	TMP, $2
->)
+')
 C FLINV(x0, x1, key-offset)
-define(<FLINV>, <
+define(`FLINV', `
 	movl	$3(KEY), TMP
 	orl	$1, TMP
 	xorl	TMP, $2
 	movl	$3 + 4(KEY), TMP
 	andl	$2, TMP
-	roll	<$>1, TMP
+	roll	`$'1, TMP
 	xorl	TMP, $1
->)
+')
 
 .file "camellia-crypt-internal.asm"
 	
diff --git a/x86/machine.m4 b/x86/machine.m4
index 38bee366..9f24ea0e 100644
--- a/x86/machine.m4
+++ b/x86/machine.m4
@@ -1,16 +1,16 @@
 C OFFSET(i)
 C Expands to 4*i, or to the empty string if i is zero
-define(<OFFSET>, <ifelse($1,0,,eval(4*$1))>)
+define(`OFFSET', `ifelse($1,0,,eval(4*$1))')
 
 dnl LREG(reg) gives the 8-bit register corresponding to the given 32-bit register.
-define(<LREG>,<ifelse(
+define(`LREG',`ifelse(
 	$1, %eax, %al,
 	$1, %ebx, %bl,
 	$1, %ecx, %cl,
-	$1, %edx, %dl)>)dnl
+	$1, %edx, %dl)')dnl
 
-define(<HREG>,<ifelse(
+define(`HREG',`ifelse(
 	$1, %eax, %ah,
 	$1, %ebx, %bh,
 	$1, %ecx, %ch,
-	$1, %edx, %dh)>)dnl
+	$1, %edx, %dh)')dnl
diff --git a/x86/md5-compress.asm b/x86/md5-compress.asm
index c849c082..7420671d 100644
--- a/x86/md5-compress.asm
+++ b/x86/md5-compress.asm
@@ -1,6 +1,6 @@
 C x86/md5-compress.asm
 
-ifelse(<
+ifelse(`
    Copyright (C) 2005, Niels Möller
 
    This file is part of GNU Nettle.
@@ -28,53 +28,53 @@ ifelse(<
    You should have received copies of the GNU General Public License and
    the GNU Lesser General Public License along with this program.  If
    not, see http://www.gnu.org/licenses/.
->)
+')
 
 C Register usage
-define(<SA>,<%eax>)
-define(<SB>,<%ebx>)
-define(<SC>,<%ecx>)
-define(<SD>,<%edx>)
-define(<TMP>,<%ebp>)
-define(<INPUT>,<%esi>)
+define(`SA',`%eax')
+define(`SB',`%ebx')
+define(`SC',`%ecx')
+define(`SD',`%edx')
+define(`TMP',`%ebp')
+define(`INPUT',`%esi')
 
 C %edi is unused
 
 C F1(x,y,z) = (z ^ (x & (y ^ z)))
-define(<F1>, <
+define(`F1', `
 	movl	$3, TMP
 	xorl	$2, TMP
 	andl	$1, TMP
-	xorl	$3, TMP>)
+	xorl	$3, TMP')
 
-define(<F2>,<F1($3, $1, $2)>)
+define(`F2',`F1($3, $1, $2)')
 
 C F3(x,y,z) = x ^ y ^ z
-define(<F3>,<
+define(`F3',`
 	movl	$1, TMP
 	xorl	$2, TMP
-	xorl	$3, TMP>)
+	xorl	$3, TMP')
 
 C F4(x,y,z) = y ^ (x | ~z)
-define(<F4>,<
+define(`F4',`
 	movl	$3, TMP
 	notl	TMP
 	orl	$1, TMP
-	xorl	$2, TMP>)
+	xorl	$2, TMP')
 
-define(<REF>,<OFFSET($1)(INPUT)>)
+define(`REF',`OFFSET($1)(INPUT)')
 	
 C ROUND(f, w, x, y, z, k, data, s):
 C	w += f(x,y,z) + data + k
 C	w <<< s
 C	w += x
-define(<ROUND>,<
+define(`ROUND',`
 	addl	$7, $2
 	$1($3, $4, $5)
 	addl	$6, $2
 	addl	TMP, $2
-	roll	<$>$8, $2
-	addl	$3, $2>)
+	roll	`$'$8, $2
+	addl	$3, $2')
 
 	.file "md5-compress.asm"
 
@@ -104,73 +104,73 @@ PROLOGUE(nettle_md5_compress)
 	C Note that if unaligned, we suffer unaligned accesses
 	movl	24(%esp), INPUT
 
-	ROUND(<F1>, SA, SB, SC, SD, REF( 0), $0xd76aa478, 7)
-	ROUND(<F1>, SD, SA, SB, SC, REF( 1), $0xe8c7b756, 12)
-	ROUND(<F1>, SC, SD, SA, SB, REF( 2), $0x242070db, 17)
-	ROUND(<F1>, SB, SC, SD, SA, REF( 3), $0xc1bdceee, 22)
-	ROUND(<F1>, SA, SB, SC, SD, REF( 4), $0xf57c0faf, 7)
-	ROUND(<F1>, SD, SA, SB, SC, REF( 5), $0x4787c62a, 12)
-	ROUND(<F1>, SC, SD, SA, SB, REF( 6), $0xa8304613, 17)
-	ROUND(<F1>, SB, SC, SD, SA, REF( 7), $0xfd469501, 22)
-	ROUND(<F1>, SA, SB, SC, SD, REF( 8), $0x698098d8, 7)
-	ROUND(<F1>, SD, SA, SB, SC, REF( 9), $0x8b44f7af, 12)
-	ROUND(<F1>, SC, SD, SA, SB, REF(10), $0xffff5bb1, 17)
-	ROUND(<F1>, SB, SC, SD, SA, REF(11), $0x895cd7be, 22)
-	ROUND(<F1>, SA, SB, SC, SD, REF(12), $0x6b901122, 7)
-	ROUND(<F1>, SD, SA, SB, SC, REF(13), $0xfd987193, 12)
-	ROUND(<F1>, SC, SD, SA, SB, REF(14), $0xa679438e, 17)
-	ROUND(<F1>, SB, SC, SD, SA, REF(15), $0x49b40821, 22)
+	ROUND(`F1', SA, SB, SC, SD, REF( 0), $0xd76aa478, 7)
+	ROUND(`F1', SD, SA, SB, SC, REF( 1), $0xe8c7b756, 12)
+	ROUND(`F1', SC, SD, SA, SB, REF( 2), $0x242070db, 17)
+	ROUND(`F1', SB, SC, SD, SA, REF( 3), $0xc1bdceee, 22)
+	ROUND(`F1', SA, SB, SC, SD, REF( 4), $0xf57c0faf, 7)
+	ROUND(`F1', SD, SA, SB, SC, REF( 5), $0x4787c62a, 12)
+	ROUND(`F1', SC, SD, SA, SB, REF( 6), $0xa8304613, 17)
+	ROUND(`F1', SB, SC, SD, SA, REF( 7), $0xfd469501, 22)
+	ROUND(`F1', SA, SB, SC, SD, REF( 8), $0x698098d8, 7)
+	ROUND(`F1', SD, SA, SB, SC, REF( 9), $0x8b44f7af, 12)
+	ROUND(`F1', SC, SD, SA, SB, REF(10), $0xffff5bb1, 17)
+	ROUND(`F1', SB, SC, SD, SA, REF(11), $0x895cd7be, 22)
+	ROUND(`F1', SA, SB, SC, SD, REF(12), $0x6b901122, 7)
+	ROUND(`F1', SD, SA, SB, SC, REF(13), $0xfd987193, 12)
+	ROUND(`F1', SC, SD, SA, SB, REF(14), $0xa679438e, 17)
+	ROUND(`F1', SB, SC, SD, SA, REF(15), $0x49b40821, 22)
 	
-        ROUND(<F2>, SA, SB, SC, SD, REF( 1), $0xf61e2562, 5)
-        ROUND(<F2>, SD, SA, SB, SC, REF( 6), $0xc040b340, 9)
-        ROUND(<F2>, SC, SD, SA, SB, REF(11), $0x265e5a51, 14)
-        ROUND(<F2>, SB, SC, SD, SA, REF( 0), $0xe9b6c7aa, 20)
-        ROUND(<F2>, SA, SB, SC, SD, REF( 5), $0xd62f105d, 5)
-        ROUND(<F2>, SD, SA, SB, SC, REF(10), $0x02441453, 9)
-        ROUND(<F2>, SC, SD, SA, SB, REF(15), $0xd8a1e681, 14)
-        ROUND(<F2>, SB, SC, SD, SA, REF( 4), $0xe7d3fbc8, 20)
-        ROUND(<F2>, SA, SB, SC, SD, REF( 9), $0x21e1cde6, 5)
-        ROUND(<F2>, SD, SA, SB, SC, REF(14), $0xc33707d6, 9)
-        ROUND(<F2>, SC, SD, SA, SB, REF( 3), $0xf4d50d87, 14)
-        ROUND(<F2>, SB, SC, SD, SA, REF( 8), $0x455a14ed, 20)
-        ROUND(<F2>, SA, SB, SC, SD, REF(13), $0xa9e3e905, 5)
-        ROUND(<F2>, SD, SA, SB, SC, REF( 2), $0xfcefa3f8, 9)
-        ROUND(<F2>, SC, SD, SA, SB, REF( 7), $0x676f02d9, 14)
-        ROUND(<F2>, SB, SC, SD, SA, REF(12), $0x8d2a4c8a, 20)        
-
-        ROUND(<F3>, SA, SB, SC, SD, REF( 5), $0xfffa3942, 4)
-        ROUND(<F3>, SD, SA, SB, SC, REF( 8), $0x8771f681, 11)
-        ROUND(<F3>, SC, SD, SA, SB, REF(11), $0x6d9d6122, 16)
-        ROUND(<F3>, SB, SC, SD, SA, REF(14), $0xfde5380c, 23)
-        ROUND(<F3>, SA, SB, SC, SD, REF( 1), $0xa4beea44, 4)
-        ROUND(<F3>, SD, SA, SB, SC, REF( 4), $0x4bdecfa9, 11)
-        ROUND(<F3>, SC, SD, SA, SB, REF( 7), $0xf6bb4b60, 16)
-        ROUND(<F3>, SB, SC, SD, SA, REF(10), $0xbebfbc70, 23)
-        ROUND(<F3>, SA, SB, SC, SD, REF(13), $0x289b7ec6, 4)
-        ROUND(<F3>, SD, SA, SB, SC, REF( 0), $0xeaa127fa, 11)
-        ROUND(<F3>, SC, SD, SA, SB, REF( 3), $0xd4ef3085, 16)
-        ROUND(<F3>, SB, SC, SD, SA, REF( 6), $0x04881d05, 23)
-        ROUND(<F3>, SA, SB, SC, SD, REF( 9), $0xd9d4d039, 4)
-        ROUND(<F3>, SD, SA, SB, SC, REF(12), $0xe6db99e5, 11)
-        ROUND(<F3>, SC, SD, SA, SB, REF(15), $0x1fa27cf8, 16)
-        ROUND(<F3>, SB, SC, SD, SA, REF( 2), $0xc4ac5665, 23)        
-
-        ROUND(<F4>, SA, SB, SC, SD, REF( 0), $0xf4292244, 6)
-        ROUND(<F4>, SD, SA, SB, SC, REF( 7), $0x432aff97, 10)
-        ROUND(<F4>, SC, SD, SA, SB, REF(14), $0xab9423a7, 15)
-        ROUND(<F4>, SB, SC, SD, SA, REF( 5), $0xfc93a039, 21)
-        ROUND(<F4>, SA, SB, SC, SD, REF(12), $0x655b59c3, 6)
-        ROUND(<F4>, SD, SA, SB, SC, REF( 3), $0x8f0ccc92, 10)
-        ROUND(<F4>, SC, SD, SA, SB, REF(10), $0xffeff47d, 15)
-        ROUND(<F4>, SB, SC, SD, SA, REF( 1), $0x85845dd1, 21)
-        ROUND(<F4>, SA, SB, SC, SD, REF( 8), $0x6fa87e4f, 6)
-        ROUND(<F4>, SD, SA, SB, SC, REF(15), $0xfe2ce6e0, 10)
-        ROUND(<F4>, SC, SD, SA, SB, REF( 6), $0xa3014314, 15)
-        ROUND(<F4>, SB, SC, SD, SA, REF(13), $0x4e0811a1, 21)
-        ROUND(<F4>, SA, SB, SC, SD, REF( 4), $0xf7537e82, 6)
-        ROUND(<F4>, SD, SA, SB, SC, REF(11), $0xbd3af235, 10)
-        ROUND(<F4>, SC, SD, SA, SB, REF( 2), $0x2ad7d2bb, 15)
-        ROUND(<F4>, SB, SC, SD, SA, REF( 9), $0xeb86d391, 21)
+        ROUND(`F2', SA, SB, SC, SD, REF( 1), $0xf61e2562, 5)
+        ROUND(`F2', SD, SA, SB, SC, REF( 6), $0xc040b340, 9)
+        ROUND(`F2', SC, SD, SA, SB, REF(11), $0x265e5a51, 14)
+        ROUND(`F2', SB, SC, SD, SA, REF( 0), $0xe9b6c7aa, 20)
+        ROUND(`F2', SA, SB, SC, SD, REF( 5), $0xd62f105d, 5)
+        ROUND(`F2', SD, SA, SB, SC, REF(10), $0x02441453, 9)
+        ROUND(`F2', SC, SD, SA, SB, REF(15), $0xd8a1e681, 14)
+        ROUND(`F2', SB, SC, SD, SA, REF( 4), $0xe7d3fbc8, 20)
+        ROUND(`F2', SA, SB, SC, SD, REF( 9), $0x21e1cde6, 5)
+        ROUND(`F2', SD, SA, SB, SC, REF(14), $0xc33707d6, 9)
+        ROUND(`F2', SC, SD, SA, SB, REF( 3), $0xf4d50d87, 14)
+        ROUND(`F2', SB, SC, SD, SA, REF( 8), $0x455a14ed, 20)
+        ROUND(`F2', SA, SB, SC, SD, REF(13), $0xa9e3e905, 5)
+        ROUND(`F2', SD, SA, SB, SC, REF( 2), $0xfcefa3f8, 9)
+        ROUND(`F2', SC, SD, SA, SB, REF( 7), $0x676f02d9, 14)
+        ROUND(`F2', SB, SC, SD, SA, REF(12), $0x8d2a4c8a, 20)
+
+        ROUND(`F3', SA, SB, SC, SD, REF( 5), $0xfffa3942, 4)
+        ROUND(`F3', SD, SA, SB, SC, REF( 8), $0x8771f681, 11)
+        ROUND(`F3', SC, SD, SA, SB, REF(11), $0x6d9d6122, 16)
+        ROUND(`F3', SB, SC, SD, SA, REF(14), $0xfde5380c, 23)
+        ROUND(`F3', SA, SB, SC, SD, REF( 1), $0xa4beea44, 4)
+        ROUND(`F3', SD, SA, SB, SC, REF( 4), $0x4bdecfa9, 11)
+        ROUND(`F3', SC, SD, SA, SB, REF( 7), $0xf6bb4b60, 16)
+        ROUND(`F3', SB, SC, SD, SA, REF(10), $0xbebfbc70, 23)
+        ROUND(`F3', SA, SB, SC, SD, REF(13), $0x289b7ec6, 4)
+        ROUND(`F3', SD, SA, SB, SC, REF( 0), $0xeaa127fa, 11)
+        ROUND(`F3', SC, SD, SA, SB, REF( 3), $0xd4ef3085, 16)
+        ROUND(`F3', SB, SC, SD, SA, REF( 6), $0x04881d05, 23)
+        ROUND(`F3', SA, SB, SC, SD, REF( 9), $0xd9d4d039, 4)
+        ROUND(`F3', SD, SA, SB, SC, REF(12), $0xe6db99e5, 11)
+        ROUND(`F3', SC, SD, SA, SB, REF(15), $0x1fa27cf8, 16)
+        ROUND(`F3', SB, SC, SD, SA, REF( 2), $0xc4ac5665, 23)
+
+        ROUND(`F4', SA, SB, SC, SD, REF( 0), $0xf4292244, 6)
+        ROUND(`F4', SD, SA, SB, SC, REF( 7), $0x432aff97, 10)
+        ROUND(`F4', SC, SD, SA, SB, REF(14), $0xab9423a7, 15)
+        ROUND(`F4', SB, SC, SD, SA, REF( 5), $0xfc93a039, 21)
+        ROUND(`F4', SA, SB, SC, SD, REF(12), $0x655b59c3, 6)
+        ROUND(`F4', SD, SA, SB, SC, REF( 3), $0x8f0ccc92, 10)
+        ROUND(`F4', SC, SD, SA, SB, REF(10), $0xffeff47d, 15)
+        ROUND(`F4', SB, SC, SD, SA, REF( 1), $0x85845dd1, 21)
+        ROUND(`F4', SA, SB, SC, SD, REF( 8), $0x6fa87e4f, 6)
+        ROUND(`F4', SD, SA, SB, SC, REF(15), $0xfe2ce6e0, 10)
+        ROUND(`F4', SC, SD, SA, SB, REF( 6), $0xa3014314, 15)
+        ROUND(`F4', SB, SC, SD, SA, REF(13), $0x4e0811a1, 21)
+        ROUND(`F4', SA, SB, SC, SD, REF( 4), $0xf7537e82, 6)
+        ROUND(`F4', SD, SA, SB, SC, REF(11), $0xbd3af235, 10)
+        ROUND(`F4', SC, SD, SA, SB, REF( 2), $0x2ad7d2bb, 15)
+        ROUND(`F4', SB, SC, SD, SA, REF( 9), $0xeb86d391, 21)
 	
 	C Update the state vector
 	movl	20(%esp),TMP
diff --git a/x86/sha1-compress.asm b/x86/sha1-compress.asm
index 03bdcdc9..0f728798 100644
--- a/x86/sha1-compress.asm
+++ b/x86/sha1-compress.asm
@@ -1,6 +1,6 @@
 C x86/sha1-compress.asm
 
-ifelse(<
+ifelse(`
    Copyright (C) 2004, 2009 Niels Möller
 
    This file is part of GNU Nettle.
@@ -28,31 +28,31 @@ ifelse(<
    You should have received copies of the GNU General Public License and
    the GNU Lesser General Public License along with this program.  If
    not, see http://www.gnu.org/licenses/.
->)
+')
 
 C Register usage
-define(<SA>,<%eax>)
-define(<SB>,<%ebx>)
-define(<SC>,<%ecx>)
-define(<SD>,<%edx>)
-define(<SE>,<%ebp>)
-define(<DATA>,<%esp>)
-define(<T1>,<%edi>)
-define(<T2>,<%esi>)
+define(`SA',`%eax')
+define(`SB',`%ebx')
+define(`SC',`%ecx')
+define(`SD',`%edx')
+define(`SE',`%ebp')
+define(`DATA',`%esp')
+define(`T1',`%edi')
+define(`T2',`%esi')
 	
 C Constants
-define(<K1VALUE>, <0x5A827999>)		C  Rounds  0-19
-define(<K2VALUE>, <0x6ED9EBA1>)		C  Rounds 20-39
-define(<K3VALUE>, <0x8F1BBCDC>)		C  Rounds 40-59
-define(<K4VALUE>, <0xCA62C1D6>)		C  Rounds 60-79
+define(`K1VALUE', `0x5A827999')		C  Rounds  0-19
+define(`K2VALUE', `0x6ED9EBA1')		C  Rounds 20-39
+define(`K3VALUE', `0x8F1BBCDC')		C  Rounds 40-59
+define(`K4VALUE', `0xCA62C1D6')		C  Rounds 60-79
 	
 C Reads the input via T2 into register, byteswaps it, and stores it in the DATA array.
 C SWAP(index, register)
-define(<SWAP>, <
+define(`SWAP', `
 	movl	OFFSET($1)(T2), $2
 	bswap	$2
 	movl	$2, OFFSET($1) (DATA)
->)dnl
+')dnl
 
 C The f functions,
 C
@@ -79,27 +79,27 @@ C   e += a <<< 5 + f( b, c, d ) + k + w;
 C   b <<<= 30
 
 dnl ROUND_F1(a, b, c, d, e, i)
-define(<ROUND_F1>, <
+define(`ROUND_F1', `
 	mov	OFFSET(eval($6 % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 +  2) % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 +  8) % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 + 13) % 16)) (DATA), T1
-	rol	<$>1, T1
+	rol	`$'1, T1
 	mov	T1, OFFSET(eval($6 % 16)) (DATA)
 	mov	$4, T2
 	xor	$3, T2
 	and	$2, T2
 	xor	$4, T2
-	rol	<$>30, $2
+	rol	`$'30, $2
 	lea	K1VALUE (T1, $5), $5
 	mov	$1, T1
-	rol	<$>5, T1
+	rol	`$'5, T1
 	add	T1, $5
 	add	T2, $5
->)
+')
 
 dnl ROUND_F1_NOEXP(a, b, c, d, e, i)
-define(<ROUND_F1_NOEXP>, <
+define(`ROUND_F1_NOEXP', `
 	mov	$4, T2
 	xor	$3, T2
 	mov	$1, T1
@@ -107,37 +107,37 @@ define(<ROUND_F1_NOEXP>, <
 	add	OFFSET($6) (DATA), $5
 	xor	$4, T2
 	add	T2, $5
-	rol	<$>30, $2
-	rol	<$>5, T1
+	rol	`$'30, $2
+	rol	`$'5, T1
 	lea	K1VALUE (T1, $5), $5
->)
+')
 
 dnl ROUND_F2(a, b, c, d, e, i, k)
-define(<ROUND_F2>, <
+define(`ROUND_F2', `
 	mov	OFFSET(eval($6 % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 +  2) % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 +  8) % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 + 13) % 16)) (DATA), T1
-	rol	<$>1, T1
+	rol	`$'1, T1
 	mov	T1, OFFSET(eval($6 % 16)) (DATA)
 	mov	$4, T2
 	xor	$3, T2
 	xor	$2, T2
-	rol	<$>30, $2
+	rol	`$'30, $2
 	lea	$7 (T1, $5), $5
 	mov	$1, T1
-	rol	<$>5, T1
+	rol	`$'5, T1
 	add	T1, $5
 	add	T2, $5
->)
+')
 
 dnl ROUND_F3(a, b, c, d, e, i)
-define(<ROUND_F3>, <
+define(`ROUND_F3', `
 	mov	OFFSET(eval($6 % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 +  2) % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 +  8) % 16)) (DATA), T1
 	xor	OFFSET(eval(($6 + 13) % 16)) (DATA), T1
-	rol	<$>1, T1
+	rol	`$'1, T1
 	mov	T1, OFFSET(eval($6 % 16)) (DATA)
 	mov	$4, T2
 	and	$3, T2
@@ -146,12 +146,12 @@ define(<ROUND_F3>, <
 	xor	$3, T1
 	and	$2, T1
 	add	T2, $5
-	rol	<$>30, $2
+	rol	`$'30, $2
 	mov	$1, T2
-	rol	<$>5, T2
+	rol	`$'5, T2
 	add	T1, $5
 	add	T2, $5
->)
+')
 
 	.file "sha1-compress.asm"