koules 1.4-3: cleanup

Update to the packaging standards:
- use prepare() and package()
- use $srcdir and $pkgdir instead of $startdir and quote them
- include .patch instead of .patch.bz2
- remove "|| return 1"
- remove dependency on "patch", this is included in package "base-devel"
- use "install -D" instead of "mkdir"

** Manually imported from AUR 3 **

4 files changed, 954 insertions, 24 deletions

diff --git a/.SRCINFO b/.SRCINFO
index d1cb398fb251..1f016f58e016 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,12 +1,11 @@
 pkgbase = koules
 	pkgdesc = A fast arcade game based on fundamental law of bodies attraction
 	pkgver = 1.4
-	pkgrel = 2
+	pkgrel = 3
 	url = http://www.ucw.cz/~hubicka/koules/English/
 	arch = i686
 	arch = x86_64
 	license = GPL
-	makedepends = patch
 	makedepends = imake
 	makedepends = xextproto
 	makedepends = xproto
@@ -14,9 +13,9 @@ pkgbase = koules
 	depends = libx11
 	depends = libxext
 	source = http://www.ucw.cz/~hubicka/koules/packages/koules1.4-src.tar.gz
-	source = koules-1.4-gcc3.patch.bz2
+	source = koules-1.4-gcc3.patch
 	md5sums = 0a5ac9e57c8b72e9fc200bc98273235c
-	md5sums = b16677698a084e11e78324098b7a9e57
+	md5sums = ccc92d4ab7d61ca482d30192a5ee83ec
 
 pkgname = koules
 
diff --git a/PKGBUILD b/PKGBUILD
index 05af7c3d73b8..a473450f420b 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,27 +1,35 @@
+# Maintainer: Markus Heidelberg <markus dot heidelberg at web dot de>
 # Contributor: Gyo <nucleogeek_at_gmail_dot_com>
 pkgname=koules
 pkgver=1.4
-pkgrel=2
+pkgrel=3
 pkgdesc="A fast arcade game based on fundamental law of bodies attraction"
 arch=('i686' 'x86_64')
 url="http://www.ucw.cz/~hubicka/koules/English/"
 license=('GPL')
 depends=('dialog' 'libx11' 'libxext')
