Add GPC - GNU Pascal Compiler. Finally we have a Pascal compiler in the

ports collection!  :-)

PR:			17578
Submitted by:		Anton N. Breusov <antonz@library.ntu-kpi.kiev.ua>
No objections from:	asami, obrien

25 files changed, 2176 insertions, 0 deletions

diff --git a/lang/Makefile b/lang/Makefile
index c1bbc624538d..c2e4fbaf414a 100644
--- a/lang/Makefile
+++ b/lang/Makefile
@@ -35,6 +35,7 @@
     SUBDIR += glibstdc++28
     SUBDIR += gnat
     SUBDIR += gnomeobjc
+    SUBDIR += gpc
     SUBDIR += guile
     SUBDIR += guileobjc
     SUBDIR += hugs
diff --git a/lang/gpc/Makefile b/lang/gpc/Makefile
new file mode 100644
index 000000000000..7bed65aae478
--- /dev/null
+++ b/lang/gpc/Makefile
@@ -0,0 +1,36 @@
+# Ports collection makefile for:	gpc
+# Date created:				January 27, 1999
+# Whom:					Berend de Boer <berend@pobox.com>
+#
+# $FreeBSD$
+
+PORTNAME=	gpc
+PORTVERSION=	2.0
+CATEGORIES=	lang
+MASTER_SITES=	ftp://agnes.dida.physik.uni-essen.de/gnu-pascal/current/
+DISTNAME=	gpc-19990118
+
+MAINTAINER=	antonz@library.ntu-kpi.kiev.ua
+
+BUILD_DEPENDS=	nonexistent:${PORTSDIR}/lang/gcc28:patch
+
+WRKSRC=		${WRKDIR}/gpc
+MAKE_ARGS=	LANGUAGES=pascal
+USE_AUTOCONF=	yes
+USE_GMAKE=	yes
+ALL_TARGET=	bootstrap
+INSTALL_TARGET=	pascal.install
+
+MAN1=		gpc.1
+
+.include <bsd.port.pre.mk>
+
+GNUHOST=	${ARCH}--freebsd${OSREL}
+
+PLIST_SUB=	GNUHOST=${GNUHOST}
+CONFIGURE_ARGS=	--with-gxx-include-dir=${PREFIX}/lib/gcc-lib/${GNUHOST}/2.8.1/include/g++
+
+post-extract:
+	@(${CP} -R ${WRKDIRPREFIX}${PORTSDIR}/lang/gcc28/work/gcc-2.8.1/* ${WRKSRC})
+
+.include <bsd.port.post.mk>
diff --git a/lang/gpc/distinfo b/lang/gpc/distinfo
new file mode 100644
index 000000000000..d61aaa8ef219
--- /dev/null
+++ b/lang/gpc/distinfo
@@ -0,0 +1 @@
+MD5 (gpc-19990118.tar.gz) = 3c818f9f7730378320dd04a03dbe8267
diff --git a/lang/gpc/files/patch-aa b/lang/gpc/files/patch-aa
new file mode 100644
index 000000000000..09f88e8e0e8e
--- /dev/null
+++ b/lang/gpc/files/patch-aa
@@ -0,0 +1,166 @@
+*** Makefile.in.orig	Tue Mar  3 03:54:31 1998
+--- Makefile.in		Thu Mar 23 14:52:24 2000
+***************
+*** 369,375 ****
+  
+  # List of things which should already be built whenever we try to use xgcc
+  # to compile anything (without linking).
+! GCC_PASSES=xgcc cc1 cpp $(EXTRA_PASSES)
+  
+  # List of things which should already be built whenever we try to use xgcc
+  # to link anything.
+--- 369,375 ----
+  
+  # List of things which should already be built whenever we try to use xgcc
+  # to compile anything (without linking).
+! GCC_PASSES=xgcc$(exeext) cc1$(exeext) cpp$(exeext) $(EXTRA_PASSES)
+  
+  # List of things which should already be built whenever we try to use xgcc
+  # to link anything.
+***************
+*** 729,746 ****
+  all.cross: native gcc-cross specs stmp-headers $(LIBGCC) $(STMP_FIXPROTO) \
+  	$(LIBGCC1_TEST) $(EXTRA_PARTS) lang.all.cross
+  # This is what to compile if making gcc with a cross-compiler.
+! all.build: native xgcc $(EXTRA_PARTS) lang.all.build
+  # This is what must be made before installing GCC and converting libraries.
+! start.encap: native xgcc specs $(LIBGCC1) xlimits.h lang.start.encap
+  # These can't be made until after GCC can run.
+  rest.encap: stmp-headers $(LIBGCC) $(STMP_FIXPROTO) $(EXTRA_PARTS) lang.rest.encap
+  # This is what is made with the host's compiler
+  # whether making a cross compiler or not.
+! native: config.status auto-config.h cpp $(LANGUAGES) \
+  	$(EXTRA_PASSES) $(EXTRA_PROGRAMS) $(USE_COLLECT2)
+  
+  # Define the names for selecting languages in LANGUAGES.
+! C c: cc1
+  PROTO: proto
+  
+  # Tell GNU make these are phony targets.
+--- 729,746 ----
+  all.cross: native gcc-cross specs stmp-headers $(LIBGCC) $(STMP_FIXPROTO) \
+  	$(LIBGCC1_TEST) $(EXTRA_PARTS) lang.all.cross
+  # This is what to compile if making gcc with a cross-compiler.
+! all.build: native xgcc$(exeext) $(EXTRA_PARTS) lang.all.build
+  # This is what must be made before installing GCC and converting libraries.
+! start.encap: native xgcc$(exeext) specs $(LIBGCC1) xlimits.h lang.start.encap
+  # These can't be made until after GCC can run.
+  rest.encap: stmp-headers $(LIBGCC) $(STMP_FIXPROTO) $(EXTRA_PARTS) lang.rest.encap
+  # This is what is made with the host's compiler
+  # whether making a cross compiler or not.
+! native: config.status auto-config.h cpp$(exeext) $(LANGUAGES) \
+  	$(EXTRA_PASSES) $(EXTRA_PROGRAMS) $(USE_COLLECT2)
+  
+  # Define the names for selecting languages in LANGUAGES.
+! C c: cc1$(exeext)
+  PROTO: proto
+  
+  # Tell GNU make these are phony targets.
+***************
+*** 756,762 ****
+  	@echo "Testing libgcc1.  Ignore linker warning messages."
+  	$(GCC_FOR_TARGET) $(GCC_CFLAGS) libgcc1-test.o -o libgcc1-test \
+  	  -nostartfiles -nostdlib `$(GCC_FOR_TARGET) --print-libgcc-file-name`
+! libgcc1-test.o: libgcc1-test.c native xgcc
+  	$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(ALL_CPPFLAGS) -c $(srcdir)/libgcc1-test.c
+  
+  # Recompile all the language-independent object files.
+--- 756,762 ----
+  	@echo "Testing libgcc1.  Ignore linker warning messages."
+  	$(GCC_FOR_TARGET) $(GCC_CFLAGS) libgcc1-test.o -o libgcc1-test \
+  	  -nostartfiles -nostdlib `$(GCC_FOR_TARGET) --print-libgcc-file-name`
+! libgcc1-test.o: libgcc1-test.c native xgcc$(exeext)
+  	$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(ALL_CPPFLAGS) -c $(srcdir)/libgcc1-test.c
+  
+  # Recompile all the language-independent object files.
+***************
+*** 771,793 ****
+  # We call this executable `xgcc' rather than `gcc'
+  # to avoid confusion if the current directory is in the path
+  # and CC is `gcc'.  It is renamed to `gcc' when it is installed.
+! xgcc: gcc.o version.o choose-temp.o pexecute.o prefix.o version.o \
+     $(LIBDEPS) $(EXTRA_GCC_OBJS)
+  	$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ gcc.o prefix.o version.o \
+  	  choose-temp.o pexecute.o $(EXTRA_GCC_OBJS) $(LIBS)
+  
+  # Dump a specs file to make -B./ read these specs over installed ones.
+! specs: xgcc
+  	$(GCC_FOR_TARGET) -dumpspecs > tmp-specs
+  	mv tmp-specs specs
+  
+  # We do want to create an executable named `xgcc', so we can use it to
+  # compile libgcc2.a.
+  # Also create gcc-cross, so that install-common will install properly.
+! gcc-cross: xgcc
+  	cp xgcc$(exeext) gcc-cross$(exeext)
+  
+! cc1: $(P) $(C_OBJS) $(OBJS) $(BC_OBJS) $(LIBDEPS)
+  	$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ $(C_OBJS) $(OBJS) $(BC_OBJS) $(LIBS)
+  
+  # Copy float.h from its source.
+--- 771,793 ----
+  # We call this executable `xgcc' rather than `gcc'
+  # to avoid confusion if the current directory is in the path
+  # and CC is `gcc'.  It is renamed to `gcc' when it is installed.
+! xgcc$(exeext): gcc.o version.o choose-temp.o pexecute.o prefix.o version.o \
+     $(LIBDEPS) $(EXTRA_GCC_OBJS)
+  	$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ gcc.o prefix.o version.o \
+  	  choose-temp.o pexecute.o $(EXTRA_GCC_OBJS) $(LIBS)
+  
+  # Dump a specs file to make -B./ read these specs over installed ones.
+! specs: xgcc$(exeext)
+  	$(GCC_FOR_TARGET) -dumpspecs > tmp-specs
+  	mv tmp-specs specs
+  
+  # We do want to create an executable named `xgcc', so we can use it to
+  # compile libgcc2.a.
+  # Also create gcc-cross, so that install-common will install properly.
+! gcc-cross: xgcc$(exeext)
+  	cp xgcc$(exeext) gcc-cross$(exeext)
+  
+! cc1$(exeext): $(P) $(C_OBJS) $(OBJS) $(BC_OBJS) $(LIBDEPS)
+  	$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ $(C_OBJS) $(OBJS) $(BC_OBJS) $(LIBS)
+  
+  # Copy float.h from its source.
+***************
+*** 1739,1749 ****
+  # Remake cpp and protoize.
+  
+  # Making the preprocessor
+! cpp: $(CCCP)
+  	-rm -f cpp$(exeext)
+  	ln $(CCCP)$(exeext) cpp$(exeext) > /dev/null 2>&1 \
+  	 || cp $(CCCP)$(exeext) cpp$(exeext)
+! cccp: cccp.o cexp.o version.o prefix.o $(LIBDEPS)
+  	$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ cccp.o cexp.o prefix.o \
+  	  version.o $(LIBS)
+  cexp.o: $(srcdir)/cexp.c $(CONFIG_H)
+--- 1739,1749 ----
+  # Remake cpp and protoize.
+  
+  # Making the preprocessor
+! cpp$(exeext): $(CCCP)$(exeext)
+  	-rm -f cpp$(exeext)
+  	ln $(CCCP)$(exeext) cpp$(exeext) > /dev/null 2>&1 \
+  	 || cp $(CCCP)$(exeext) cpp$(exeext)
+! cccp$(exeext): cccp.o cexp.o version.o prefix.o $(LIBDEPS)
+  	$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ cccp.o cexp.o prefix.o \
+  	  version.o $(LIBS)
+  cexp.o: $(srcdir)/cexp.c $(CONFIG_H)
+***************
+*** 2248,2254 ****
+  
+  # Install the driver program as $(target_alias)-gcc
+  # and also as either gcc (if native) or $(tooldir)/bin/gcc.
+! install-driver: xgcc
+  	-if [ -f gcc-cross$(exeext) ] ; then \
+  	  rm -f $(bindir)/$(GCC_CROSS_NAME)$(exeext); \
+  	  $(INSTALL_PROGRAM) gcc-cross$(exeext) $(bindir)/$(GCC_CROSS_NAME)$(exeext); \
+--- 2248,2254 ----
+  
+  # Install the driver program as $(target_alias)-gcc
+  # and also as either gcc (if native) or $(tooldir)/bin/gcc.
+! install-driver: xgcc$(exeext)
+  	-if [ -f gcc-cross$(exeext) ] ; then \
+  	  rm -f $(bindir)/$(GCC_CROSS_NAME)$(exeext); \
+  	  $(INSTALL_PROGRAM) gcc-cross$(exeext) $(bindir)/$(GCC_CROSS_NAME)$(exeext); \
diff --git a/lang/gpc/files/patch-ab b/lang/gpc/files/patch-ab
new file mode 100644
index 000000000000..5ab24eeff657
--- /dev/null
+++ b/lang/gpc/files/patch-ab
@@ -0,0 +1,168 @@
+*** ansidecl.h.orig	Thu Jan  1 03:00:00 1970
+--- ansidecl.h		Thu Mar 23 16:03:22 2000
+***************
+*** 0 ****
+--- 1,163 ----
++ /* ANSI and traditional C compatability macros
++    Copyright 1991, 1992, 1996 Free Software Foundation, Inc.
++    This file is part of the GNU C Library.
++ 
++ This program is free software; you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation; either version 2 of the License, or
++ (at your option) any later version.
++ 
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ GNU General Public License for more details.
++ 
++ You should have received a copy of the GNU General Public License
++ along with this program; if not, write to the Free Software
++ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
++ 
++ /* ANSI and traditional C compatibility macros
++ 
++    ANSI C is assumed if __STDC__ is #defined.
++ 
++    Macro	ANSI C definition	Traditional C definition
++    -----	---- - ----------	----------- - ----------
++    PTR		`void *'		`char *'
++    LONG_DOUBLE	`long double'		`double'
++    VOLATILE	`volatile'		`'
++    SIGNED	`signed'		`'
++    PTRCONST	`void *const'		`char *'
++    ANSI_PROTOTYPES  1			not defined
++ 
++    CONST is also defined, but is obsolete.  Just use const.
++ 
++    obsolete --     DEFUN (name, arglist, args)
++ 
++ 	Defines function NAME.
++ 
++ 	ARGLIST lists the arguments, separated by commas and enclosed in
++ 	parentheses.  ARGLIST becomes the argument list in traditional C.
++ 
++ 	ARGS list the arguments with their types.  It becomes a prototype in
++ 	ANSI C, and the type declarations in traditional C.  Arguments should
++ 	be separated with `AND'.  For functions with a variable number of
++ 	arguments, the last thing listed should be `DOTS'.
++ 
++    obsolete --     DEFUN_VOID (name)
++ 
++ 	Defines a function NAME, which takes no arguments.
++ 
++    obsolete --     EXFUN (name, (prototype))	-- obsolete.
++ 
++ 	Replaced by PARAMS.  Do not use; will disappear someday soon.
++ 	Was used in external function declarations.
++ 	In ANSI C it is `NAME PROTOTYPE' (so PROTOTYPE should be enclosed in
++ 	parentheses).  In traditional C it is `NAME()'.
++ 	For a function that takes no arguments, PROTOTYPE should be `(void)'.
++ 
++    obsolete --     PROTO (type, name, (prototype)    -- obsolete.
++ 
++ 	This one has also been replaced by PARAMS.  Do not use.
++ 
++    PARAMS ((args))
++ 
++ 	We could use the EXFUN macro to handle prototype declarations, but
++ 	the name is misleading and the result is ugly.  So we just define a
++ 	simple macro to handle the parameter lists, as in:
++ 
++ 	      static int foo PARAMS ((int, char));
++ 
++ 	This produces:  `static int foo();' or `static int foo (int, char);'
++ 
++ 	EXFUN would have done it like this:
++ 
++ 	      static int EXFUN (foo, (int, char));
++ 
++ 	but the function is not external...and it's hard to visually parse
++ 	the function name out of the mess.   EXFUN should be considered
++ 	obsolete; new code should be written to use PARAMS.
++ 
++    DOTS is also obsolete.
++ 
++    Examples:
++ 
++ 	extern int printf PARAMS ((const char *format, ...));
++ */
++ 
++ #ifndef	_ANSIDECL_H
++ 
++ #define	_ANSIDECL_H	1
++ 
++ 
++ /* Every source file includes this file,
++    so they will all get the switch for lint.  */
++ /* LINTLIBRARY */
++ 
++ 
++ #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32)
++ /* All known AIX compilers implement these things (but don't always
++    define __STDC__).  The RISC/OS MIPS compiler defines these things
++    in SVR4 mode, but does not define __STDC__.  */
++ 
++ #define	PTR		void *
++ #define	PTRCONST	void *CONST
++ #define	LONG_DOUBLE	long double
++ 
++ #ifndef IN_GCC
++ #define	AND		,
++ #define	NOARGS		void
++ #define	VOLATILE	volatile
++ #define	SIGNED		signed
++ #endif /* ! IN_GCC */
++ 
++ #define PARAMS(paramlist)		paramlist
++ #define ANSI_PROTOTYPES			1
++ 
++ #define VPARAMS(ARGS)			ARGS
++ #define VA_START(va_list,var)		va_start(va_list,var)
++ 
++ /* These are obsolete.  Do not use.  */
++ #ifndef IN_GCC
++ #define CONST				const
++ #define DOTS				, ...
++ #define PROTO(type, name, arglist)	type name arglist
++ #define EXFUN(name, proto)		name proto
++ #define DEFUN(name, arglist, args)	name(args)
++ #define DEFUN_VOID(name)		name(void)
++ #endif /* ! IN_GCC */
++ 
++ #else	/* Not ANSI C.  */
++ 
++ #define	PTR		char *
++ #define	PTRCONST	PTR
++ #define	LONG_DOUBLE	double
++ 
++ #ifndef IN_GCC
++ #define	AND		;
++ #define	NOARGS
++ #define	VOLATILE
++ #define	SIGNED
++ #endif /* !IN_GCC */
++ 
++ #ifndef const /* some systems define it in header files for non-ansi mode */
++ #define	const
++ #endif
++ 
++ #define PARAMS(paramlist)		()
++ 
++ #define VPARAMS(ARGS)			(va_alist) va_dcl
++ #define VA_START(va_list,var)		va_start(va_list)
++ 
++ /* These are obsolete.  Do not use.  */
++ #ifndef IN_GCC
++ #define CONST
++ #define DOTS
++ #define PROTO(type, name, arglist)	type name ()
++ #define EXFUN(name, proto)		name()
++ #define DEFUN(name, arglist, args)	name arglist args;
++ #define DEFUN_VOID(name)		name()
++ #endif /* ! IN_GCC */
++ 
++ #endif	/* ANSI C.  */
++ 
++ #endif	/* ansidecl.h	*/
diff --git a/lang/gpc/files/patch-ac b/lang/gpc/files/patch-ac
new file mode 100644
index 000000000000..32b12cc475b7
--- /dev/null
+++ b/lang/gpc/files/patch-ac
@@ -0,0 +1,33 @@
+*** convert.c.orig	Thu Aug  7 13:44:17 1997
+--- convert.c		Thu Mar 23 14:54:56 2000
+***************
+*** 288,294 ****
+--- 288,299 ----
+  
+  		/* Can't do arithmetic in enumeral types
+  		   so use an integer type that will hold the values.  */
++ #ifdef GPC
++               if (TREE_CODE (typex) == ENUMERAL_TYPE
++                   || TREE_CODE (typex) == BOOLEAN_TYPE)
++ #else /* not GPC */
+  		if (TREE_CODE (typex) == ENUMERAL_TYPE)
++ #endif /* not GPC */
+  		  typex = type_for_size (TYPE_PRECISION (typex),
+  					 TREE_UNSIGNED (typex));
+  
+***************
+*** 326,332 ****
+--- 331,343 ----
+  
+  	    /* Can't do arithmetic in enumeral types
+  	       so use an integer type that will hold the values.  */
++ #ifdef GPC
++           if (TREE_CODE (typex) == ENUMERAL_TYPE
++               || TREE_CODE (typex) == CHAR_TYPE
++               || TREE_CODE (typex) == BOOLEAN_TYPE)
++ #else /* not GPC */
+  	    if (TREE_CODE (typex) == ENUMERAL_TYPE)
++ #endif /* not GPC */
+  	      typex = type_for_size (TYPE_PRECISION (typex),
+  				     TREE_UNSIGNED (typex));
+  
diff --git a/lang/gpc/files/patch-ad b/lang/gpc/files/patch-ad
new file mode 100644
index 000000000000..9ae4dab171fa
--- /dev/null
+++ b/lang/gpc/files/patch-ad
@@ -0,0 +1,39 @@
+*** dbxout.c.orig	Thu Oct 23 15:03:03 1997
+--- dbxout.c		Thu Mar 23 14:58:21 2000
+***************
+*** 960,965 ****
+--- 960,993 ----
+    else
+      fprintf (asmfile, ";-1;");
+  }
++ #ifdef GPC
++ void
++ dbxout_set_type_status (type, defined)
++     tree type;
++     int defined;
++ {
++  if (TYPE_SYMTAB_ADDRESS (type) == 0)
++    {
++      /* Type has no dbx number assigned.  Assign next available number.  */
++      TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
++ 
++      /* Make sure type vector is long enough to record about this type.  */
++ 
++      if (next_type_number == typevec_len)
++      {
++        typevec =
++          (struct typeinfo *) xrealloc (typevec,
++                                        typevec_len * 2 * sizeof typevec[0]);
++        bzero ((char *) (typevec + typevec_len),
++               typevec_len * sizeof typevec[0]);
++        typevec_len *= 2;
++      }
++    }
++  typevec[ TYPE_SYMTAB_ADDRESS (type) ].status =
++    defined ? TYPE_DEFINED : TYPE_UNSEEN;
++ }
++ #endif /* GPC */
++ 
+  
+  /* Output a reference to a type.  If the type has not yet been
+     described in the dbx output, output its definition now.
diff --git a/lang/gpc/files/patch-ae b/lang/gpc/files/patch-ae
new file mode 100644
index 000000000000..f24359936143
--- /dev/null
+++ b/lang/gpc/files/patch-ae
@@ -0,0 +1,12 @@
+*** demangle.h.orig	Wed Jul 30 22:02:03 1997
+--- demangle.h		Thu Mar 23 16:13:01 2000
+***************
+*** 22,28 ****
+  
+  #ifdef IN_GCC
+  #include "gansidecl.h"
+- #define PARAMS(ARGS) PROTO(ARGS)
+  #else /* ! IN_GCC */
+  #include <ansidecl.h>
+  #endif /* IN_GCC */
+--- 22,27 ----
diff --git a/lang/gpc/files/patch-af b/lang/gpc/files/patch-af
new file mode 100644
index 000000000000..955b9c7a6d2a
--- /dev/null
+++ b/lang/gpc/files/patch-af
@@ -0,0 +1,299 @@
+*** expr.c.orig	Wed Mar  4 04:32:19 1998
+--- expr.c	Thu Mar 23 15:23:42 2000
+***************
+*** 3931,3938 ****
+--- 3931,3947 ----
+  	}
+      }
+    /* set constructor assignments */
++ #ifdef GPC
+    else if (TREE_CODE (type) == SET_TYPE)
+      {
++ 	void store_set_constructor ();
++ 	store_set_constructor (exp, target);
++     }
++   else if (0 && TREE_CODE (type) == SET_TYPE) /* @@@@ Chill SET_TYPE */
++ #else /* not GPC */
++   else if (TREE_CODE (type) == SET_TYPE)
++ #endif /* not GPC */
++     {
+        tree elt = CONSTRUCTOR_ELTS (exp);
+        rtx xtarget = XEXP (target, 0);
+        int set_word_size = TYPE_ALIGN (type);
+***************
+*** 5453,5458 ****
+--- 5462,5481 ----
+  	 store directly into the target unless the type is large enough
+  	 that memcpy will be used.  If we are making an initializer and
+  	 all operands are constant, put it in memory as well.  */
++ #ifdef GPC
++       else if (TREE_CODE (TREE_TYPE (exp)) != SET_TYPE
++              &&
++              ((TREE_STATIC (exp)
++               && ((mode == BLKmode
++                    && ! (target != 0 && safe_from_p (target, exp, 1)))
++                   || TREE_ADDRESSABLE (exp)
++                   || (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
++                       && (move_by_pieces_ninsns
++                           (TREE_INT_CST_LOW (TYPE_SIZE (type)),
++                            TYPE_ALIGN (type))
++                           > MOVE_RATIO))))
++              || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp))))
++ #else /* not GPC */
+        else if ((TREE_STATIC (exp)
+  		&& ((mode == BLKmode
+  		     && ! (target != 0 && safe_from_p (target, exp, 1)))
+***************
+*** 5464,5469 ****
+--- 5487,5493 ----
+  			    > MOVE_RATIO)
+  			&& ! mostly_zeros_p (exp))))
+  	       || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
++ #endif /* not GPC */
+  	{
+  	  rtx constructor = output_constant_def (exp);
+  	  if (modifier != EXPAND_CONST_ADDRESS
+***************
+*** 5908,5913 ****
+--- 5932,5946 ----
+        abort ();
+  
+      case IN_EXPR:
++ #ifdef GPC
++       {
++       /* @@@ Fix & move this.  */
++       rtx expand_set_in ();
++ 
++       preexpand_calls (exp);
++       return expand_set_in (exp, target);
++       }
++ #else /* not GPC */
+        {
+  	/* Pascal set IN expression.
+  
+***************
+*** 6015,6020 ****
+--- 6048,6063 ----
+  	emit_label (op0);
+  	return target;
+        }
++ #endif /* not GPC */
++ 
++ #ifdef GPC
++     case CARD_EXPR:  /* Count number of elements in a set.  */
++       preexpand_calls (exp);
++       {
++       rtx expand_set_card ();
++       return expand_set_card (TREE_OPERAND (exp, 0), target);
++       }
++ #endif /* GPC */
+  
+      case WITH_CLEANUP_EXPR:
+        if (RTL_EXPR_RTL (exp) == 0)
+***************
+*** 6469,6474 ****
+--- 6512,6561 ----
+        return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
+  
+      case FIX_ROUND_EXPR:
++ #ifdef GPC
++      {
++        /* ISO Pascal round(x):
++           if x >= 0.0 then trunc (x+0.5) else trunc (x-0.5);
++ 
++           Pascal round is none of the four IEEE rounding modes:
++           nearest, minus infinity, plus infinity or chop
++ 
++           So it is implemented with code.  */
++ 
++        rtx label_positive = gen_label_rtx ();
++        rtx label_done     = gen_label_rtx ();
++        rtx half;
++        enum machine_mode fmode;
++ 
++        if (target == NULL_RTX)
++          target = gen_reg_rtx (mode);
++ 
++        op0  = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
++        fmode = GET_MODE (op0);
++ 
++        half = immed_real_const_1 (REAL_VALUE_ATOF ("0.5", fmode), fmode);
++ 
++        emit_cmp_insn (op0, CONST0_RTX (fmode), GE, 0, fmode, 0, 0);
++        emit_jump_insn (gen_bge (label_positive));
++ 
++        expand_fix (target, expand_binop (fmode, sub_optab, op0, half,
++                                          NULL_RTX, 0, OPTAB_DIRECT),
++                    0);
++        emit_queue ();
++        emit_jump_insn (gen_jump (label_done));
++        emit_barrier ();
++        emit_queue ();
++ 
++        emit_label (label_positive);
++        expand_fix (target, expand_binop (fmode, add_optab, op0, half,
++                                          NULL_RTX, 0, OPTAB_DIRECT),
++                    0);
++        emit_queue ();
++        emit_label (label_done);
++ 
++        return target;
++      }
++ #endif /* GPC */
+      case FIX_FLOOR_EXPR:
+      case FIX_CEIL_EXPR:
+        abort ();			/* Not used for C.  */
+***************
+*** 6504,6512 ****
+--- 6591,6612 ----
+        op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
+  
+        /* Handle complex values specially.  */
++ #ifdef GPC
++       /* It is the mode of the operand, not the mode of the return
++        value that is tested here. ABS(complex) does not return
++        complex type.  */
++       {
++       enum machine_mode op0_mode =
++         TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
++       if (GET_MODE_CLASS (op0_mode) == MODE_COMPLEX_INT
++           || GET_MODE_CLASS (op0_mode) == MODE_COMPLEX_FLOAT)
++         return expand_complex_abs (op0_mode, op0, target, unsignedp);
++       }
++ #else /* not GPC */
+        if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
+  	  || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
+  	return expand_complex_abs (mode, op0, target, unsignedp);
++ #endif /* not GPC */
+  
+        /* Unsigned abs is simply the operand.  Testing here means we don't
+  	 risk generating incorrect code below.  */
+***************
+*** 6629,6634 ****
+--- 6729,6739 ----
+        this_optab = xor_optab;
+        goto binop;
+  
++ #ifdef GPC
++     case BIT_ANDTC_EXPR:
++       goto binop;
++ #endif /* GPC */
++ 
+      case LSHIFT_EXPR:
+      case RSHIFT_EXPR:
+      case LROTATE_EXPR:
+***************
+*** 6649,6654 ****
+--- 6754,6767 ----
+      case EQ_EXPR:
+      case NE_EXPR:
+        preexpand_calls (exp);
++ #ifdef GPC
++       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == SET_TYPE
++         || TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == SET_TYPE)
++       {
++         rtx expand_set_comparison ();
++         return expand_set_comparison (exp, target);
++       }
++ #endif /* GPC */
+        temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
+        if (temp != 0)
+  	return temp;
+***************
+*** 7136,7141 ****
+--- 7249,7273 ----
+  		  && TYPE_READONLY (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
+  	  preexpand_calls (exp);
+  
++ #ifdef GPC
++       if (TREE_CODE (type) == SET_TYPE
++           && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs))) == VOID_TYPE)
++         {
++           /* Assigning an empty set.  */
++ 
++           int size = int_size_in_bytes (type);
++ 
++           /* Only constant bounds in standard pascal.  */
++           if (size == -1)
++             abort ();
++ 
++           target = expand_expr (lhs, target, VOIDmode, 0);
++           clear_storage (target, expr_size (exp),
++                          TYPE_ALIGN (type) / BITS_PER_UNIT);
++           return ignore ? const0_rtx : target;
++         }
++ #endif /* GPC */
++ 
+  	/* Check for |= or &= of a bitfield of size one into another bitfield
+  	   of size 1.  In this case, (unless we need the result of the
+  	   assignment) we can do this more efficiently with a
+***************
+*** 7415,7420 ****
+--- 7547,7560 ----
+       from the optab already placed in `this_optab'.  */
+   binop:
+    preexpand_calls (exp);
++ #ifdef GPC
++   if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == SET_TYPE
++       || TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == SET_TYPE)
++     {
++       rtx expand_set_binop ();
++       return expand_set_binop (exp, target);
++     }
++ #endif /* GPC */
+    if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
+      subtarget = 0;
+    op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
+***************
+*** 10888,10901 ****
+--- 11028,11077 ----
+       register tree exp;
+       enum rtx_code signed_code, unsigned_code;
+  {
++ #ifdef GPC
++   register rtx op0;
++   register rtx op1;
++ #else /* not GPC */
+    register rtx op0
+      = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
+    register rtx op1
+      = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
++ #endif /* not GPC */
+    register tree type = TREE_TYPE (TREE_OPERAND (exp, 0));
+    register enum machine_mode mode = TYPE_MODE (type);
+    int unsignedp = TREE_UNSIGNED (type);
+    enum rtx_code code = unsignedp ? unsigned_code : signed_code;
++ 
++ #ifdef GPC
++   if (TREE_CODE (type) == SET_TYPE
++       || TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == SET_TYPE)
++     {
++ 
++       /* Generate code to compare two set operands.
++ 
++          First generate code that compares the words in the set.
++          The two sets are not necessarily same size in memory,
++          so block compare does not work here.
++          (If op0 is a constructor [ 'A' ] and op1 is a
++          set with elements [ chr('0') .. chr (255) ],
++          then op0 takes one word and op1 takes 8 words in
++          a 32 bit machine.)
++ 
++          The (boolean) result is then compared to const1_rtx with the
++          mode of the set comparison result to set the CC0 as the caller
++          wants.  */
++ 
++       op0  = expand_expr (exp, NULL_RTX, VOIDmode, 0);
++       mode = GET_MODE (op0);
++       code = EQ;
++       op1  = const1_rtx;
++     }
++   else
++     {
++       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
++       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
++     }
++ #endif /* GPC */
+  
+  #ifdef HAVE_canonicalize_funcptr_for_compare
+    /* If function pointers need to be "canonicalized" before they can
diff --git a/lang/gpc/files/patch-ag b/lang/gpc/files/patch-ag
new file mode 100644
index 000000000000..f88718ed10a9
--- /dev/null
+++ b/lang/gpc/files/patch-ag
@@ -0,0 +1,171 @@
+*** fold-const.c.orig	Sat Feb 28 22:58:15 1998
+--- fold-const.c	Thu Mar 23 15:32:50 2000
+***************
+*** 1225,1232 ****
+--- 1225,1236 ----
+      }
+  
+    TREE_OVERFLOW (t)
++ #ifdef GPC
++     = ((notrunc ? overflow : force_fit_type (t, overflow))
++ #else /* not GPC */
+      = ((notrunc ? (!uns || forsize) && overflow
+  	: force_fit_type (t, (!uns || forsize) && overflow) && ! no_overflow)
++ #endif /* not GPC */
+         | TREE_OVERFLOW (arg1)
+         | TREE_OVERFLOW (arg2));
+    /* If we're doing a size calculation, unsigned arithmetic does overflow.
+***************
+*** 4489,4494 ****
+--- 4493,4510 ----
+        goto associate;
+  
+      case BIT_IOR_EXPR:
++ #ifdef GPC
++       if (TREE_CODE (type) == SET_TYPE)
++       {
++         /* S + [] == S */
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++           return arg0;
++ 
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++           return arg1;
++         goto associate;
++       }
++ #endif /* GPC */
+      bit_ior:
+        {
+        register enum tree_code code0, code1;
+***************
+*** 4550,4555 ****
+--- 4566,4583 ----
+        }
+  
+      case BIT_XOR_EXPR:
++ #ifdef GPC
++       if (TREE_CODE (type) == SET_TYPE)
++       {
++         /* S >< [] == S */
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++           return arg0;
++ 
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++           return arg1;
++         goto associate;
++       }
++ #endif /* GPC */
+        if (integer_zerop (arg1))
+  	return non_lvalue (convert (type, arg0));
+        if (integer_all_onesp (arg1))
+***************
+*** 4557,4562 ****
+--- 4585,4602 ----
+        goto associate;
+  
+      case BIT_AND_EXPR:
++ #ifdef GPC
++       if (TREE_CODE (type) == SET_TYPE)
++       {
++         /* S * [] == [] */
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++           return arg1;
++ 
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++           return arg0;
++         goto associate;
++       }
++ #endif /* GPC */
+      bit_and:
+        if (integer_all_onesp (arg1))
+  	return non_lvalue (convert (type, arg0));
+***************
+*** 4587,4592 ****
+--- 4627,4644 ----
+        goto associate;
+  
+      case BIT_ANDTC_EXPR:
++ #ifdef GPC
++       if (TREE_CODE (type) == SET_TYPE)
++       {
++         /* S - [] == S; [] - S == [] */
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++           return arg0;
++ 
++         if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++           return arg0;
++         goto associate;
++       }
++ #endif /* GPC */
+        if (integer_all_onesp (arg0))
+  	return non_lvalue (convert (type, arg1));
+        if (integer_zerop (arg0))
+***************
+*** 4998,5003 ****
+--- 5050,5093 ----
+      case GT_EXPR:
+      case LE_EXPR:
+      case GE_EXPR:
++ #ifdef GPC
++       if (TREE_CODE (TREE_TYPE (arg0)) == SET_TYPE)
++       {
++         switch (code)
++             {
++             case EQ_EXPR:
++               if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE
++                   && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++                 return convert (type, integer_one_node);
++               break;
++             case NE_EXPR:
++               if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE
++                   && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++                 return convert (type, integer_zero_node);
++               break;
++             case LE_EXPR:
++               if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++                 return convert (type, integer_one_node);
++               break;
++             case GE_EXPR:
++               if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++                 return convert (type, integer_one_node);
++               break;
++             case GT_EXPR:
++               /* Optimized from: "not (arg0 <= arg1)" */
++               if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++                 return convert (type, integer_zero_node);
++               break;
++             case LT_EXPR:
++               /* Optimized from: "not (arg0 >= arg1)" */
++               if (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == VOID_TYPE)
++                 return convert (type, integer_zero_node);
++               break;
++             default:
++               abort ();
++           }
++       }
++ #endif /* GPC */
+        /* If one arg is a constant integer, put it last.  */
+        if (TREE_CODE (arg0) == INTEGER_CST
+  	  && TREE_CODE (arg1) != INTEGER_CST)
+***************
+*** 5782,5787 ****
+--- 5872,5891 ----
+  	return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
+  
+        return t;
++ 
++ #ifdef GPC
++     case CARD_EXPR:
++       if (TREE_CODE (TREE_TYPE (arg0)) == SET_TYPE
++         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++       return convert (type, integer_zero_node);
++       return t;
++ 
++     case IN_EXPR:
++       if (TREE_CODE (TREE_TYPE (arg0)) == SET_TYPE
++         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == VOID_TYPE)
++       return convert (type, integer_zero_node);
++       return t;
++ #endif /* GPC */
+  
+      case COMPOUND_EXPR:
+        /* When pedantic, a compound expression can be neither an lvalue
diff --git a/lang/gpc/files/patch-ah b/lang/gpc/files/patch-ah
new file mode 100644
index 000000000000..b528b5db42cd
--- /dev/null
+++ b/lang/gpc/files/patch-ah
@@ -0,0 +1,44 @@
+*** function.c.orig	Sat Feb 28 22:58:16 1998
+--- function.c		Thu Mar 23 15:34:50 2000
+***************
+*** 463,468 ****
+--- 463,491 ----
+  /* Given a function decl for a containing function,
+     return the `struct function' for it.  */
+  
++ #ifdef GPC
++ struct function *
++ maybe_find_function_data (decl)
++      tree decl;
++ {
++   struct function *p;
++   for (p = outer_function_chain; p; p = p->next)
++    if (p->decl == decl)
++      return p;
++  return (struct function *)NULL;
++ }
++ 
++ struct function *
++ find_function_data (decl)
++     tree decl;
++ {
++  struct function *p = maybe_find_function_data (decl);
++  if (!p)
++    abort ();
++  return p;
++ }
++ 
++ #else /* not GPC */
+  struct function *
+  find_function_data (decl)
+       tree decl;
+***************
+*** 475,480 ****
+--- 498,504 ----
+  
+    abort ();
+  }
++ #endif /* not GPC */
+  
+  /* Save the current context for compilation of a nested function.
+     This is called from language-specific code.
diff --git a/lang/gpc/files/patch-ai b/lang/gpc/files/patch-ai
new file mode 100644
index 000000000000..9f1614ed783d
--- /dev/null
+++ b/lang/gpc/files/patch-ai
@@ -0,0 +1,135 @@
+*** gansidecl.h.orig	Sat Feb 14 18:31:43 1998
+--- gansidecl.h		Thu Mar 23 16:07:55 2000
+***************
+*** 22,107 ****
+     in binutils and gdb releases.
+     ??? Over time the two should be merged into one.  */
+  
+! #ifndef	ANSIDECL_H
+! #define	ANSIDECL_H
+  
+! /* Add prototype support.  */
+! #ifndef PROTO
+! #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+! #define PROTO(ARGS) ARGS
+! #else
+! #define PROTO(ARGS) ()
+! #endif
+! #endif
+  
+! #ifndef VPROTO
+! #ifdef __STDC__
+! #define PVPROTO(ARGS)		ARGS
+! #define VPROTO(ARGS)            ARGS
+! #define VA_START(va_list,var)  va_start(va_list,var)
+! #else
+! #define PVPROTO(ARGS)		()
+! #define VPROTO(ARGS)            (va_alist) va_dcl
+! #define VA_START(va_list,var)  va_start(va_list)
+! #endif
+  #endif
+  
+- /* Define a generic NULL if one hasn't already been defined.  */
+  
+! #ifndef NULL
+! #define NULL 0
+! #endif
+! 
+! #ifndef GENERIC_PTR
+! #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+! #define GENERIC_PTR void *
+! #else
+! #define GENERIC_PTR char *
+! #endif
+! #endif
+  
+  #ifndef NULL_PTR
+! #define NULL_PTR ((GENERIC_PTR) 0)
+! #endif
+! 
+! #ifdef __STDC__
+! 
+! #define	PTR void *
+! 
+! #else
+! 
+! #define	PTR char *
+! #ifndef const
+! #define const
+! #endif
+! 
+! #endif /* ! __STDC__ */
+! 
+! /* We don't have autoconf for libgcc2.c since it's a target, so don't
+!    define these functions, which aren't used there anyway.  */
+! 
+! #ifndef IN_LIBGCC2
+! 
+! #ifndef HAVE_BCOPY
+! #define bcopy(src,dst,len) memcpy ((dst),(src),(len))
+! #endif
+! 
+! #ifndef HAVE_BZERO
+! #define bzero(dst,len) memset ((dst),0,(len))
+! #endif
+! 
+! #ifndef HAVE_BCMP
+! #define bcmp(left,right,len) memcmp ((left),(right),(len))
+! #endif
+! 
+! #ifndef HAVE_RINDEX
+! #define rindex strrchr
+! #endif
+! 
+! #ifndef HAVE_INDEX
+! #define index strchr
+  #endif
+  
+! #endif /* IN_LIBGCC2 */
+  
+- #endif /* ANSIDECL_H */
+--- 22,65 ----
+     in binutils and gdb releases.
+     ??? Over time the two should be merged into one.  */
+  
+! #ifndef       __GANSIDECL_H__
+! #define       __GANSIDECL_H__
+  
+! #include "ansidecl.h"
+  
+! /* Undef ansidecl.h's "obsolete" version. */
+! #undef PROTO
+! /* These macros are deprecated, use ansidecl.h's PARAMS style instead. */
+! #define PROTO(ARGS) PARAMS(ARGS)
+! #define VPROTO(ARGS) VPARAMS(ARGS)
+! #define PVPROTO(ARGS) PARAMS(ARGS)
+! 
+! #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
+! # define __attribute__(x)
+  #endif
+  
+  
+! #ifndef ATTRIBUTE_UNUSED
+! #define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+! #endif /* ATTRIBUTE_UNUSED */
+! 
+! #ifndef ATTRIBUTE_NORETURN
+! #define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
+! #endif /* ATTRIBUTE_NORETURN */
+! 
+! #ifndef ATTRIBUTE_PRINTF
+! #define ATTRIBUTE_PRINTF(m, n) __attribute__ ((format (__printf__, m, n)))
+! #define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
+! #define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
+! #define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
+! #define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
+! #define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
+! #endif /* ATTRIBUTE_PRINTF */
+! #define GENERIC_PTR PTR
+  
+  #ifndef NULL_PTR
+! #define NULL_PTR ((PTR) 0)
+  #endif
+  
+! #endif /* __GANSIDECL_H__ */
+  
diff --git a/lang/gpc/files/patch-aj b/lang/gpc/files/patch-aj
new file mode 100644
index 000000000000..d2f6c918cd97
--- /dev/null
+++ b/lang/gpc/files/patch-aj
@@ -0,0 +1,7 @@
+*** mbchar.c.orig	Thu Jan  1 03:00:00 1970
+--- mbchar.c		Thu Mar 23 16:13:36 2000
+***************
+*** 0 ****
+--- 1 ----
++ /* empty */
+\ No newline at end of file
diff --git a/lang/gpc/files/patch-ak b/lang/gpc/files/patch-ak
new file mode 100644
index 000000000000..df4d00205aa3
--- /dev/null
+++ b/lang/gpc/files/patch-ak
@@ -0,0 +1,49 @@
+*** optabs.c.orig	Sat Feb 14 13:41:17 1998
+--- optabs.c		Thu Mar 23 15:38:53 2000
+***************
+*** 1379,1384 ****
+--- 1379,1422 ----
+  
+  	      ok = 1;
+  	    }
++ #ifdef GPC
++          /* Optimization if real part of divisor is zero.  */
++        else if (real1 == 0)
++          {
++            /* (a+ib) / (0+id) == -i(a+ib) / d == (b/d + i(-a/d) */
++ 
++            /* Fetch imag1 from memory only once.  */
++            imag1 = force_reg (submode, imag1);
++ 
++            if (class == MODE_COMPLEX_FLOAT)
++              res = expand_binop (submode, binoptab, imag0, imag1,
++                                  realr, unsignedp, methods);
++            else
++              res = expand_divmod (0, TRUNC_DIV_EXPR, submode,
++                                   imag0, imag1, realr, unsignedp);
++            if (res == 0)
++              break;
++            else if (res != realr)
++              emit_move_insn (realr, res);
++ 
++            if (class == MODE_COMPLEX_FLOAT)
++              res = expand_binop (submode, binoptab, real0,
++                                  imag1, imagr, unsignedp, methods);
++            else
++              res = expand_divmod (0, TRUNC_DIV_EXPR, submode,
++                                   real0, imag1, imagr, unsignedp);
++ 
++            /* Negate the imaginary part.  */
++            res = expand_unop (submode, neg_optab,
++                               res, imagr, unsignedp);
++            if (res == 0)
++              break;
++            else if (res != imagr)
++              emit_move_insn (imagr, res);
++ 
++            ok = 1;
++          }
++ #endif /* GPC */
+  	  else
+  	    {
+  	      /* Divisor is of complex type:
diff --git a/lang/gpc/files/patch-al b/lang/gpc/files/patch-al
new file mode 100644
index 000000000000..5d5da64f57d6
--- /dev/null
+++ b/lang/gpc/files/patch-al
@@ -0,0 +1,41 @@
+*** prefix.c.orig	Fri Feb  6 16:04:22 1998
+--- prefix.c		Thu Mar 23 15:40:38 2000
+***************
+*** 232,238 ****
+       char *name;
+  {
+    char code = name[0];
+!   char *key, *prefix = 0;
+    int keylen;
+  
+    if (code != '@' && code != '$')
+--- 232,238 ----
+       char *name;
+  {
+    char code = name[0];
+!   char *key, *prefix = 0, *oldname = name;
+    int keylen;
+  
+    if (code != '@' && code != '$')
+***************
+*** 272,278 ****
+        prefix[strlen (prefix) - 1] = 0;
+      }
+  
+!   return concat (prefix, name, NULL_PTR);
+  }
+  
+  /* Update PATH using KEY if PATH starts with PREFIX.  */
+--- 272,283 ----
+        prefix[strlen (prefix) - 1] = 0;
+      }
+  
+!   name = concat (prefix, name, NULL_PTR);
+! 
+!   if (!strcmp (name, oldname))
+!     return 0;
+! 
+!   return name;
+  }
+  
+  /* Update PATH using KEY if PATH starts with PREFIX.  */
diff --git a/lang/gpc/files/patch-am b/lang/gpc/files/patch-am
new file mode 100644
index 000000000000..b6553c3474d1
--- /dev/null
+++ b/lang/gpc/files/patch-am
@@ -0,0 +1,233 @@
+*** stor-layout.c.orig	Sat Nov  8 16:12:07 1997
+--- stor-layout.c	Thu Mar 23 15:48:05 2000
+***************
+*** 65,70 ****
+--- 65,79 ----
+  
+  int immediate_size_expand;
+  
++ #ifdef GPC
++ 
++ /* Nonzero means that the size of a type may vary
++     within one function context.  */
++ 
++ int size_volatile = 0;
++ 
++ #endif /* GPC */
++ 
+  tree
+  get_pending_sizes ()
+  {
+***************
+*** 102,109 ****
+        || global_bindings_p () < 0 || contains_placeholder_p (size))
+      return size;
+  
+!   size = save_expr (size);
+! 
+    if (global_bindings_p ())
+      {
+        if (TREE_CONSTANT (size))
+--- 111,123 ----
+        || global_bindings_p () < 0 || contains_placeholder_p (size))
+      return size;
+  
+! #ifdef GPC
+!   if (! size_volatile)
+!     size = save_expr (size);
+! #else /* not GPC */
+!     size = save_expr (size);
+! #endif /* not GPC */
+!     
+    if (global_bindings_p ())
+      {
+        if (TREE_CONSTANT (size))
+***************
+*** 119,125 ****
+--- 133,143 ----
+         Also, we would like to pass const0_rtx here, but don't have it.  */
+      expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0),
+  		 VOIDmode, 0);
++ #ifdef GPC
++   else if (! size_volatile)
++ #else /* not GPC */
+    else
++ #endif /* not GPC */
+      pending_sizes = tree_cons (NULL_TREE, size, pending_sizes);
+  
+    return size;
+***************
+*** 953,958 ****
+--- 971,1117 ----
+  	}
+        break;
+  
++ #ifdef GPC
++      /* Unfortunately the code for SET_TYPE in standard gcc 2.6.3 will
++       not work for pascal sets. The problem is that the code aligns
++       the set so that it always starts from the first bit of the
++       aligned set. (i.e it shifts bit 0 to the firt bit of the
++       aligned first word of the set). This is ok, if the set low
++       bound is zero (as in powersets) or any multiple of
++       "set_alignment". But this is not always the case in Pascal.
++ 
++       It causes problems when using set types with set constructors
++       in an expression, possibly the expression having ranges whose
++       both bounds are variable.
++ 
++       The method used in GPC is to adjust the sets so that the bits
++       are never shifted to the beginning of the aligned entity (in
++       gpc, it is a word), but rather more room is allocated in
++       front and behind of the actual set, so that both bounds are aligned
++       and then the size used by the set is counted.
++ 
++       The code below works as the original code for the special
++       cases when set low bound is 0 or a multiple of alignement,
++       but it also works for GPC.
++ 
++       Also, the code in the case when the bounds are variable
++       should work, and the algorithm is the same as in the
++       constant case, but the calculation is done in tree nodes
++       (so it can be folded wherever possible).
++ 
++       In this case, the original code called abort().  */
++ 
++ #ifndef SET_WORD_SIZE
++ #define SET_WORD_SIZE BITS_PER_WORD
++ #endif
++ 
++    case SET_TYPE:
++      if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
++        && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST)
++      {
++        int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
++        int aligned_size_in_bits;
++        int low_bound, high_bound;
++ 
++        int l_index = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type)));
++        int h_index = TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
++ 
++        if (l_index == 0 && h_index == -1)
++          {
++            /* Special empty set node */
++            TYPE_SIZE (type) = size_zero_node;
++            TYPE_MODE (type) = VOIDmode;
++            TYPE_ALIGN (type) = 1;
++            break;
++          }
++ 
++        /* Calculate an aligned low bound from the set low bound */
++        low_bound = l_index - (l_index % alignment);
++ 
++        /* Calculate an aligned high bound from the set high bound */
++        high_bound = (alignment-1) + (alignment * (h_index / alignment));
++ 
++        /* This is the aligned size (both low and high aligned) */
++        aligned_size_in_bits = high_bound - low_bound + 1;
++ 
++        if (aligned_size_in_bits > alignment)
++          TYPE_MODE (type) = BLKmode;
++        else
++          TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
++ 
++        TYPE_SIZE (type)      = size_int (aligned_size_in_bits);
++        TYPE_ALIGN (type)     = alignment;
++        TYPE_PRECISION (type) = h_index - l_index + 1;
++      }
++      else
++      {
++        tree domain = TYPE_DOMAIN (type);
++        int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
++        tree align = build_int_2 (alignment, 0);
++ 
++        /* @@@@@ Negative bounds do not work here.
++ 
++             @@@ Although this should work, variable bound sets are
++                 not supported in setop.c.  */
++ 
++        extern tree build_binary_op (enum tree_code, tree, tree, int);
++ 
++        /* low_bound = low_index - (low_index % align); */
++        tree low_bound =
++          build_binary_op (MINUS_EXPR,
++                           convert (integer_type_node,
++                                    TYPE_MIN_VALUE (domain)),
++                           build_binary_op (TRUNC_MOD_EXPR,
++                                            convert (integer_type_node,
++                                                     TYPE_MIN_VALUE (domain)),
++                                            align,
++                                            0),
++                           0);
++ 
++        /* Upper bit number.  Avoid overflow.  */
++        /* upper_bound = (align-1) + (align * (high_index / align)); */
++        tree high_bound =
++          build_binary_op
++            (PLUS_EXPR,
++             build_int_2 (alignment - 1, 0),
++             build_binary_op (MULT_EXPR,
++                              align,
++                              build_binary_op (TRUNC_DIV_EXPR,
++                                               convert (integer_type_node,
++                                                        TYPE_MAX_VALUE (domain)),
++                                               align,
++                                               0),
++                              0),
++             0);
++ 
++        /* Allocated TYPE_SIZE in bits, including possible aligning */
++        /* set_size_in_bits = high_bound - low_bound + 1; */
++        TYPE_SIZE (type) =
++          build_binary_op (PLUS_EXPR,
++                           integer_one_node,
++                           build_binary_op (MINUS_EXPR,
++                                            high_bound,
++                                            low_bound,
++                                            0),
++                           0);
++ 
++        TYPE_ALIGN (type) = alignment;
++ 
++        /* Find out if the set fits in word_mode. If not, use BLKmode.
++           @@@ But it requires knowing the size, which is variable
++           in this case ...  */
++ 
++        if (TYPE_SIZE (type)
++            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
++            && TREE_INT_CST_LOW (TYPE_SIZE (type)) <= alignment)
++          TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
++        else
++          TYPE_MODE (type) = BLKmode;
++      }
++      break;
++ #else /* not GPC */
++ 
++ 
+      case SET_TYPE:  /* Used by Chill and Pascal. */
+        if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
+  	  || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
+***************
+*** 977,982 ****
+--- 1136,1142 ----
+  	  TYPE_PRECISION (type) = size_in_bits;
+  	}
+        break;
++ #endif /* not GPC */
+  
+      case FILE_TYPE:
+        /* The size may vary in different languages, so the language front end
+***************
+*** 1152,1157 ****
+--- 1312,1323 ----
+  		      >> (HOST_BITS_PER_WIDE_INT
+  			  - (precision - HOST_BITS_PER_WIDE_INT)))
+  		   : 0);
++ #ifdef GPC
++   /* Not only for Pascal, but other languages don't seem to care
++      about this.  */
++   TREE_UNSIGNED (TYPE_MIN_VALUE (type)) = 1;
++   TREE_UNSIGNED (TYPE_MAX_VALUE (type)) = 1;
++ #endif /* GPC */
+    TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
+    TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
+  
diff --git a/lang/gpc/files/patch-an b/lang/gpc/files/patch-an
new file mode 100644
index 000000000000..97406adf8937
--- /dev/null
+++ b/lang/gpc/files/patch-an
@@ -0,0 +1,398 @@
+*** system.h.orig	Thu Jan  1 03:00:00 1970
+--- system.h		Thu Mar 23 16:11:35 2000
+***************
+*** 0 ****
+--- 1,393 ----
++ /* system.h - Get common system includes and various definitions and
++    declarations based on autoconf macros.
++    Copyright (C) 1998 Free Software Foundation, Inc.
++ 
++  */
++ 
++ #ifndef __GCC_SYSTEM_H__
++ #define __GCC_SYSTEM_H__
++ 
++ /* We must include stdarg.h/varargs.h before stdio.h. */
++ #ifdef ANSI_PROTOTYPES
++ #include <stdarg.h>
++ #else
++ #include <varargs.h>
++ #endif
++ 
++ #include <stdio.h>
++ 
++ /* Define a generic NULL if one hasn't already been defined.  */
++ #ifndef NULL
++ #define NULL 0
++ #endif
++ 
++ /* The compiler is not a multi-threaded application and therefore we
++    do not have to use the locking functions.  */
++ #ifdef HAVE_PUTC_UNLOCKED
++ # undef putc
++ # define putc(C, Stream) putc_unlocked (C, Stream)
++ #endif
++ #ifdef HAVE_FPUTC_UNLOCKED
++ # undef fputc
++ # define fputc(C, Stream) fputc_unlocked (C, Stream)
++ #endif
++ #ifdef HAVE_FPUTS_UNLOCKED
++ # undef fputs
++ # define fputs(String, Stream) fputs_unlocked (String, Stream)
++ #endif
++ 
++ #include <ctype.h>
++ 
++ /* Jim Meyering writes:
++ 
++    "... Some ctype macros are valid only for character codes that
++    isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when
++    using /bin/cc or gcc but without giving an ansi option).  So, all
++    ctype uses should be through macros like ISPRINT...  If
++    STDC_HEADERS is defined, then autoconf has verified that the ctype
++    macros don't need to be guarded with references to isascii. ...
++    Defining isascii to 1 should let any compiler worth its salt
++    eliminate the && through constant folding."
++ 
++    Bruno Haible adds:
++ 
++    "... Furthermore, isupper(c) etc. have an undefined result if c is
++    outside the range -1 <= c <= 255. One is tempted to write isupper(c)
++    with c being of type `char', but this is wrong if c is an 8-bit
++    character >= 128 which gets sign-extended to a negative value.
++    The macro ISUPPER protects against this as well."  */
++ 
++ #if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))
++ # define IN_CTYPE_DOMAIN(c) 1
++ #else
++ # define IN_CTYPE_DOMAIN(c) isascii(c)
++ #endif
++ 
++ #ifdef isblank
++ # define ISBLANK(c) (IN_CTYPE_DOMAIN (c) && isblank (c))
++ #else
++ # define ISBLANK(c) ((c) == ' ' || (c) == '\t')
++ #endif
++ #ifdef isgraph
++ # define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isgraph (c))
++ #else
++ # define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isprint (c) && !isspace (c))
++ #endif
++ 
++ #define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (c))
++ #define ISALNUM(c) (IN_CTYPE_DOMAIN (c) && isalnum (c))
++ #define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
++ #define ISCNTRL(c) (IN_CTYPE_DOMAIN (c) && iscntrl (c))
++ #define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
++ #define ISPUNCT(c) (IN_CTYPE_DOMAIN (c) && ispunct (c))
++ #define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c))
++ #define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper (c))
++ #define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (c))
++ #define ISDIGIT_LOCALE(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))
++ 
++ /* ISDIGIT differs from ISDIGIT_LOCALE, as follows:
++    - Its arg may be any int or unsigned int; it need not be an unsigned char.
++    - It's guaranteed to evaluate its argument exactly once.
++    - It's typically faster.
++    Posix 1003.2-1992 section 2.5.2.1 page 50 lines 1556-1558 says that
++    only '0' through '9' are digits.  Prefer ISDIGIT to ISDIGIT_LOCALE unless
++    it's important to use the locale's definition of `digit' even when the
++    host does not conform to Posix.  */
++ #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
++ 
++ 
++ #include <sys/types.h>
++ #include <errno.h>
++ 
++ #ifndef errno
++ extern int errno;
++ #endif
++ 
++ #ifdef STRING_WITH_STRINGS
++ # include <string.h>
++ # include <strings.h>
++ #else
++ # ifdef HAVE_STRING_H
++ #  include <string.h>
++ # else
++ #  ifdef HAVE_STRINGS_H
++ #   include <strings.h>
++ #  endif
++ # endif
++ #endif
++ 
++ #ifdef HAVE_STDLIB_H
++ # include <stdlib.h>
++ #endif
++ 
++ #ifdef HAVE_UNISTD_H
++ # include <unistd.h>
++ #endif
++ 
++ #ifdef HAVE_SYS_PARAM_H
++ # include <sys/param.h>
++ #endif
++ 
++ #if HAVE_LIMITS_H
++ # include <limits.h>
++ #endif
++ 
++ #ifdef TIME_WITH_SYS_TIME
++ # include <sys/time.h>
++ # include <time.h>
++ #else
++ # if HAVE_SYS_TIME_H
++ #  include <sys/time.h>
++ # else
++ #  ifdef HAVE_TIME_H
++ #   include <time.h>
++ #  endif
++ # endif
++ #endif
++ 
++ #ifdef HAVE_FCNTL_H
++ # include <fcntl.h>
++ #else
++ # ifdef HAVE_SYS_FILE_H
++ #  include <sys/file.h>
++ # endif
++ #endif
++ 
++ #ifndef SEEK_SET
++ # define SEEK_SET 0
++ # define SEEK_CUR 1
++ # define SEEK_END 2
++ #endif
++ #ifndef F_OK
++ # define F_OK 0
++ # define X_OK 1
++ # define W_OK 2
++ # define R_OK 4
++ #endif
++ #ifndef O_RDONLY
++ # define O_RDONLY 0
++ #endif
++ #ifndef O_WRONLY
++ # define O_WRONLY 1
++ #endif
++ 
++ #ifdef HAVE_SYS_WAIT_H
++ #include <sys/wait.h>
++ #endif
++ 
++ #ifndef WIFSIGNALED
++ #define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f)
++ #endif
++ #ifndef WTERMSIG
++ #define WTERMSIG(S) ((S) & 0x7f)
++ #endif
++ #ifndef WIFEXITED
++ #define WIFEXITED(S) (((S) & 0xff) == 0)
++ #endif
++ #ifndef WEXITSTATUS
++ #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
++ #endif
++ 
++ 
++ 
++ #ifndef bcopy
++ # ifdef HAVE_BCOPY
++ #  ifdef NEED_DECLARATION_BCOPY
++ extern void bcopy ();
++ #  endif
++ # else /* ! HAVE_BCOPY */
++ #  define bcopy(src,dst,len) memcpy ((dst),(src),(len))
++ # endif
++ #endif
++ 
++ #ifndef bcmp
++ # ifdef HAVE_BCMP
++ #  ifdef NEED_DECLARATION_BCMP
++ extern int bcmp ();
++ #  endif
++ # else /* ! HAVE_BCMP */
++ #  define bcmp(left,right,len) memcmp ((left),(right),(len))
++ # endif
++ #endif
++ 
++ #ifndef bzero
++ # ifdef HAVE_BZERO
++ #  ifdef NEED_DECLARATION_BZERO
++ extern void bzero ();
++ #  endif
++ # else /* ! HAVE_BZERO */
++ #  define bzero(dst,len) memset ((dst),0,(len))
++ # endif
++ #endif
++ 
++ #ifndef index
++ # ifdef HAVE_INDEX
++ #  ifdef NEED_DECLARATION_INDEX
++ extern char *index ();
++ #  endif
++ # else /* ! HAVE_INDEX */
++ #  define index strchr
++ # endif
++ #endif
++ 
++ #ifndef rindex
++ # ifdef HAVE_RINDEX
++ #  ifdef NEED_DECLARATION_RINDEX
++ extern char *rindex ();
++ #  endif
++ # else /* ! HAVE_RINDEX */
++ #  define rindex strrchr
++ # endif
++ #endif
++ 
++ #ifdef NEED_DECLARATION_ATOF
++ extern double atof ();
++ #endif
++ 
++ #ifdef NEED_DECLARATION_ATOL
++ extern long atol();
++ #endif
++ 
++ #ifdef NEED_DECLARATION_FREE
++ extern void free ();
++ #endif
++ 
++ #ifdef NEED_DECLARATION_GETCWD
++ extern char *getcwd ();
++ #endif
++ 
++ #ifdef NEED_DECLARATION_GETENV
++ extern char *getenv ();
++ #endif
++ 
++ #ifdef NEED_DECLARATION_GETWD
++ extern char *getwd ();
++ #endif
++ 
++ #ifdef NEED_DECLARATION_SBRK
++ extern char *sbrk ();
++ #endif
++ 
++ #ifdef HAVE_STRERROR
++ # ifdef NEED_DECLARATION_STRERROR
++ #  ifndef strerror
++ extern char *strerror ();
++ #  endif
++ # endif
++ #else /* ! HAVE_STRERROR */
++ extern int sys_nerr;
++ extern char *sys_errlist[];
++ #endif /* HAVE_STRERROR */
++ 
++ #ifdef HAVE_STRSIGNAL
++ # ifdef NEED_DECLARATION_STRSIGNAL
++ #  ifndef strsignal
++ extern char * strsignal ();
++ #  endif
++ # endif
++ #else /* ! HAVE_STRSIGNAL */
++ # ifndef SYS_SIGLIST_DECLARED
++ #  ifndef NO_SYS_SIGLIST
++ extern char * sys_siglist[];
++ #  endif
++ # endif
++ #endif /* HAVE_STRSIGNAL */
++ 
++ #ifdef HAVE_GETRLIMIT
++ # ifdef NEED_DECLARATION_GETRLIMIT
++ #  ifndef getrlimit
++ extern int getrlimit ();
++ #  endif
++ # endif
++ #endif
++ 
++ #ifdef HAVE_SETRLIMIT
++ # ifdef NEED_DECLARATION_SETRLIMIT
++ #  ifndef setrlimit
++ extern int setrlimit ();
++ #  endif
++ # endif
++ #endif
++ 
++ /* HAVE_VOLATILE only refers to the stage1 compiler.  We also check
++    __STDC__ and assume gcc sets it and has volatile in stage >=2. */
++ #if !defined(HAVE_VOLATILE) && !defined(__STDC__) && !defined(volatile)
++ #define volatile
++ #endif
++ 
++ /* Redefine abort to report an internal error w/o coredump, and reporting the
++    location of the error in the source file.  */
++ #ifndef abort
++ #ifndef __STDC__
++ #ifndef __GNUC__
++ #ifndef USE_SYSTEM_ABORT
++ #define USE_SYSTEM_ABORT
++ #endif /* !USE_SYSTEM_ABORT */
++ #endif /* !__GNUC__ */
++ #endif /* !__STDC__ */
++ 
++ #ifdef USE_SYSTEM_ABORT
++ # ifdef NEED_DECLARATION_ABORT
++ extern void abort ();
++ # endif
++ #else
++ #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
++ #define abort()								\
++ (fprintf (stderr,							\
++ 	  "%s:%d: Internal compiler error\n", __FILE__, __LINE__),	\
++  exit (FATAL_EXIT_CODE))
++ 
++ #else
++ #define abort()								\
++ (fprintf (stderr,							\
++ 	  "%s:%d: Internal compiler error in function %s\n",		\
++ 	  __FILE__, __LINE__, __PRETTY_FUNCTION__),			\
++  exit (FATAL_EXIT_CODE))
++ 
++ #endif /* recent gcc */
++ #endif /* USE_SYSTEM_ABORT */
++ #endif /* !abort */
++ 
++ 
++ /* Define a STRINGIFY macro that's right for ANSI or traditional C.
++    HAVE_CPP_STRINGIFY only refers to the stage1 compiler.  Assume that
++    (non-traditional) gcc used in stage2 or later has this feature.
++ 
++    Note: if the argument passed to STRINGIFY is itself a macro, eg
++    #define foo bar, STRINGIFY(foo) will produce "foo", not "bar".
++    Although the __STDC__ case could be made to expand this via a layer
++    of indirection, the traditional C case can not do so.  Therefore
++    this behavior is not supported. */
++ #ifndef STRINGIFY
++ # if defined(HAVE_CPP_STRINGIFY) || (defined(__GNUC__) && defined(__STDC__))
++ #  define STRINGIFY(STRING) #STRING
++ # else
++ #  define STRINGIFY(STRING) "STRING"
++ # endif
++ #endif /* ! STRINGIFY */
++ 
++ 
++ /* These macros are here in preparation for the use of gettext in egcs.  */
++ #define _(String) String
++ #define N_(String) String
++ 
++ #if HAVE_SYS_STAT_H
++ # include <sys/stat.h>
++ #endif
++ 
++ /* Test if something is a normal file.  */
++ #ifndef S_ISREG
++ #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
++ #endif
++ 
++ /* Test if something is a directory.  */
++ #ifndef S_ISDIR
++ #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
++ #endif
++ 
++ #if !defined(GPC) || defined(EGCS92)
++ /* Get libiberty declarations. */
++ #include "libiberty.h"
++ #endif
++ 
++ #endif /* __GCC_SYSTEM_H__ */
diff --git a/lang/gpc/files/patch-ao b/lang/gpc/files/patch-ao
new file mode 100644
index 000000000000..e5067d4eaec0
--- /dev/null
+++ b/lang/gpc/files/patch-ao
@@ -0,0 +1,95 @@
+*** toplev.c.orig	Thu Mar 23 14:19:51 2000
+--- toplev.c		Thu Mar 23 15:57:06 2000
+***************
+*** 304,309 ****
+--- 304,315 ----
+  
+  int optimize = 0;
+  
++ #ifdef GPC
++ /* Nonzero if called with --version (i.e. gpc called with --verbose).  */
++ 
++ int version_flag = 0;
++ #endif /* GPC */
++ 
+  /* Number of error messages and warning messages so far.  */
+  
+  int errorcount = 0;
+***************
+*** 590,595 ****
+--- 596,607 ----
+  
+  int flag_pedantic_errors = 0;
+  
++ #ifdef GPC
++ /* Nonzero means copy the source input to stderr.  */
++ 
++ extern int flag_debug_source;
++ #endif /* GPC */
++ 
+  /* flag_schedule_insns means schedule insns within basic blocks (before
+     local_alloc).
+     flag_schedule_insns_after_reload means schedule insns after
+***************
+*** 2897,2902 ****
+--- 2909,2921 ----
+  #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
+  #endif
+  
++ /* Dito.  */
++ #ifdef GPC
++ #define NOT_IN_GPC(X)
++ #else /* not GPC */
++ #define NOT_IN_GPC(X) X
++ #endif /* not GPC */
++ 
+    /* Forward declarations for nested functions are not "external",
+       but we need to treat them as if they were.  */
+    if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
+***************
+*** 2914,2922 ****
+  		 /* Don't output anything
+  		    when a tentative file-scope definition is seen.
+  		    But at end of compilation, do output code for them.  */
+! 		 if (! (! at_end && top_level
+  			&& (DECL_INITIAL (decl) == 0
+! 			    || DECL_INITIAL (decl) == error_mark_node)))
+  		   assemble_variable (decl, top_level, at_end, 0);
+  	       if (!output_bytecode
+  		   && decl == last_assemble_variable_decl)
+--- 2933,2941 ----
+  		 /* Don't output anything
+  		    when a tentative file-scope definition is seen.
+  		    But at end of compilation, do output code for them.  */
+! NOT_IN_GPC (     if (! (! at_end && top_level
+  			&& (DECL_INITIAL (decl) == 0
+!                           || DECL_INITIAL (decl) == error_mark_node)))     )
+  		   assemble_variable (decl, top_level, at_end, 0);
+  	       if (!output_bytecode
+  		   && decl == last_assemble_variable_decl)
+***************
+*** 3741,3747 ****
+--- 3760,3768 ----
+    register int i;
+    char *filename = 0;
+    int flag_print_mem = 0;
++ #ifndef GPC
+    int version_flag = 0;
++ #endif /* not GPC */
+    char *p;
+  
+    /* save in case md file wants to emit args as a comment.  */
+***************
+*** 3956,3961 ****
+--- 3977,3987 ----
+  		  case 'R':
+  		    sched2_dump = 1;
+  		    break;
++ #ifdef GPC
++                 case 'Y':
++                   flag_debug_source = 1;
++                   break;
++ #endif /* GPC */
+  		  case 'y':
+  		    set_yydebug (1);
+  		    break;
diff --git a/lang/gpc/files/patch-ap b/lang/gpc/files/patch-ap
new file mode 100644
index 000000000000..a8adf52be22e
--- /dev/null
+++ b/lang/gpc/files/patch-ap
@@ -0,0 +1,18 @@
+*** tree.c.orig	Tue Mar  3 02:37:46 1998
+--- tree.c	Thu Mar 23 15:58:48 2000
+***************
+*** 4742,4747 ****
+--- 4742,4754 ----
+    for (i = 0; i < bit_size; i++)
+      buffer[i] = 0;
+  
++ #ifdef GPC
++   /* Since sets are word-aligned in Pascal,
++      the first bits in the set may be unused.  */
++ 
++   domain_min -= domain_min % BITS_PER_WORD;
++ #endif /* GPC */
++ 
+    for (vals = TREE_OPERAND (init, 1); 
+         vals != NULL_TREE; vals = TREE_CHAIN (vals))
+      {
diff --git a/lang/gpc/files/patch-aq b/lang/gpc/files/patch-aq
new file mode 100644
index 000000000000..47bcd62055ef
--- /dev/null
+++ b/lang/gpc/files/patch-aq
@@ -0,0 +1,121 @@
+diff -P -N -C3 -r gpc.std/p/gpc-common.c gpc/p/gpc-common.c
+*** p/gpc-common.c.orig	Sat Dec 26 02:06:58 1998
+--- p/gpc-common.c		Thu Mar 23 18:24:40 2000
+***************
+*** 797,803 ****
+  
+  	    record_function_format (DECL_NAME (decl),
+  				    DECL_ASSEMBLER_NAME (decl),
+! 				    is_scan, format_num, first_arg_num);
+  	    break;
+  	  }
+  
+--- 797,803 ----
+  
+  	    record_function_format (DECL_NAME (decl),
+  				    DECL_ASSEMBLER_NAME (decl),
+! 				    is_scan, 0, format_num, first_arg_num);
+  	    break;
+  	  }
+  
+***************
+*** 1038,1043 ****
+--- 1038,1044 ----
+    tree assembler_name;		/* optional mangled identifier (for C++) */
+    int is_scan;			/* TRUE if *scanf */
+    int format_num;		/* number of format argument */
++   int null_format_ok;          /* TRUE if the format string may be NULL */
+    int first_arg_num;		/* number of first arg (zero for varargs) */
+  } function_format_info;
+  
+***************
+*** 1068,1082 ****
+  void
+  init_function_format_info ()
+  {
+!   record_function_format (get_identifier ("printf"), NULL_TREE, 0, 1, 2);
+!   record_function_format (get_identifier ("fprintf"), NULL_TREE, 0, 2, 3);
+!   record_function_format (get_identifier ("sprintf"), NULL_TREE, 0, 2, 3);
+!   record_function_format (get_identifier ("scanf"), NULL_TREE, 1, 1, 2);
+!   record_function_format (get_identifier ("fscanf"), NULL_TREE, 1, 2, 3);
+!   record_function_format (get_identifier ("sscanf"), NULL_TREE, 1, 2, 3);
+!   record_function_format (get_identifier ("vprintf"), NULL_TREE, 0, 1, 0);
+!   record_function_format (get_identifier ("vfprintf"), NULL_TREE, 0, 2, 0);
+!   record_function_format (get_identifier ("vsprintf"), NULL_TREE, 0, 2, 0);
+  
+    record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
+    record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
+--- 1069,1083 ----
+  void
+  init_function_format_info ()
+  {
+!   record_function_format (get_identifier ("printf"), NULL_TREE, 0, 0, 1, 2);
+!   record_function_format (get_identifier ("fprintf"), NULL_TREE, 0, 0, 2, 3);
+!   record_function_format (get_identifier ("sprintf"), NULL_TREE, 0, 0, 2, 3);
+!   record_function_format (get_identifier ("scanf"), NULL_TREE, 1, 0, 1, 2);
+!   record_function_format (get_identifier ("fscanf"), NULL_TREE, 1, 0, 2, 3);
+!   record_function_format (get_identifier ("sscanf"), NULL_TREE, 1, 0, 2, 3);
+!   record_function_format (get_identifier ("vprintf"), NULL_TREE, 0, 0, 1, 0);
+!   record_function_format (get_identifier ("vfprintf"), NULL_TREE, 0, 0, 2, 0);
+!   record_function_format (get_identifier ("vsprintf"), NULL_TREE, 0, 0, 2, 0);
+  
+    record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
+    record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
+***************
+*** 1093,1104 ****
+     (e.g. for varargs such as vfprintf).  */
+  
+  void
+! record_function_format (name, assembler_name, is_scan,
+  			format_num, first_arg_num)
+        tree name;
+        tree assembler_name;
+        int is_scan;
+        int format_num;
+        int first_arg_num;
+  {
+    function_format_info *info;
+--- 1094,1106 ----
+     (e.g. for varargs such as vfprintf).  */
+  
+  void
+! record_function_format (name, assembler_name, is_scan, null_format_ok,
+  			format_num, first_arg_num)
+        tree name;
+        tree assembler_name;
+        int is_scan;
+        int format_num;
++       int null_format_ok;
+        int first_arg_num;
+  {
+    function_format_info *info;
+***************
+*** 1122,1127 ****
+--- 1124,1130 ----
+  
+    info->is_scan = is_scan;
+    info->format_num = format_num;
++   info->null_format_ok = null_format_ok;
+    info->first_arg_num = first_arg_num;
+  }
+  
+diff -P -N -C3 -r gpc.std/p/gpc-defs.h gpc/p/gpc-defs.h
+*** p/gpc-defs.h.orig	Mon Dec 21 04:41:07 1998
+--- p/gpc-defs.h	Thu Mar 23 18:20:44 2000
+***************
+*** 622,628 ****
+  extern tree build_pascal_unary_op PROTO ((enum tree_code, tree, int));
+  extern tree build_pascal_pointer_reference PROTO ((tree));
+  extern tree build_pascal_address_expression PROTO ((tree));
+! extern void record_function_format PROTO ((tree, tree, int, int, int));
+  
+  /*
+   * construct an identifier_node for the assembler-name
+--- 622,628 ----
+  extern tree build_pascal_unary_op PROTO ((enum tree_code, tree, int));
+  extern tree build_pascal_pointer_reference PROTO ((tree));
+  extern tree build_pascal_address_expression PROTO ((tree));
+! extern void record_function_format PROTO ((tree, tree, int, int, int, int));
+  
+  /*
+   * construct an identifier_node for the assembler-name
diff --git a/lang/gpc/files/patch-ar b/lang/gpc/files/patch-ar
new file mode 100644
index 000000000000..6b0ce53c3a81
--- /dev/null
+++ b/lang/gpc/files/patch-ar
@@ -0,0 +1,19 @@
+*** p/rts/file.c.orig	Sat Jan 16 04:07:00 1999
+--- p/rts/file.c	Thu Mar 23 18:58:07 2000
+***************
+*** 1568,1574 ****
+  #ifdef HAVE_STATVFS
+  #include <sys/statvfs.h>
+  #elif defined(HAVE_STATFS)
+! #include <sys/vfs.h>
+  #endif
+  
+  void
+--- 1568,1574 ----
+  #ifdef HAVE_STATVFS
+  #include <sys/statvfs.h>
+  #elif defined(HAVE_STATFS)
+! #include <sys/mount.h>
+  #endif
+  
+  void
diff --git a/lang/gpc/files/patch-as b/lang/gpc/files/patch-as
new file mode 100644
index 000000000000..af9884303825
--- /dev/null
+++ b/lang/gpc/files/patch-as
@@ -0,0 +1,11 @@
+--- p/units/regexc.c	Tue Jan  5 08:53:29 1999
++++ p/units/regexc.c.new	Sun Apr 16 01:03:17 2000
+@@ -21,7 +21,7 @@
+ */
+ 
+ #include <stdlib.h>
+-#include <rxposix.h>
++#include <gnuregex.h>
+ 
+ typedef unsigned char Boolean;
+ 
diff --git a/lang/gpc/pkg-comment b/lang/gpc/pkg-comment
new file mode 100644
index 000000000000..360f666e6e32
--- /dev/null
+++ b/lang/gpc/pkg-comment
@@ -0,0 +1 @@
+A free 32-bit Pascal compiler
diff --git a/lang/gpc/pkg-descr b/lang/gpc/pkg-descr
new file mode 100644
index 000000000000..a8bfc470e8ad
--- /dev/null
+++ b/lang/gpc/pkg-descr
@@ -0,0 +1,10 @@
+GNU Pascal is part of the GNU compiler family, GNU CC or GCC.
+It combines a Pascal front-end with the proven GNU C back-end
+for code generation and optimization.  Unlike utilities such
+as p2c, this is a true compiler, not just a converter.
+			
+The current release 2.0 implements Standard Pascal (ISO 7185,
+level 1), a large subset of Extended Pascal (ISO 10206), and
+Borland Pascal.
+
+WWW: http://agnes.dida.physik.uni-essen.de/~gnu-pascal/
diff --git a/lang/gpc/pkg-plist b/lang/gpc/pkg-plist
new file mode 100644
index 000000000000..86388fa54b29
--- /dev/null
+++ b/lang/gpc/pkg-plist
@@ -0,0 +1,68 @@
+bin/gpc
+lib/gcc-lib/%%GNUHOST%%/2.8.1/gpc1
+lib/gcc-lib/%%GNUHOST%%/2.8.1/gpc-cpp
+lib/gcc-lib/%%GNUHOST%%/2.8.1/libgpc.a
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crt.inc
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crt.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtc.c
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtc.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtdospc.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtdummy.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtlinux386.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtunix.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/crtunix1.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/dos.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/dosc.c
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/dosunix.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/getopt.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/getopt.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/getoptc.c
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/gmp.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/gpc.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/gpcutil.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/internal.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/overlay.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/pexecutc.c
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/pexecute.h
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/pexecute.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/pipe.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/pipec.c
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/ports.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/printer.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/regex.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/regexc.c
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/strings.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/system.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/turbo3.pas
+lib/gcc-lib/%%GNUHOST%%/2.8.1/units/windos.pas
+@dirrm lib/gcc-lib/%%GNUHOST%%/2.8.1/units
+@exec install-info %D/info/gpc.info %D/info/dir
+@exec install-info %D/info/gpc.info-1 %D/info/dir
+@exec install-info %D/info/gpc.info-10 %D/info/dir
+@exec install-info %D/info/gpc.info-11 %D/info/dir
+@exec install-info %D/info/gpc.info-12 %D/info/dir
+@exec install-info %D/info/gpc.info-13 %D/info/dir
+@exec install-info %D/info/gpc.info-14 %D/info/dir
+@exec install-info %D/info/gpc.info-2 %D/info/dir
+@exec install-info %D/info/gpc.info-3 %D/info/dir
+@exec install-info %D/info/gpc.info-4 %D/info/dir
+@exec install-info %D/info/gpc.info-5 %D/info/dir
+@exec install-info %D/info/gpc.info-6 %D/info/dir
+@exec install-info %D/info/gpc.info-7 %D/info/dir
+@exec install-info %D/info/gpc.info-8 %D/info/dir
+@exec install-info %D/info/gpc.info-9 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-1 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-10 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-11 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-12 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-13 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-14 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-2 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-3 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-4 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-5 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-6 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-7 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-8 %D/info/dir
+@unexec install-info --delete %D/info/gpc.info-9 %D/info/dir