diff --git a/.cvsignore b/.cvsignore
index 04b5a21..9ee38a5 100644
--- a/.cvsignore
+++ b/.cvsignore
@@ -1,2 +1 @@
-fpc-2.0.0.compiler.bin.tar.gz
-fpc-2.0.0.source.tar.gz
+fpcbuild-2.0.2.tar.bz2
diff --git a/fpc-2.0.0-G5.patch b/fpc-2.0.0-G5.patch
deleted file mode 100644
index cad5046..0000000
--- a/fpc-2.0.0-G5.patch
+++ /dev/null
@@ -1,379 +0,0 @@
-Index: rtl/powerpc/powerpc.inc
-===================================================================
---- rtl/powerpc/powerpc.inc	(revision 830)
-+++ rtl/powerpc/powerpc.inc	(working copy)
-@@ -203,374 +203,7 @@
- end;
- {$endif MACOS}
- 
--{****************************************************************************
--                                Move / Fill
--****************************************************************************}
- 
--{$ifndef FPC_SYSTEM_HAS_MOVE}
--{$define FPC_SYSTEM_HAS_MOVE}
--procedure Move(const source;var dest;count:longint);[public, alias: 'FPC_MOVE'];assembler; nostackframe;
--asm
--          {  count <= 0 ?  }
--          cmpwi   cr0,r5,0
--          {  check if we have to do the move backwards because of overlap  }
--          sub     r10,r4,r3
--          {  carry := boolean(dest-source < count) = boolean(overlap) }
--          subc    r10,r10,r5
--
--          {  count < 15 ? (to decide whether we will move dwords or bytes  }
--          cmpwi   cr1,r5,15
--
--          {  if overlap, then r10 := -1 else r10 := 0  }
--          subfe   r10,r10,r10
--
--          {  count < 63 ? (32 + max. alignment (31) }
--          cmpwi   cr7,r5,63
--
--          {  if count <= 0, stop  }
--          ble     cr0,.LMoveDone
--
--          {  load the begin of the source in the data cache }
--          dcbt    0,r3
--          { and the dest as well }
--          dcbtst  0,r4
--
--          {  if overlap, then r0 := count else r0 := 0  }
--          and     r0,r5,r10
--          {  if overlap, then point source and dest to the end  }
--          add     r3,r3,r0
--          add     r4,r4,r0
--          {  if overlap, then r6 := 0, else r6 := -1  }
--          not     r6,r10
--          {  if overlap, then r10 := -2, else r10 := 0  }
--          slwi    r10,r10,1
--          {  if overlap, then r10 := -1, else r10 := 1  }
--          addi    r10,r10,1
--
--          {  if count < 15, copy everything byte by byte  }
--          blt     cr1,.LMoveBytes
--
--          {  if no overlap, then source/dest += -1, otherwise they stay }
--          {  After the next instruction, r3/r4 + r10 = next position to }
--          {  load/store from/to                                         }
--          add     r3,r3,r6
--          add     r4,r4,r6
--
--          {  otherwise, guarantee 4 byte alignment for dest for starters  }
--.LMove4ByteAlignLoop:
--          lbzux   r0,r3,r10
--          stbux   r0,r4,r10
--          {  is dest now 4 aligned?  }
--          andi.   r0,r4,3
--          subi    r5,r5,1
--          {  while not aligned, continue  }
--          bne     cr0,.LMove4ByteAlignLoop
--
--{$ifndef ppc603}
--          { check for 32 byte alignment }
--          andi.   r7,r4,31
--{$endif non ppc603}
--          { we are going to copy one byte again (the one at the newly }
--          { aligned address), so increase count byte 1                }
--          addi    r5,r5,1
--          { count div 4 for number of dwords to copy }
--          srwi    r0,r5,2
--          {  if 11 <= count < 63, copy using dwords }
--          blt     cr7,.LMoveDWords
--
--{$ifndef ppc603}
--          { # of dwords to copy to reach 32 byte alignment (*4) }
--          { (depends on forward/backward copy)                  }
--
--          { if forward copy, r6 = -1 -> r8 := 32 }
--          { if backward copy, r6 = 0 -> r8 := 0  }
--          rlwinm  r8,r6,0,31-6+1,31-6+1
--          { if forward copy, we have to copy 32 - unaligned count bytes }
--          { if backward copy unaligned count bytes                      }
--          sub     r7,r8,r7
--          { if backward copy, the calculated value is now negate -> }
--          { make it positive again                                 }
--          not     r8, r6
--          add     r7, r7, r8
--          xor     r7, r7, r8
--{$endif not ppc603}
--
--          { multiply the update count with 4 }
--          slwi    r10,r10,2
--          slwi    r6,r6,2
--          { and adapt the source and dest }
--          add     r3,r3,r6
--          add     r4,r4,r6
--
--{$ifndef ppc603}
--          beq     cr0,.LMove32BytesAligned
--.L32BytesAlignMoveLoop:
--          {  count >= 39 -> align to 8 byte boundary and then use the FPU  }
--          {  since we're already at 4 byte alignment, use dword store      }
--          subic.  r7,r7,4
--          lwzux   r0,r3,r10
--          subi    r5,r5,4
--          stwux   r0,r4,r10
--          bne     .L32BytesAlignMoveLoop
--
--.LMove32BytesAligned:
--          { count div 32 ( >= 1, since count was >=63 }
--          srwi    r0,r5,5
--          { remainder }
--          andi.   r5,r5,31
--          { to decide if we will do some dword stores (instead of only }
--          { byte stores) afterwards or not                             }
--{$else not ppc603}
--          srwi    r0,r5,4
--          andi.   r5,r5,15
--{$endif not ppc603}
--          cmpwi   cr1,r5,11
--          mtctr   r0
--
--          {  r0 := count div 4, will be moved to ctr when copying dwords  }
--          srwi    r0,r5,2
--
--{$ifndef ppc603}
--          {  adjust the update count: it will now be 8 or -8 depending on overlap  }
--          slwi    r10,r10,1
--
--          {  adjust source and dest pointers: because of the above loop, dest is now   }
--          {  aligned to 8 bytes. So if we add r6 we will still have an 8 bytes         }
--          { aligned address)                                                           }
--          add     r3,r3,r6
--          add     r4,r4,r6
--
--          slwi    r6,r6,1
--
--          { the dcbz offset must give a 32 byte aligned address when added   }
--          { to the current dest address and its address must point to the    }
--          { bytes that will be overwritten in the current iteration. In case }
--          { of a forward loop, the dest address has currently an offset of   }
--          { -8 compared to the bytes that will be overwritten (and r6 = -8). }
--          { In case of a backward of a loop, the dest address currently has  }
--          { an offset of +32 compared to the bytes that will be overwritten  }
--          { (and r6 = 0). So the forward dcbz offset must become +8 and the  }
--          { backward -32 -> (-r6 * 5) - 32 gives the correct offset          }
--          slwi    r7,r6,2
--          add     r7,r7,r6
--          neg     r7,r7
--          subi    r7,r7,32
--
--.LMove32ByteDcbz:
--          lfdux   f0,r3,r10
--          lfdux   f1,r3,r10
--          lfdux   f2,r3,r10
--          lfdux   f3,r3,r10
--          { must be done only now, in case source and dest are less than }
--          { 32 bytes apart!                                              }
--          dcbz    r4,r7
--          stfdux  f0,r4,r10
--          stfdux  f1,r4,r10
--          stfdux  f2,r4,r10
--          stfdux  f3,r4,r10
--          bdnz    .LMove32ByteDcbz
--.LMove32ByteLoopDone:
--{$else not ppc603}
--.LMove16ByteLoop:
--          lwzux   r11,r3,r10
--          lwzux   r7,r3,r10
--          lwzux   r8,r3,r10
--          lwzux   r9,r3,r10
--          stwux   r11,r4,r10
--          stwux   r7,r4,r10
--          stwux   r8,r4,r10
--          stwux   r9,r4,r10
--          bdnz    .LMove16ByteLoop
--{$endif not ppc603}
--
--          { cr0*4+eq is true if "count and 31" = 0 }
--          beq     cr0,.LMoveDone
--
--          {  make r10 again -1 or 1, but first adjust source/dest pointers }
--          sub     r3,r3,r6
--          sub     r4,r4,r6
--{$ifndef ppc603}
--          srawi   r10,r10,3
--          srawi   r6,r6,3
--{$else not ppc603}
--          srawi   r10,r10,2
--          srawi   r6,r6,2
--{$endif not ppc603}
--
--          { cr1 contains whether count <= 11 }
--          ble     cr1,.LMoveBytes
--
--.LMoveDWords:
--          mtctr   r0
--          andi.   r5,r5,3
--          {  r10 * 4  }
--          slwi    r10,r10,2
--          slwi    r6,r6,2
--          add     r3,r3,r6
--          add     r4,r4,r6
--
--.LMoveDWordsLoop:
--          lwzux   r0,r3,r10
--          stwux   r0,r4,r10
--          bdnz    .LMoveDWordsLoop
--
--          beq     cr0,.LMoveDone
--          {  make r10 again -1 or 1  }
--          sub     r3,r3,r6
--          sub     r4,r4,r6
--          srawi   r10,r10,2
--          srawi   r6,r6,2
--.LMoveBytes:
--          add     r3,r3,r6
--          add     r4,r4,r6
--          mtctr   r5
--.LMoveBytesLoop:
--          lbzux   r0,r3,r10
--          stbux   r0,r4,r10
--          bdnz    .LMoveBytesLoop
--.LMoveDone:
--end;
--{$endif FPC_SYSTEM_HAS_MOVE}
--
--
--{$ifndef FPC_SYSTEM_HAS_FILLCHAR}
--{$define FPC_SYSTEM_HAS_FILLCHAR}
--
--Procedure FillChar(var x;count:longint;value:byte);assembler;
--{ input: x in r3, count in r4, value in r5 }
--
--{$ifndef FPC_ABI_AIX}
--{ in the AIX ABI, we can use te red zone for temp storage, otherwise we have }
--{ to explicitely allocate room                                               }
--var
--  temp : packed record
--    case byte of
--      0: (l1,l2: longint);
--      1: (d: double);
--    end;
--{$endif FPC_ABI_AIX}
--asm
--        { no bytes? }
--        cmpwi     cr6,r4,0
--        { less than 15 bytes? }
--        cmpwi     cr7,r4,15
--        { less than 64 bytes? }
--        cmpwi     cr1,r4,64
--        { fill r5 with ValueValueValueValue }
--        rlwimi    r5,r5,8,16,23
--        { setup for aligning x to multiple of 4}
--        rlwinm    r10,r3,0,31-2+1,31
--        rlwimi    r5,r5,16,0,15
--        ble       cr6,.LFillCharDone
--        { get the start of the data in the cache (and mark it as "will be }
--        { modified")                                                      }
--        dcbtst    0,r3
--        subfic    r10,r10,4
--        blt       cr7,.LFillCharVerySmall
--        { just store 4 bytes instead of using a loop to align (there are }
--        { plenty of other instructions now to keep the processor busy    }
--        { while it handles the (possibly unaligned) store)               }
--        stw       r5,0(r3)
--        { r3 := align(r3,4) }
--        add       r3,r3,r10
--        { decrease count with number of bytes already stored }
--        sub       r4,r4,r10
--        blt       cr1,.LFillCharSmall
--        { if we have to fill with 0 (which happens a lot), we can simply use }
--        { dcbz for the most part, which is very fast, so make a special case }
--        { for that                                                           }
--        cmplwi    cr1,r5,0
--        { align to a multiple of 32 (and immediately check whether we aren't }
--        { already 32 byte aligned)                                           }
--        rlwinm.   r10,r3,0,31-5+1,31
--        { setup r3 for using update forms of store instructions }
--        subi      r3,r3,4
--        { get number of bytes to store }
--        subfic    r10,r10,32
--        { if already 32byte aligned, skip align loop }
--        beq       .L32ByteAlignLoopDone
--        { substract from the total count }
--        sub       r4,r4,r10
--.L32ByteAlignLoop:
--        { we were already aligned to 4 byres, so this will count down to }
--        { exactly 0                                                      }
--        subic.    r10,r10,4
--        stwu      r5,4(r3)
--        bne       .L32ByteAlignLoop
--.L32ByteAlignLoopDone:
--        { get the amount of 32 byte blocks }
--        srwi      r10,r4,5
--        { and keep the rest in r4 (recording whether there is any rest) }
--        rlwinm.   r4,r4,0,31-5+1,31
--        { move to ctr }
--        mtctr     r10
--        { check how many rest there is (to decide whether we'll use }
--        { FillCharSmall or FillCharVerySmall)                       }
--        cmplwi    cr7,r4,11
--        { if filling with zero, only use dcbz }
--        bne       cr1, .LFillCharNoZero
--        { make r3 point again to the actual store position }
--        addi      r3,r3,4
--.LFillCharDCBZLoop:
--        dcbz      0,r3
--        addi      r3,r3,32
--        bdnz      .LFillCharDCBZLoop
--        { if there was no rest, we're finished }
--        beq       .LFillCharDone
--        b         .LFillCharVerySmall
--.LFillCharNoZero:
--{$ifdef FPC_ABI_AIX}
--        stw       r5,-4(r1)
--        stw       r5,-8(r1)
--        lfd       f0,-8(r1)
--{$else FPC_ABI_AIX}
--        stw       r5,temp
--        stw       r5,temp+4
--        lfd       f0,temp
--{$endif FPC_ABI_AIX}
--        { make r3 point to address-8, so we're able to use fp double stores }
--        { with update (it's already -4 now)                                 }
--        subi      r3,r3,4
--        { load r10 with 8, so that dcbz uses the correct address }
--        li        r10, 8
--.LFillChar32ByteLoop:
--        dcbz      r3,r10
--        stfdu     f0,8(r3)
--        stfdu     f0,8(r3)
--        stfdu     f0,8(r3)
--        stfdu     f0,8(r3)
--        bdnz      .LFillChar32ByteLoop
--        { if there was no rest, we're finished }
--        beq       .LFillCharDone
--        { make r3 point again to the actual next byte that must be written }
--        addi      r3,r3,8
--        b         .LFillCharVerySmall
--.LFillCharSmall:
--        { when we arrive here, we're already 4 byte aligned }
--        { get count div 4 to store dwords }
--        srwi      r10,r4,2
--        { get ready for use of update stores }
--        subi      r3,r3,4
--        mtctr     r10
--        rlwinm.   r4,r4,0,31-2+1,31
--.LFillCharSmallLoop:
--        stwu      r5,4(r3)
--        bdnz      .LFillCharSmallLoop
--        { if nothing left, stop }
--        beq       .LFillCharDone
--        { get ready to store bytes }
--        addi      r3,r3,4
--.LFillCharVerySmall:
--        mtctr     r4
--        subi      r3,r3,1
--.LFillCharVerySmallLoop:
--        stbu      r5,1(r3)
--        bdnz      .LFillCharVerySmallLoop
--.LFillCharDone:
--end;
--{$endif FPC_SYSTEM_HAS_FILLCHAR}
--
--
- {$ifndef FPC_SYSTEM_HAS_FILLDWORD}
- {$define FPC_SYSTEM_HAS_FILLDWORD}
- procedure filldword(var x;count : longint;value : dword);
diff --git a/fpc.spec b/fpc.spec
index ac16518..9e189c5 100644
--- a/fpc.spec
+++ b/fpc.spec
@@ -1,18 +1,17 @@
 Name:           fpc
-Version:        2.0.0
-Release:        4%{?dist}
+Version:        2.0.2
+Release:        1%{?dist}
 Summary:        Free Pascal Compiler
 
 Group:          Development/Languages
 License:        GPL and modified LGPL
 URL:            http://www.freepascal.org/
-Source0:        ftp://ftp.freepascal.org/pub/fpc/dist/source-%{version}/%{name}-%{version}.source.tar.gz
-Source1:        http://www.cnoc.nl/fpc/%{name}-%{version}.compiler.bin.tar.gz
+Source0:        ftp://ftp.freepascal.org/pub/fpc/dist/source-%{version}/%{name}build-%{version}.tar.bz2
 Patch0:         %{name}-%{version}-G5.patch
 BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
 
 Requires:	gpm, glibc, ncurses, binutils
-BuildRequires:  tetex, tetex-latex, tetex-fonts, binutils, gpm-devel, glibc-devel
+BuildRequires:  fpc, tetex, tetex-latex, tetex-fonts, binutils, gpm-devel, glibc-devel
 
 %description
 
@@ -54,20 +53,12 @@ automatical-code generation purposes.
 %endif
 
 %prep
-%setup -q -a1 -n %{name}
+%setup -q -n %{name}-src-%{version}
 %patch0 
 
 %build
-# The source-files:
-mkdir -p fpcsrc
-cp -a rtl fpcsrc
-cp -a fcl fpcsrc
-cp -a packages fpcsrc
-rm -rf fpcsrc/packages/extra/amunits
-rm -rf fpcsrc/packages/extra/winunits
-find fpcsrc -name .cvsignore -exec rm '{}' ';'
-
-STARTPP=`pwd`/startcompiler/%{ppcname}
+cd fpcsrc
+STARTPP=%{ppcname}
 NEWPP=`pwd`/compiler/%{ppcname}
 NEWFPDOC=`pwd`/utils/fpdoc/fpdoc
 DATA2INC=`pwd`/utils/data2inc
@@ -79,9 +70,10 @@ make fv_smart FPC=${NEWPP}
 make packages_extra_smart FPC=${NEWPP}
 make ide_all FPC=${NEWPP}
 make utils_all FPC=${NEWPP} DATA2INC=${DATA2INC}
+cd ..
 export save_size=40000
 export pool_size=1250000
-make -C docs pdf FPC=${NEWPP} FPDOC=${NEWFPDOC}
+make -C fpcdocs pdf FPC=${NEWPP} FPDOC=${NEWFPDOC}
 
 # disable the debuginfo package
 %define debug_package %{nil}
@@ -89,6 +81,7 @@ make -C docs pdf FPC=${NEWPP} FPDOC=${NEWFPDOC}
 
 %install
 rm -rf %{buildroot}
+cd fpcsrc
 FPCMAKE=`pwd`/utils/fpcm/fpcmake
 NEWPP=`pwd`/compiler/%{ppcname}
 INSTALLOPTS="FPC=${NEWPP} FPCMAKE=${FPCMAKE} \
@@ -106,23 +99,28 @@ make fcl_distinstall ${INSTALLOPTS}
 make fv_distinstall ${INSTALLOPTS}
 make ide_distinstall ${INSTALLOPTS}
 make utils_distinstall ${INSTALLOPTS}
-
-make doc_install ${INSTALLOPTS}
-make -C docs pdfinstall ${INSTALLOPTS}
-make man_install ${INSTALLOPTS} INSTALL_MANDIR=%{buildroot}%{_mandir}
+cd ../install
+make -C doc ${INSTALLOPTS}
+make -C man ${INSTALLOPTS} INSTALL_MANDIR=%{buildroot}%{_mandir}
+cd ..
+make -C fpcdocs pdfinstall ${INSTALLOPTS}
 
 # create link
 ln -sf ../%{_lib}/%{name}/%{version}/%{ppcname} %{buildroot}%{_bindir}/%{ppcname}
 
-# Include the COPYING-information in the documentation
-cp -a compiler/COPYING %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING
-cp -a rtl/COPYING %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING.rtl
-cp -a fcl/COPYING %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING.fcl
-cp -a rtl/COPYING.FPC %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING.FPC
+# Include the COPYING-information for the fcl/rtl in the documentation
+cp -a fpcsrc/compiler/COPYING %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING
+cp -a fpcsrc/rtl/COPYING %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING.rtl
+cp -a fpcsrc/fcl/COPYING %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING.fcl
+cp -a fpcsrc/rtl/COPYING.FPC %{buildroot}%{_defaultdocdir}/%{name}-%{version}/COPYING.FPC
 
 # The source-files:
 mkdir -p %{buildroot}%{_datadir}/fpcsrc
-cp -a fpcsrc/* %{buildroot}%{_datadir}/fpcsrc/
+rm -rf fpcsrc/packages/extra/amunits
+rm -rf fpcsrc/packages/extra/winunits
+cp -a fpcsrc/rtl %{buildroot}%{_datadir}/fpcsrc
+cp -a fpcsrc/fcl %{buildroot}%{_datadir}/fpcsrc
+cp -a fpcsrc/packages %{buildroot}%{_datadir}/fpcsrc
 
 # Workaround:
 # newer rpm versions do not allow garbage
@@ -158,6 +156,9 @@ rm -rf %{buildroot}
 %{_datadir}/fpcsrc
 
 %changelog
+* Tue Dec 20 2005 Joost van der Sluis <joost@cnoc.nl> 2.0.2-1
+- Updated to version 2.0.2
+
 * Wed Aug 17 2005 Joost van der Sluis <joost@cnoc.nl> 2.0.0-4
 - Added %%{?dist} to release.
 
diff --git a/sources b/sources
index cb14def..bd930b7 100644
--- a/sources
+++ b/sources
@@ -1,2 +1 @@
-fd5730c59bb5a87e5828568b7d039cb5  fpc-2.0.0.compiler.bin.tar.gz
-3f9c64d0146a3631f6963fd7477776d1  fpc-2.0.0.source.tar.gz
+b88893bc005c4404197ae55ef3c0de30  fpcbuild-2.0.2.tar.bz2