-makedepends=('patch' 'imake' 'xextproto' 'xproto')
-source=(http://www.ucw.cz/~hubicka/koules/packages/${pkgname}${pkgver}-src.tar.gz $pkgname-$pkgver-gcc3.patch.bz2)
-md5sums=('0a5ac9e57c8b72e9fc200bc98273235c' 'b16677698a084e11e78324098b7a9e57')
+makedepends=('imake' 'xextproto' 'xproto')
+source=(http://www.ucw.cz/~hubicka/koules/packages/$pkgname$pkgver-src.tar.gz
+        $pkgname-$pkgver-gcc3.patch)
+md5sums=('0a5ac9e57c8b72e9fc200bc98273235c'
+         'ccc92d4ab7d61ca482d30192a5ee83ec')
+
+prepare() {
+  cd "$srcdir/$pkgname$pkgver"
+  patch -p1 < "$srcdir/$pkgname-$pkgver-gcc3.patch"
+}
 
 build() {
+  cd "$srcdir/$pkgname$pkgver"
+
   # some sources modifications
-  cd $startdir/src/${pkgname}${pkgver}
-  patch -Np1 < ../$pkgname-$pkgver-gcc3.patch || return 1
   sed -i \
     -e "/^KOULESDIR/s:=.*:=/usr/bin:" \
-    -e "/^SOUNDDIR/s:=.*:=/usr/share/$pkgname:" Iconfig || return 1
+    -e "/^SOUNDDIR/s:=.*:=/usr/share/$pkgname:" Iconfig
   sed -i \
-    -e "s:/usr/local/bin:/usr/bin:" koules || return 1
+    -e "s:/usr/local/bin:/usr/bin:" koules
   sed -i \
-    -e 's:exec.*tcl:exec xkoules -M "$@":' koules || return 1
+    -e 's:exec.*tcl:exec xkoules -M "$@":' koules
 
   ln -s xkoules.6 xkoules.man
   ln -s xkoules.6 xkoules._man
@@ -30,16 +38,15 @@ build() {
   xmkmf -a
   sed -i \
     -e '/SYSDEFS =/d' \
-    -e "/^ *CFLAGS =/s:$: ${CFLAGS}:" Makefile || return 1
-  make || return 1
+    -e "/^ *CFLAGS =/s:$: ${CFLAGS}:" Makefile
+  make
+}
 
-  # installation
-  mkdir -p $startdir/pkg/usr/bin
-  install -m755 xkoules $startdir/pkg/usr/bin
-  install -m755 koules $startdir/pkg/usr/bin
-  mkdir -p $startdir/pkg/usr/share/koules
-  install -m755 koules.sndsrv.linux $startdir/pkg/usr/share/koules
-  install -m644 sounds/* $startdir/pkg/usr/share/koules
-  mkdir -p $startdir/pkg/usr/share/man/man6
-  install -m644 xkoules.6 $startdir/pkg/usr/share/man/man6
+package() {
+  cd "$srcdir/$pkgname$pkgver"
+  install -Dm755 xkoules "$pkgdir/usr/bin/xkoules"
+  install -Dm755 koules "$pkgdir/usr/bin/koules"
+  install -Dm755 koules.sndsrv.linux "$pkgdir/usr/share/koules/koules.sndsrv.linux"
+  install -m644 sounds/* "$pkgdir/usr/share/koules"
+  install -Dm644 xkoules.6 "$pkgdir/usr/share/man/man6/xkoules.6"
 }
diff --git a/koules-1.4-gcc3.patch b/koules-1.4-gcc3.patch
new file mode 100644
index 000000000000..e2830d94adba
--- /dev/null
+++ b/koules-1.4-gcc3.patch
@@ -0,0 +1,924 @@
+diff -ur koules1.4/koules.sndsrv.linux.c koules1.4-gcc3/koules.sndsrv.linux.c
+--- koules1.4/koules.sndsrv.linux.c	1998-03-04 19:59:19.000000000 +0100
++++ koules1.4-gcc3/koules.sndsrv.linux.c	2003-04-23 01:15:16.000000000 +0200
+@@ -136,7 +136,7 @@
+    Eventually I'll look at the koules signal handlers and
+    just trap this.
+  */
+-int
++void
+ do_nothing (void)
+ {
+   fprintf (stderr, "koules.sndsrv: doing nothing, something is broken\n");
+diff -ur koules1.4/xlib/inlstring.h koules1.4-gcc3/xlib/inlstring.h
+--- koules1.4/xlib/inlstring.h	1998-03-04 19:59:19.000000000 +0100
++++ koules1.4-gcc3/xlib/inlstring.h	2003-04-23 00:53:56.000000000 +0200
+@@ -1,292 +1,348 @@
+-
+ /* Based on functions in linux/string.h */
+ 
+-
++#ifndef INLSTRING_H
++#define INLSTRING_H
++#include <sys/types.h>	/* for size_t */
+ 
+ #if !defined(__386__)||!defined(ASSEMBLY)
+ 
+ #define __memcpy(dst,src,n)			memcpy((dst),(src),(n))
+-#define __memcpy_conventioanl(dst,src,n)	memcpy((dst),(src),(n))
++#define __memcpy_conventional(dst,src,n)	memcpy((dst),(src),(n))
+ #define __memcpyb(dst,src,n)			memcpy((dst),(src),(n))
+ #define __memsetb(dst,c,n)			memset((dst),(c),(n))
+-#define __memsetlong(dst,c,n)			memset((dst),(c),(n))
+ #define __memset(dst,c,n)			memset((dst),(c),(n))
+-#define __memset2(dst,c,n)			memset((dst),(c),2*(n))
+-#define __memset3(dst,c,n)			memset((dst),(c),3*(n))
++
++static inline void *__memsetlong(void *s, long c, size_t count) {
++    long *p=s;
++    int i;
++    for(i=0;i<count;i++)*p++=c;
++    return s;
++}
++
++static inline void *__memset2(void *s, short c, size_t count) {
++    short *p=s;
++    int i;
++    for(i=0;i<count;i++)*p++=c;
++    return s;
++}
++
++static inline void *__memset3(void *s, short c, size_t count) {
++    unsigned char *p=s;
++    int i;
++    for(i=0;i<count;i++) {
++        *p++=c&0xff;
++        *p++=(c>>8)&0xff;
++        *p++=(c>>16)&0xff;
++    }
++    return s;
++}
+ 
+ #else
+ 
+-#include <linux/types.h>	/* for size_t */
+-static INLINE void *
+-__memcpy_conventional (void *to, const void *from, size_t n)
++static inline void *
++ __memcpy_conventional(void *to, const void *from, size_t n)
+ {
+-  __asm__ ("cld\n\t"
+-	   "movl %%edi,%%ecx\n\t"
+-	   "andl $1,%%ecx\n\t"
+-	   "subl %%ecx,%%edx\n\t"
+-	   "rep ; movsb\n\t"	/* 16-bit align destination */
+-	   "movl %%edx,%%ecx\n\t"
+-	   "shrl $2,%%ecx\n\t"
+-	   "rep ; movsl\n\t"
+-	   "testb $1,%%dl\n\t"
+-	   "je 1f\n\t"
+-	   "movsb\n"
+-	   "1:\ttestb $2,%%dl\n\t"
+-	   "je 2f\n\t"
+-	   "movsw\n"
+-	   "2:\n"
+-: :	   "d" (n), "D" ((long) to), "S" ((long) from)
+-:	   "cx", "dx", "di", "si");
+-  return (to);
++  int dummy1;
++  long dummy2, dummy3;
++    __asm__ __volatile__("cld\n\t"
++    	    "cmpl $0,%%edx\n\t"
++    	    "jle 2f\n\t"
++	    "movl %%edi,%%ecx\n\t"
++	    "andl $1,%%ecx\n\t"
++	    "subl %%ecx,%%edx\n\t"
++	    "rep ; movsb\n\t"	/* 16-bit align destination */
++	    "movl %%edx,%%ecx\n\t"
++	    "shrl $2,%%ecx\n\t"
++	    "jz 3f\n\t"
++	    "rep ; movsl\n\t"
++	    "3:\n\t"
++	    "testb $1,%%dl\n\t"
++	    "je 1f\n\t"
++	    "movsb\n"
++	    "1:\ttestb $2,%%dl\n\t"
++	    "je 2f\n\t"
++	    "movsw\n"
++	    "2:\n"
++  :         "=d"(dummy1), "=D"(dummy2), "=S"(dummy3)   /* fake output */ 
++  :	    "0"(n), "1"((long) to), "2"((long) from)
++  :	    "cx"/***rjr***, "dx", "di", "si"***/
++  );
++    return (to);
+ }
+ 
+ 
+-static INLINE void *
+-__memcpyb (void *to, const void *from, size_t n)
++static inline void *
++ __memcpyb(void *to, const void *from, size_t n)
+ {
+-  __asm__ ("cld\n\t"
+-	   "rep ; movsb\n\t"
+-: :	   "c" (n), "D" ((long) to), "S" ((long) from)
+-:	   "cx", "di", "si");
+-  return (to);
++  int dummy1;
++  long dummy2, dummy3;
++    __asm__ __volatile__("cld\n\t"
++	    "rep ; movsb\n\t"
++  :         "=c"(dummy1), "=D"(dummy2), "=S"(dummy3) /* fake output */
++  :	    "0"(n), "1"((long) to), "2"((long) from)
++			 /***rjr***:	    "cx", "di", "si"***/
++  );
++    return (to);
+ }
+ 
+-static INLINE void *
+-__memsetb (void *s, char c, size_t count)
++static inline void *
++ __memsetb(void *s, char c, size_t count)
+ {
+-  __asm__ ("cld\n\t"
+-	   "rep\n\t"
+-	   "stosb"
+-: :	   "a" (c), "D" (s), "c" (count)
+-:	   "cx", "di");
+-  return s;
++    __asm__("cld\n\t"
++	    "rep\n\t"
++	    "stosb"
++  : :	    "a"(c), "D"(s), "c"(count)
++  :	    "cx", "di");
++    return s;
+ }
+ 
+-static INLINE void *
+-__memsetlong (void *s, unsigned c, size_t count)
++static inline void *
++ __memsetlong(void *s, unsigned c, size_t count)
+ {
+-  __asm__ ("cld\n\t"
+-	   "rep\n\t"
+-	   "stosl"
+-: :	   "a" (c), "D" (s), "c" (count)
+-:	   "cx", "di");
+-  return s;
++  long dummy1;
++  int dummy2;
++    __asm__ __volatile__("cld\n\t"
++	    "rep\n\t"
++	    "stosl"
++  :         "=D"(dummy1), "=c"(dummy2) /* fake outputs */
++  :	    "a"(c), "0"(s), "1"(count)
++			 /***rjr***:	    "cx", "di"***/
++  );
++    return s;
+ }
+ 
+-static INLINE void *
+-__memset (void *s, char c, size_t count)
++static inline void *
++ __memset(void *s, char c, size_t count)
+ {
+-  __asm__ (
+-	    "cld\n\t"
+-	    "cmpl $12,%%edx\n\t"
+-	    "jl 1f\n\t"		/* if (count >= 12) */
+-
+-	    "movzbl %%al,%%ax\n\t"
+-	    "movl %%eax,%%ecx\n\t"
+-	    "shll $8,%%ecx\n\t"	/* c |= c << 8 */
+-	    "orl %%ecx,%%eax\n\t"
+-	    "movl %%eax,%%ecx\n\t"
+-	    "shll $16,%%ecx\n\t"	/* c |= c << 16 */
+-	    "orl %%ecx,%%eax\n\t"
+-
+-	    "movl %%edx,%%ecx\n\t"
+-	    "negl %%ecx\n\t"
+-	    "andl $3,%%ecx\n\t"	/* (-s % 4) */
+-	    "subl %%ecx,%%edx\n\t"	/* count -= (-s % 4) */
+-	    "rep ; stosb\n\t"	/* align to longword boundary */
+-
+-	    "movl %%edx,%%ecx\n\t"
+-	    "shrl $2,%%ecx\n\t"
+-	    "rep ; stosl\n\t"	/* fill longwords */
+-
+-	    "andl $3,%%edx\n"	/* fill last few bytes */
+-	    "1:\tmovl %%edx,%%ecx\n\t"	/* <= 12 entry point */
+-	    "rep ; stosb\n\t"
+-: :	    "a" (c), "D" (s), "d" (count)
+-:	    "ax", "cx", "dx", "di");
+-  return s;
++  int dummy1;
++  long dummy2;
++  int dummy3;
++    __asm__ __volatile__(
++	       "cld\n\t"
++	       "cmpl $12,%%edx\n\t"
++	       "jl 1f\n\t"	/* if (count >= 12) */
++
++	       "movzbl %%al,%%ax\n\t"
++	       "movl %%eax,%%ecx\n\t"
++	       "shll $8,%%ecx\n\t"	/* c |= c << 8 */
++	       "orl %%ecx,%%eax\n\t"
++	       "movl %%eax,%%ecx\n\t"
++	       "shll $16,%%ecx\n\t"	/* c |= c << 16 */
++	       "orl %%ecx,%%eax\n\t"
++
++	       "movl %%edx,%%ecx\n\t"
++	       "negl %%ecx\n\t"
++	       "andl $3,%%ecx\n\t"	/* (-s % 4) */
++	       "subl %%ecx,%%edx\n\t"	/* count -= (-s % 4) */
++	       "rep ; stosb\n\t"	/* align to longword boundary */
++
++	       "movl %%edx,%%ecx\n\t"
++	       "shrl $2,%%ecx\n\t"
++	       "rep ; stosl\n\t"	/* fill longwords */
++
++	       "andl $3,%%edx\n"	/* fill last few bytes */
++	       "1:\tmovl %%edx,%%ecx\n\t"	/* <= 12 entry point */
++	       "rep ; stosb\n\t"
++  :            "=a"(dummy1), "=D"(dummy2), "=d"(dummy3) /* fake outputs */
++  :	       "0"(c), "1"(s), "2"(count)
++  :	       /***rjr***"ax",*/ "cx"/*, "dx", "di"*/
++  );
++    return s;
+ }
+ 
+-static INLINE void *
+-__memset2 (void *s, short c, size_t count)
++static inline void *
++ __memset2(void *s, short c, size_t count)
+ /* count is in 16-bit pixels */
+ /* s is assumed to be 16-bit aligned */
+ {
+-  __asm__ (
+-	    "cld\n\t"
+-	    "cmpl $12,%%edx\n\t"
+-	    "jl 1f\n\t"		/* if (count >= 12) */
+-
+-	    "movzwl %%ax,%%eax\n\t"
+-	    "movl %%eax,%%ecx\n\t"
+-	    "shll $16,%%ecx\n\t"	/* c |= c << 16 */
+-	    "orl %%ecx,%%eax\n\t"
+-
+-	    "movl %%edi,%%ecx\n\t"
+-	    "andl $2,%%ecx\n\t"	/* s & 2 */
+-	    "jz 2f\n\t"
+-	    "decl %%edx\n\t"	/* count -= 1 */
+-	    "stosw\n\t"		/* align to longword boundary */
+-
+-	    "2:\n\t"
+-	    "movl %%edx,%%ecx\n\t"
+-	    "shrl $1,%%ecx\n\t"
+-	    "rep ; stosl\n\t"	/* fill longwords */
+-
+-	    "andl $1,%%edx\n"	/* one 16-bit word left? */
+-	    "jz 3f\n\t"		/* no, finished */
+-	    "1:\tmovl %%edx,%%ecx\n\t"	/* <= 12 entry point */
+-	    "rep ; stosw\n\t"
+-	    "3:\n\t"
+-: :	    "a" (c), "D" (s), "d" (count)
+-:	    "ax", "cx", "dx", "di");
+-  return s;
++  int dummy1;
++  long dummy2;
++  int dummy3;
++    __asm__ __volatile__(
++	       "cld\n\t"
++	       "cmpl $12,%%edx\n\t"
++	       "jl 1f\n\t"	/* if (count >= 12) */
++
++	       "movzwl %%ax,%%eax\n\t"
++	       "movl %%eax,%%ecx\n\t"
++	       "shll $16,%%ecx\n\t"	/* c |= c << 16 */
++	       "orl %%ecx,%%eax\n\t"
++
++	       "movl %%edi,%%ecx\n\t"
++	       "andl $2,%%ecx\n\t"	/* s & 2 */
++	       "jz 2f\n\t"
++	       "decl %%edx\n\t"	/* count -= 1 */
++	       "movw %%ax,(%%edi)\n\t"	/* align to longword boundary */
++	       "addl $2,%%edi\n\t"
++
++	       "2:\n\t"
++	       "movl %%edx,%%ecx\n\t"
++	       "shrl $1,%%ecx\n\t"
++	       "rep ; stosl\n\t"	/* fill longwords */
++
++	       "andl $1,%%edx\n"	/* one 16-bit word left? */
++	       "jz 3f\n\t"	/* no, finished */
++	       "1:\tmovl %%edx,%%ecx\n\t"	/* <= 12 entry point */
++	       "rep ; stosw\n\t"
++	       "3:\n\t"
++  :            "=a"(dummy1), "=D"(dummy2), "=d"(dummy3) /* fake outputs */
++  :	       "0"(c), "1"(s), "2"(count)
++  :	       /***rjr***"ax",*/ "cx"/*, "dx", "di"*/
++  );
++    return s;
+ }
+ 
+-static INLINE void *
+-__memset3 (void *s, int c, size_t count)
++static inline void *
++ __memset3(void *s, int c, size_t count)
+ /* count is in 24-bit pixels (3 bytes per pixel) */
+ {
+-  __asm__ (
+-	    "cmpl $8,%%edx\n\t"
+-  /*      "jmp 2f\n\t" *//* debug */
+-	    "jl 2f\n\t"
+-
+-	    "movl %%eax,%%ebx\n\t"	/* eax = (low) BGR0 (high) */
+-	    "shll $24,%%ebx\n\t"	/* ebx = 000B */
+-	    "orl %%ebx,%%eax\n\t"	/* eax = BGRB */
+-
+-	    "movl %%eax,%%ebx\n\t"
+-	    "shrl $8,%%ebx\n\t"	/* ebx = GRB0 */
+-	    "movl %%ebx,%%ecx\n\t"
+-	    "shll $24,%%ecx\n\t"	/* ecx = 000G */
+-	    "orl %%ecx,%%ebx\n\t"	/* ebx = GRBG */
+-
+-	    "movl %%eax,%%ecx\n\t"
+-	    "shll $8,%%ecx\n\t"	/* ecx = 0BGR */
+-	    "movb %%bh,%%cl\n\t"	/* ecx = RBGR */
+-
+-	    "cmpl $16,%%edx\n\t"
+-	    "jl 1f\n\t"
+-	    "jmp 5f\n\t"
+-	    ".align 4,0x90\n\t"
+-
+-	    "5:\n\t"		/* loop unrolling */
+-	    "movl %%eax,(%%edi)\n\t"	/* write BGRB */
+-	    "movl %%ebx,4(%%edi)\n\t"	/* write GRBG */
+-	    "movl %%ecx,8(%%edi)\n\t"	/* write RBGR */
+-	    "movl %%eax,12(%%edi)\n\t"
+-	    "movl %%ebx,16(%%edi)\n\t"
+-	    "movl %%ecx,20(%%edi)\n\t"
+-	    "movl %%eax,24(%%edi)\n\t"
+-	    "movl %%ebx,28(%%edi)\n\t"
+-	    "movl %%ecx,32(%%edi)\n\t"
+-	    "movl %%eax,36(%%edi)\n\t"
+-	    "subl $16,%%edx\n\t"	/* blend end-of-loop instr. */
+-	    "movl %%ebx,40(%%edi)\n\t"
+-	    "movl %%ecx,44(%%edi)\n\t"
+-	    "addl $48,%%edi\n\t"
+-	    "cmpl $16,%%edx\n\t"
+-	    "jge 5b\n\t"
+-	    "andl %%edx,%%edx\n\t"
+-	    "jz 4f\n\t"		/* finished */
+-	    "cmpl $4,%%edx\n\t"
+-	    "jl 2f\n\t"		/* less than 4 pixels left */
+-	    "jmp 1f\n\t"
+-	    ".align 4,0x90\n\t"
+-
+-	    "1:\n\t"
+-	    "movl %%eax,(%%edi)\n\t"	/* write BGRB */
+-	    "movl %%ebx,4(%%edi)\n\t"	/* write GRBG */
+-	    "movl %%ecx,8(%%edi)\n\t"	/* write RBGR */
+-	    "addl $12,%%edi\n\t"
+-	    "subl $4,%%edx\n\t"
+-	    "cmpl $4,%%edx\n\t"
+-	    "jge 1b\n\t"
+-
+-	    "2:\n\t"
+-	    "cmpl $0,%%edx\n\t"	/* none left? */
+-	    "jle 4f\n\t"	/* finished */
+-
+-	    "mov %%eax,%%ecx\n\t"
+-	    "shrl $16,%%ecx\n\t"	/* B in cl */
+-
+-	    "3:\n\t"		/* write last few pixels */
+-	    "movw %%ax,(%%edi)\n\t"	/* write RG */
+-	    "movb %%cl,2(%%edi)\n\t"	/* write B */
+-	    "addl $3,%%edi\n\t"
+-	    "decl %%edx\n\t"
+-	    "jnz 3b\n\t"
+-
+-	    "4:\n\t"
+-: :	    "a" (c), "D" (s), "d" (count)
+-:	    "ax", "bx", "cx", "dx", "di");
+-  return s;
++  int dummy1;
++  long dummy2;
++  int dummy3;
++    __asm__ __volatile__(
++	       "cmpl $8,%%edx\n\t"
++    /*      "jmp 2f\n\t" *//* debug */
++	       "jl 2f\n\t"
++
++	       "movl %%eax,%%esi\n\t"	/* esi = (low) BGR0 (high) */
++	       "shll $24,%%eax\n\t"	/* eax = 000B */
++	       "orl %%eax,%%esi\n\t"	/* esi = BGRB */
++
++	       "movl %%esi,%%eax\n\t"
++	       "shrl $8,%%eax\n\t"	/* eax = GRB0 */
++	       "movl %%eax,%%ecx\n\t"
++	       "shll $24,%%ecx\n\t"	/* ecx = 000G */
++	       "orl %%ecx,%%eax\n\t"	/* eax = GRBG */
++
++	       "movl %%esi,%%ecx\n\t"
++	       "shll $8,%%ecx\n\t"	/* ecx = 0BGR */
++	       "movb %%ah,%%cl\n\t"	/* ecx = RBGR */
++
++	       "cmpl $16,%%edx\n\t"
++	       "jl 1f\n\t"
++	       "jmp 5f\n\t"
++	       ".align 4,0x90\n\t"
++
++	       "5:\n\t"		/* loop unrolling */
++	       "movl %%esi,(%%edi)\n\t"		/* write BGRB */
++	       "movl %%eax,4(%%edi)\n\t"	/* write GRBG */
++	       "movl %%ecx,8(%%edi)\n\t"	/* write RBGR */
++	       "movl %%esi,12(%%edi)\n\t"
++	       "movl %%eax,16(%%edi)\n\t"
++	       "movl %%ecx,20(%%edi)\n\t"
++	       "movl %%esi,24(%%edi)\n\t"
++	       "movl %%eax,28(%%edi)\n\t"
++	       "movl %%ecx,32(%%edi)\n\t"
++	       "movl %%esi,36(%%edi)\n\t"
++	       "subl $16,%%edx\n\t"	/* blend end-of-loop instr. */
++	       "movl %%eax,40(%%edi)\n\t"
++	       "movl %%ecx,44(%%edi)\n\t"
++	       "addl $48,%%edi\n\t"
++	       "cmpl $16,%%edx\n\t"
++	       "jge 5b\n\t"
++	       "andl %%edx,%%edx\n\t"
++	       "jz 4f\n\t"	/* finished */
++	       "cmpl $4,%%edx\n\t"
++	       "jl 2f\n\t"	/* less than 4 pixels left */
++	       "jmp 1f\n\t"
++	       ".align 4,0x90\n\t"
++
++	       "1:\n\t"
++	       "movl %%esi,(%%edi)\n\t"		/* write BGRB */
++	       "movl %%eax,4(%%edi)\n\t"	/* write GRBG */
++	       "movl %%ecx,8(%%edi)\n\t"	/* write RBGR */
++	       "addl $12,%%edi\n\t"
++	       "subl $4,%%edx\n\t"
++	       "cmpl $4,%%edx\n\t"
++	       "jge 1b\n\t"
++
++	       "2:\n\t"
++	       "cmpl $0,%%edx\n\t"	/* none left? */
++	       "jle 4f\n\t"	/* finished */
++
++	       "mov %%ecx,%%eax\n\t"
++	       "shrl $8,%%ecx\n\t"	/* R in cl */
++
++	       "3:\n\t"		/* write last few pixels */
++	       "movw %%cx,(%%edi)\n\t"	/* write BG */
++	       "movb %%al,2(%%edi)\n\t"		/* write R */
++	       "addl $3,%%edi\n\t"
++	       "decl %%edx\n\t"
++	       "jnz 3b\n\t"
++
++	       "4:\n\t"
++  :            "=a"(dummy1), "=D"(dummy2), "=d"(dummy3) /* fake outputs */
++  :	       "0"(c), "1"(s), "2"(count)
++  :	       /***rjr***"ax",*/ "cx", /*"dx",*/ "si"/*, "di"*/
++  );
++    return s;
+ }
+ 
+-/* Functions defined in mem.S */
+-
+-extern          memcpy4to3 (void *dest, void *src, int n);
+-extern          memcpy32shift8 (void *dest, void *src, int n);
+-
+ /* Functions for which arguments must be passed in %ebx, %edx, and %ecx. */
+-extern          __memcpyasm_regargs ();		/* nu_bytes >= 3 */
+-extern          __memcpyasm_regargs_aligned ();		/* nu_bytes >= 32 */
++#if 0				/* Why declare 'em? Just confuses the compiler and can't be called from C
++				   anyway */
++extern __memcpyasm_regargs();	/* nu_bytes >= 3 */
++extern __memcpyasm_regargs_aligned();	/* nu_bytes >= 32 */
++#endif
+ 
+ 
+ /* Always 32-bit align destination, even for a small number of bytes. */
+-static INLINE void *
+-__memcpy_aligndest (void *dest, const void *src, int n)
++static inline void *
++ __memcpy_aligndest(void *dest, const void *src, int n)
+ {
+-  __asm__         __volatile__ ("
+-				cmpl $3, %%ecx
+-				ja 1f
+-				call * __memcpy_jumptable (, %%ecx, 4)
+-				jmp 2f
+-				1:call __memcpyasm_regargs
+-				"
+-				:
+-				:"b"            (dest), "d" (src), "c" (n)
+-				:"ax", "0", "1", "2");
++    __asm__ __volatile__("cmpl $3, %%ecx\n\t"
++			 "ja 1f\n\t"
++			 "call * __memcpy_jumptable (, %%ecx, 4)\n\t"
++			 "jmp 2f\n\t"
++			 "1:call __memcpyasm_regargs\n\t"
++			 "2:":
++			 :"S"(dest), "d"(src), "c"(n)
++			 :"ax", "0", "1", "2");
++    return dest;
+ }
+ 
+ 
+ /* Optimized version for 32-bit aligned destination. */
+-static INLINE void *
+-__memcpy_destaligned (void *dest, const void *src, int n)
++static inline void *
++ __memcpy_destaligned(void *dest, const void *src, int n)
+ {
+-  __asm__         __volatile__ ("
+-				cmpl $32, %%ecx
+-				ja 1f
+-				call * __memcpy_jumptable (, %%ecx, 4)
+-				jmp 2f
+-				1:call __memcpyasm_regargs_aligned
+-				2:
+-				"
+-				:
+-				:"b"            (dest), "d" (src), "c" (n)
+-				:"ax", "0", "1", "2");
++    __asm__ __volatile__("cmpl $32, %%ecx\n\t"
++			 "ja 1f\n\t"
++			 "call * __memcpy_jumptable (, %%ecx, 4)\n\t"
++			 "jmp 2f\n\t"
++			 "1:call __memcpyasm_regargs_aligned\n\t"
++			 "2:\n\t":
++			 :"S"(dest), "d"(src), "c"(n)
++			 :"ax", "0", "1", "2");
++    return dest;
+ }
+ 
+ 
+-/* Balanced INLINE memcpy; 32-bit align destination if nu_bytes >= 20. */
+-static INLINE void *
+-__memcpy_balanced (void *dest, const void *src, int n)
++/* Balanced inline memcpy; 32-bit align destination if nu_bytes >= 20. */
++static inline void *
++ __memcpy_balanced(void *dest, const void *src, int n)
+ {
+-  __asm__         __volatile__ ("
+-				cmpl $19, %%ecx
+-				ja 1f
+-				call * __memcpy_jumptable (, %%ecx, 4)
+-				jmp 2f
+-				1:call __memcpyasm_regargs
+-				2:
+-				"
+-				:
+-	     :"b"            ((long) dest), "d" ((long) src), "c" ((long) n)
+-				:"ax", "bx", "cx", "dx");
++    __asm__ __volatile__("cmpl $19, %%ecx\n\t"
++			 "ja 1f\n\t"
++			 "call * __memcpy_jumptable (, %%ecx, 4)\n\t"
++			 "jmp 2f\n\t"
++			 "1:call __memcpyasm_regargs\n\t"
++			 "2:\n\t"
++			 :
++			 :"S"((long) dest), "d"((long) src), "c"((long) n)
++			 :"ax", "0", "1", "2");
++    return dest;
+ }
+ 
+ 
+ #define __memcpy __memcpy_conventional
+ 
+ #endif
++
++/* Functions defined in mem.S or mem.c */
++
++extern void __memcpy4to3(void *dest, void *src, int n);
++extern void __memcpy32shift8(void *dest, void *src, int n);
++
++#endif
++
+diff -ur koules1.4/xlib/shmbitmap.c koules1.4-gcc3/xlib/shmbitmap.c
+--- koules1.4/xlib/shmbitmap.c	1998-03-04 19:59:19.000000000 +0100
++++ koules1.4-gcc3/xlib/shmbitmap.c	2003-04-23 01:11:02.000000000 +0200
+@@ -139,23 +139,37 @@
+ 	  count = *dp++;
+ 	  /* __memcpy gives severe bug here */
+ 	  if (y >= ny)
++	    {
+ 	    if (x >= nx)
++	      {
+ 	      if (x + count > __clipx2 + 1)
+ 		{
+ 		  if (x <= __clipx2)
+-		    __memcpyb (vp, dp, __clipx2 - x + 1);
++		    {
++		      __memcpyb (vp, dp, __clipx2 - x + 1);
++		    }
+ 		}
+ 	      else
+-		__memcpyb (vp, dp, count);
++		{
++		  __memcpyb (vp, dp, count);
++		}
++	      }
+ 	    else if (x + count > __clipx1)
++	      {
+ 	      if (x + count > __clipx2 + 1)
++		{
+ 		__memcpyb (vp + __clipx1 - x,
+ 			   dp + __clipx1 - x,
+ 			   __clipx2 - __clipx1 + 1);
++		}
+ 	      else
++		{
+ 		__memcpy (vp + __clipx1 - x,
+ 			  dp + __clipx1 - x,
+ 			  count - __clipx1 + x);
++		}
++	      }
++	    }
+ 	  x += count;
+ 	  vp += count;
+ 	  dp += count;
+@@ -224,11 +238,7 @@
+ 
+ 
+ /*following routines are ripped from vgagl library */
+-/* We use the 32-bit to 64-bit multiply and 64-bit to 32-bit divide of the */
+-/* 386 (which gcc doesn't know well enough) to efficiently perform integer */
+-/* scaling without having to worry about overflows. */
+ #define swap(x, y) { int temp = x; x = y; y = temp; }
+-#define setpixel (*(backscreen->ff.driver_setpixel_func))
+ #undef __clipx2
+ #define __clipx2 (MAPWIDTH-1)
+ #undef __clipx1
+@@ -237,23 +247,15 @@
+ #define __clipy1 0
+ #undef __clipy2
+ #define __clipy2 (MAPHEIGHT+19)
+-#ifdef __i386__
++
+ static INLINE int
+-muldiv64 (int CONST m1, int CONST m2, int CONST d)
++muldiv64(int m1, int m2, int d)
+ {
+-/* int32 * int32 -> int64 / int32 -> int32 */
+-  int             result;
+-  __asm__ (
+-	    "imull %%edx\n\t"
+-	    "idivl %3\n\t"
+-:	    "=a" (result)	/* out */
+-:	    "a" (m1), "d" (m2), "g" (d)		/* in */
+-:	    "ax", "dx"		/* mod */
+-    );
+-  return result;
++  return (float) m1 * (float) m2 / ((float) d);
+ }
+ 
+-#define INC_IF_NEG(y)                                  \
++#ifdef __i386__
++#define INC_IF_NEG(y, result)                           \
+ {                                                       \
+         __asm__("btl $31,%1\n\t"                        \
+                 "adcl $0,%0"                            \
+@@ -264,20 +266,20 @@
+ static INLINE int
+ gl_regioncode (CONST int x, CONST int y)
+ {
+-  int             dx1, dx2, dy1, dy2;
+-  int             result;
++  int dx1, dx2, dy1, dy2;
++  int result;
+   result = 0;
+   dy2 = __clipy2 - y;
+-  INC_IF_NEG (dy2);
++  INC_IF_NEG (dy2, result);
+   result <<= 1;
+   dy1 = y - __clipy1;
+-  INC_IF_NEG (dy1);
++  INC_IF_NEG (dy1, result);
+   result <<= 1;
+   dx2 = __clipx2 - x;
+-  INC_IF_NEG (dx2);
++  INC_IF_NEG (dx2, result);
+   result <<= 1;
+   dx1 = x - __clipx1;
+-  INC_IF_NEG (dx1);
++  INC_IF_NEG (dx1, result);
+   return result;
+ }
+ 
+@@ -287,7 +289,7 @@
+ static INLINE int
+ gl_regioncode (CONST int x, CONST int y)
+ {
+-  int             result = 0;
++  int result = 0;
+   if (x < 0)
+     result |= 1;
+   else if (x > __clipx2)
+@@ -300,15 +302,44 @@
+ }
+ #endif
+ 
+-/* Partly based on vgalib by Tommy Frandsen */
+-/* This would be a lot faster if setpixel was inlined */
++#define line_loop_linear_a(m,i,u,v)	\
++	    {    \
++	    int d = ay - (ax >> 1);	\
++	    if ((x = abs (dx)))	\
++		do {	\
++		    i;	\
++		    if (d m 0) {	\
++			vp v;	\
++			d -= ax;	\
++		    }	\
++		    vp u;	\
++		    d += ay;	\
++		} while (--x);    \
++	    }
++
++#define line_loop_linear_b(m,i,u,v)	\
++		{    \
++		int d = ax - (ay >> 1);	\
++		if ((y = abs (dy)))	\
++		    do {	\
++			i;	\
++			if (d m 0) {	\
++			    vp u;	\
++			    d -= ay;	\
++			}	\
++			vp v;	\
++			d += ax;	\
++		    } while (--y);    \
++		}
++
++/* Partly based on the work which was partly based on vgalib by Tommy Frandsen */
++/* This is a lot faster now that setpixel is inlined */
+ 
+ void
+ Line (int x1, int y1, int x2, int y2, int c)
+ {
+-  int             dx, dy, ax, ay, sx, sy, x, y;
+-  int             syp;
+-  char           *point;
++  int dx, dy, ax, ay, sx, sy, x, y;
++  unsigned char *vp = NULL;
+   if (!shm)
+     {
+       qLine (x1, y1, x2, y2, c);
+@@ -319,8 +350,8 @@
+   if (Clipping)
+     for (;;)
+       {
+-	int             r1 = gl_regioncode (x1, y1);
+-	int             r2 = gl_regioncode (x2, y2);
++	int r1 = gl_regioncode (x1, y1);
++	int r2 = gl_regioncode (x2, y2);
+ 	if (!(r1 | r2))
+ 	  break;		/* completely inside */
+ 	if (r1 & r2)
+@@ -333,38 +364,22 @@
+ 	  }
+ 	if (r1 & 1)
+ 	  {			/* left */
+-#ifdef __i386__
+ 	    y1 += muldiv64 (__clipx1 - x1, y2 - y1, x2 - x1);
+-#else
+-	    y1 += (long) (__clipx1 - x1) * (long) (y2 - y1) / (long) (x2 - x1);
+-#endif
+ 	    x1 = __clipx1;
+ 	  }
+ 	else if (r1 & 2)
+ 	  {			/* right */
+-#ifdef __i386__
+ 	    y1 += muldiv64 (__clipx2 - x1, y2 - y1, x2 - x1);
+-#else
+-	    y1 += (long) (__clipx2 - x1) * (long) (y2 - y1) / (long) (x2 - x1);
+-#endif
+ 	    x1 = __clipx2;
+ 	  }
+ 	else if (r1 & 4)
+ 	  {			/* top */
+-#ifdef __i386__
+ 	    x1 += muldiv64 (__clipy1 - y1, x2 - x1, y2 - y1);
+-#else
+-	    x1 += (long) (__clipy1 - y1) * (long) (x2 - x1) / (long) (y2 - y1);
+-#endif
+ 	    y1 = __clipy1;
+ 	  }
+ 	else if (r1 & 8)
+ 	  {			/* bottom */
+-#ifdef __i386__
+ 	    x1 += muldiv64 (__clipy2 - y1, x2 - x1, y2 - y1);
+-#else
+-	    x1 += (long) (__clipy2 - y1) * (long) (x2 - x1) / (long) (y2 - y1);
+-#endif
+ 	    y1 = __clipy2;
+ 	  }
+       }
+@@ -377,45 +392,66 @@
+   x = x1;
+   y = y1;
+ 
+-  point = VScreenToBuffer (backscreen) + x + y * MAPWIDTH;
++#define insert_pixel_1 *((unsigned char *) vp) = c;
++
++  vp = VScreenToBuffer (backscreen) + y * MAPWIDTH + x;
+   if (ax > ay)
+     {
+-      int             d = ay - (ax >> 1);
+-      syp = sy * MAPWIDTH;
+-      while (x != x2)
++      if(sx > 0)
+ 	{
+-	  *point = c;
+-	  if (d > 0 || (d == 0 && sx == 1))
+-	    {
+-	      y += sy;
+-	      point += syp;
+-	      d -= ax;
+-	    }
+-	  x += sx;
+-	  point += sx;
+-	  d += ay;
++	  line_loop_linear_a(>=,insert_pixel_1,++,+=MAPWIDTH*sy);
++	} 
++      else 
++	{
++	  line_loop_linear_a(>,insert_pixel_1,--,+=MAPWIDTH*sy);
+ 	}
+     }
+   else
+     {
+-      int             sy = (dy >= 0) ? 1 : -1;
+-      int             d = ax - (ay >> 1);
+-      syp = sy * MAPWIDTH;
+-      while (y != y2)
++      if(sy > 0)
++	{
++	  line_loop_linear_b(>=,insert_pixel_1,+=sx,+=MAPWIDTH);
++	} 
++      else 
+ 	{
+-	  *(point) = c;
+-	  if (d > 0 || (d == 0 && sy == 1))
++	  line_loop_linear_b(>,insert_pixel_1,+=sx,-=MAPWIDTH);
++	}
++    }
++  insert_pixel_1;
++ 
++  if (!vp)
++    {
++      if (ax > ay)
++	{
++	  int d = ay - (ax >> 1);
++	  while (x != x2)
+ 	    {
++	      insert_pixel_1;
++	      if (d > 0 || (d == 0 && sx == 1))
++		{
++		  y += sy;
++		  d -= ax;
++		}
+ 	      x += sx;
+-	      point += sx;
+-	      d -= ay;
++	      d += ay;
++	    }
++	} 
++      else
++	{
++	  int d = ax - (ay >> 1);
++	  while (y != y2)
++	    {
++	      insert_pixel_1;
++	      if (d > 0 || (d == 0 && sy == 1))
++		{
++		  x += sx;
++		  d -= ay;
++		}
++	      y += sy;
++	      d += ax;
+ 	    }
+-	  y += sy;
+-	  point += syp;
+-	  d += ax;
+ 	}
++      insert_pixel_1;
+     }
+-  *(point) = c;
+-  point++;
+ }
+ #endif
+--- koules1.4/Iconfig	2003-07-12 00:20:13.000000000 -0400
++++ koules1.4-gcc3/Iconfig	2003-07-12 00:20:45.000000000 -0400
+@@ -36,7 +36,7 @@
+ /* directories*/
+ KOULESDIR		=/usr/bin/X11
+ SOUNDDIR		=/usr/local/lib/koules
+-MANDIR			=/usr/local/man/man6
++MANDIR			=/usr/share/man/man6
+ 
+ /*You need some extra libraryes for BSD sockets compatibility?*/
+ /* TOP_INCLUDES =                       /* Sun users with GCC need this */
diff --git a/koules-1.4-gcc3.patch.bz2 b/koules-1.4-gcc3.patch.bz2
deleted file mode 100644
index a01b9eef8759..000000000000
--- a/koules-1.4-gcc3.patch.bz2
+++ /dev/null