debian/0000755000000000000000000000000011350006354007163 5ustar debian/control0000644000000000000000000000242511350005224010564 0ustar Source: gprolog Section: devel Priority: optional Maintainer: Salvador Abreu Standards-Version: 3.7.2 Build-Depends: debhelper (>= 5), autoconf (>= 2.52), gcc (>> 4.2), autotools-dev, texlive-full, hevea (>= 1.09) Build-Depends-Indep: imagemagick, gsfonts Package: gprolog Architecture: i386 amd64 sparc mips mipsel alpha powerpc Depends: ${shlibs:Depends} Recommends: gprolog-doc Conflicts: Description: GNU Prolog compiler GNU Prolog is a free Prolog compiler with constraint solving over finite domains (FD) developed at INRIA by Daniel Diaz. GNU Prolog is based on two systems developed by the same author (with lot of code rewriting and a lot of new extensions): wamcc and clp(FD). Much work has been devoted to make it ISO compatible, full compliance being one of its goals. . This package contains the compiler and runtime system for the ISO standard version of GNU Prolog. Package: gprolog-doc Architecture: all Section: doc Conflicts: gprolog (<< 1.2.7) Recommends: xpdf | pdf-viewer, w3m | www-browser Description: documentation for the GNU Prolog compiler GNU Prolog is a free Prolog compiler with constraint solving over finite domains (FD) developed at INRIA by Daniel Diaz. . This package contains the documentation (both PDF and HTML) for GNU Prolog. debian/gprolog.postinst0000644000000000000000000000125711350005224012441 0ustar #!/bin/sh -e #DEBHELPER# case "$1" in configure) # -- setup the regular "gprolog" alternatives -------------------------- update-alternatives \ --install /usr/bin/gprolog gprolog ${LIB}/bin/gprolog 10 \ --slave /usr/bin/gplc gplc ${LIB}/bin/gplc \ --slave /usr/bin/hexgplc hexgplc ${LIB}/bin/hexgplc \ --slave /usr/include/gprolog gprolog-inc ${LIB}/include # -- create a plain "prolog" command alternative ----------------------- update-alternatives \ --install /usr/bin/prolog prolog ${LIB}/bin/gprolog 10 \ --slave \ /usr/share/man/man1/prolog.1.gz prolog.1.gz \ /usr/share/man/man1/gprolog.1.gz ;; esac debian/files.gprolog-doc0000644000000000000000000000015111350005224012413 0ustar usr/share/doc/gprolog-doc/gprolog.html usr/share/doc/gprolog-doc/examples usr/share/doc-base/gprolog-doc debian/gprolog-doc.doc-base0000644000000000000000000000122711350005224012773 0ustar Document: gprolog-doc Title: Online docs for GNU Prolog compiler Author: Daniel Diaz Abstract: GNU Prolog is a free Prolog compiler with constraint solving over finite domains (FD) developed by Daniel Diaz. GNU Prolog is based on two systems developed by the same author (with lot of code rewriting and a lot of new extensions): wamcc and clp(FD). A lot of work has been devoted to the ISO compatibility, GNU Prolog is very close to the ISO standard. Section: Apps/Programming Format: PDF Files: /usr/share/doc/gprolog-doc/gprolog.pdf Format: HTML Index: /usr/share/doc/gprolog-doc/gprolog.html/index.html Files: /usr/share/doc/gprolog-doc/gprolog.html/* debian/manpage0000644000000000000000000000361611350005224010517 0ustar .\" Hey, Emacs! This is an -*- nroff -*- source file. .\" .\" Copyright (C) 2000 Milan Zamazal .\" .\" This 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, or (at your option) any later .\" version. .\" .\" This 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 with .\" your Debian GNU/Linux system, in /usr/share/common-licenses/GPL, or with .\" the dpkg source package as the file COPYING. If not, write to the Free .\" Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. .\" .\" This manpage is created thanks to: .\" Kai Henningsen , .\" Ian Jackson , .\" David H. Silber & .\" Carl Streeter . .\" Erick Branderhorst .\" .TH GPROLOG 1 "September 2001" "Debian Project" "Debian GNU/Linux" .SH NAME GNU Prolog \- Prolog compiler, includes CLP(FD). .SH SYNOPSIS .B gprolog .br .B gplc .br .B hexgplc .br .B pl2wam .br .B wam2ma .br .B ma2asm .br .B fd2c .SH DESCRIPTION This program does not have a useful manpage. .PP If you install the .B gprolog-doc package, you will find GNU Prolog documentation in the file /usr/share/doc/gprolog-doc/manual.pdf or you can read it in HTML format starting with the file /usr/share/doc/gprolog-doc/gprolog.html/index.html or at the URL .B http://localhost/doc/gprolog-doc/gprolog.html/ .SH AUTHOR Milan Zamazal . .br Salvador Abreu . .SH THANKS Kai Henningsen, Ian Jackson, David H. Silber, Carl Streeter, Erick Branderhorst. debian/source/0000755000000000000000000000000011350006354010463 5ustar debian/source/format0000644000000000000000000000001411350440146011672 0ustar 3.0 (quilt) debian/changelog0000644000000000000000000004153611350006242011042 0ustar gprolog (1.3.0-6.1) unstable; urgency=low [Jari Aalto] * Non-maintainer upload. - Move to packaging format "3.0 (quilt)" due to patch. * debian/patches - (Number 10): Add patch to fix latex error. Patch thanks to Ilya Barygin https://launchpad.net/ubuntu/+source/gprolog/1.3.0-6ubuntu1 (RC bug FTBFS serious; Closes: #562394). * debian/source/format - New file. -- Jari Aalto Wed, 17 Mar 2010 00:53:43 +0200 gprolog (1.3.0-6) unstable; urgency=low * revert to regular gcc: 4.2 (closes: #463289) * debian/rules: get rid of bashisms (closes: #478390) * src/EnginePl/machine.c: don't include ; thanks to Sebastian Bober (closes: #456842, #442980) -- Salvador Abreu Thu, 08 May 2008 15:54:02 +0100 gprolog (1.3.0-5) unstable; urgency=low * src/configure.in: recognize sparc-linux! * debian/changelog: back to plain ASCII... -- Salvador Abreu Sat, 08 Dec 2007 20:11:48 +0000 gprolog (1.3.0-4) unstable; urgency=low * Work on mips/mipsel again (closes: #448952); patch courtesy of Thiemo Seufer * Convert changelog, etc. to UTF-8 (closes: #453994, #454012) * EnginePL/wam_inst.h: correctly type destructor callback for use by C++ programs (closes: #452958) * Revert to the default GCC (4.1) because 4.2 doesn't seem to be up-to-date on several architectures... eventually this will allow gprolog to migrate to testing. * Re-close erroneously reopened bugs (closes: #397294, #412671) * Remove silly menu entry for gprolog top-level shell * Don't compress PDF manual * Make lintian (a little bit) happier ;-) -- Salvador Abreu Thu, 06 Dec 2007 10:30:41 +0000 gprolog (1.3.0-3) unstable; urgency=low * Even more dependencies on texlive packages: now include texlive-full in the hope it will be enough (closes: #421247). * use gcc-4.2 -- Salvador Abreu Sun, 20 May 2007 23:35:14 +0100 gprolog (1.3.0-2) unstable; urgency=low * Depend on texlive-latex-recommended: needed to build docs. -- Salvador Abreu Thu, 26 Apr 2007 12:03:38 +0100 gprolog (1.3.0-1) unstable; urgency=low * New upstream release * Remove Homepage: headers from debian/control (closes: #412671) * Include dvi & ps doc generation patch by Frank Kuester (closes: #397294) * Depend on some texlive packages, such as texlive-extra-utils, instead of the old tetex ones (closes: #420335) * Reset compilation flags to be less pessimistic (back to using -O3) * Adapt to shallower directory scheme (not based on sourceforge.net version anymore) -- Salvador Abreu Wed, 25 Apr 2007 00:32:13 +0100 gprolog (1.2.18-17) unstable; urgency=low * Fix non-ascii character in doc/use.tex; this only seems to be a problem with more recent versions of hevea. (closes: #397135) * Fix unaligned access on amd64. This is done in a way which I'd rather not have to confess: I had GCC produce assembly code, which is then patched via a sed script before being fed to as. Thanks to ramune@net-ronin.org for pointing out the location of the problem. (closes: #356406) * Fixed a few things in order to be able to use more recent versions of gcc, most notably casts in lvalues. As of now, gcc 4.1 can be used to compile gprolog! * Doesn't leave anything in /etc/alternatives nor /usr/bin after being purged. (closes: #358256) -- Salvador Abreu Mon, 6 Nov 2006 10:40:23 +0000 gprolog (1.2.18-16) unstable; urgency=low * touch all *.wam files to ensure buildds don't get mixed up about .pl and .wam having similar modification times. Was having trouble with just about all of them. -- Salvador Abreu Tue, 1 Nov 2005 08:15:20 +0000 gprolog (1.2.18-15) unstable; urgency=low * include mips and mipsel in Architecture: in debian/control, as the built-in support for MIPS has been extended for Linux, courtesy of Thiemo Seufer (closes: #272829). -- Salvador Abreu Mon, 31 Oct 2005 10:15:57 +0000 gprolog (1.2.18-14) unstable; urgency=low * enforce gcc version 3.3, as it's the "last known good" version for gprolog (closes: #323528). -- Salvador Abreu Wed, 17 Aug 2005 09:31:14 +0100 gprolog (1.2.18-13) unstable; urgency=low * don't use "-nosymb" to deal with recent versions of hevea: 1.07 and later (closes: #321977) * acknowledge NMUs by Steve Langasek (closes: #271399) -- Salvador Abreu Mon, 15 Aug 2005 12:51:59 +0100 gprolog (1.2.18-12) unstable; urgency=low * The "attempt to be free from x86" release... ;-) * Acknowledge NMUs (1.2.18-11.1 and -11.2). * debian/rules: removed bashisms (closes: #265032). Thanks Roland Stigge * debian/menu: use gprolog-iso instead of gprolog (alternative) to satisfy lintian. * src/src/Ma2Asm/powerpc_any.c: fix duplicate patch (same problem as fixed in 1.2.18-10 for amd64) * src/src/Ma2Asm/ma2asm_inst.c: try to ignore OS for mips architecture. * Hopefully this version might finally make it into testing, now that it's no longer considered x86-only (it was being held because the buildds weren't taking it and yet there were old alpha and sparc versions lying around), so I'm closing the can't-build for sarge, which applied to a very old version (closes: #268671). -- Salvador Abreu Mon, 20 Sep 2004 22:39:15 +0100 gprolog (1.2.18-11.2) unstable; urgency=low * Non-maintainer upload. * Also add tetex-extra into Build-Depends, needed on the buildds even though it appears not to have mattered locally (closes: #271399). * Touch src/src/BipsPl/arith_inl.wam as part of the build, to deal with timestamp skew issues when building. -- Steve Langasek Wed, 15 Sep 2004 02:55:14 -0700 gprolog (1.2.18-11.1) unstable; urgency=low * Non-maintainer upload. * Move tetex-bin and hevea from build-depends-indep back to build-depends, as they're used in the build target (closes: #271399). -- Steve Langasek Tue, 14 Sep 2004 15:40:57 -0700 gprolog (1.2.18-11) unstable; urgency=low * BipsPl/term_supp.c: incorporate upstream changes. * debian/control: Build-Depends: split into Build-Depends-Indep: * debian/control: gprolog-doc is now in Recommends: -- Salvador Abreu Thu, 24 Jun 2004 14:48:57 +0100 gprolog (1.2.18-10) unstable; urgency=low * fix compilation on amd64 (closes: #252868) * Ma2asm/x86_64_any.c: remove duplicate code. -- Salvador Abreu Sat, 12 Jun 2004 10:46:59 +0100 gprolog (1.2.18-9) unstable; urgency=low * new upstream version: merge patches. -- Salvador Abreu Mon, 19 Apr 2004 13:38:29 +0100 gprolog (1.2.18-8) unstable; urgency=low * rebuild with gprolog (-iso), NOT with gprolog-cx (sneak preview...) * EnginePl/wam_archi.def: decreased default area sizes to something more reasonable (closes: #216697). -- Salvador Abreu Tue, 21 Oct 2003 10:59:08 +0100 gprolog (1.2.18-7) unstable; urgency=low * bug fixes weren't properly registered since 1.2.18-1, so repeat (closes: #211708, #199147) * ought to migrate to testing, someday... (closes: #214903) -- Salvador Abreu Fri, 17 Oct 2003 07:06:57 +0100 gprolog (1.2.18-6) unstable; urgency=low * EnginePl/wam_inst.c: Create_Water_Mark(): check for overflow. * EnginePl/wam_inst.h: bump size of MAXWMARK. -- Salvador Abreu Mon, 22 Sep 2003 00:08:06 +0100 gprolog (1.2.18-5) unstable; urgency=low * Update to Standards-Version 3.6.1 * Compile without optimization as a workaround to avoid SIGINT handler reinstallation problem. This must be looked into again for a better fix. (closes: #211708) -- Salvador Abreu Sun, 21 Sep 2003 09:41:02 +0100 gprolog (1.2.18-4) unstable; urgency=low * BipsPl/scan_supp.h and EnginePl/engine.h: grossly increase size of the glob_buff[] array, as it was being victimized by buffer overflows. * BipsPl/format_c.c: urk... bump temp buffer sizes from 2K to 64K. * BipsPl/stream_supp.c: Stream_Printf(): str[] is now dynamically-sized as necessary (uses vsnprintf(3) instead of vsprintf(3)). This was a nasty one!!! * Increase default area sizes... -- Salvador Abreu Tue, 12 Aug 2003 19:58:05 +0100 gprolog (1.2.18-3) unstable; urgency=low * More Wam2Ma/wam_parser.c constants bumped; this time to deal with very long lines. * Fixed sparc declarations in src/EnginePl/engine1.c for real. * doc/packages.tex: use colored links, as per Martin Pitt's suggestion: it does look better... (closes: #199147) -- Salvador Abreu Thu, 3 Jul 2003 16:38:16 +0100 gprolog (1.2.18-2) unstable; urgency=low * src/EnginePl/engine1.c: fix sparc declarations after statement. -- Salvador Abreu Mon, 16 Jun 2003 15:24:21 +0100 gprolog (1.2.18-1) unstable; urgency=low * New upstream release * Wam2Ma/wam_parser.c: bump a limit to deal with larger source files. * Rebuild fixes formatting problems (closes: #191135). * Don't reference inexistant URL http://www.logic-programming.org/ (closes: #111191). * Include doc-base entry for gprolog-doc as well (closes: #190636). * Bumped Standards-Version to 3.5.10 * Copied config.{sub,guess} from autotools-dev to get the latest. -- Salvador Abreu Mon, 16 Jun 2003 13:28:54 +0100 gprolog (1.2.17-2) unstable; urgency=low * src/src/configure.in, src/src/config.{sub,guess}: adapt to latest versions and recognize wider range of designation for supported architectures. * debian/rules: in "clean" target: run autoconf when needed. * src/src/TopComp/prolog_path.c: Search_Path(): look in PROLOG_BINDIR first! * debian/rules: *really* make sure we're using the locally generated gplc & friends: it's critical when rebuilding the system... * debian/rules: new target "config". -- Salvador Abreu Mon, 17 Feb 2003 00:37:17 +0000 gprolog (1.2.17-1) unstable; urgency=low * New upstream release * Updated Standards-Version to 3.5.8 * Restrict binary packages to known working architectures (i386, sparc, mips, alpha, powerpc) * Fixed postinst and prerm scripts to look for executables in the right place. * machine1.c: modified execvp() calls to try library directory first. * configure.in, gp_config.h.in: added PROLOG_BINDIR and PROLOG_LIBDIR constants (for above). * top_comp.c: use PROLOG_LIBDIR to locate *.o files. * Fixed library locations introduced in version 1.2.11-4, to adhere to the scheme /usr/lib/gprolog-VARIANT/. For now, VARIANT is only "iso" but the "cx" (Contextual Logic Programming) packages are on the way... * Lintian 1.22.6 approved :) -- Salvador Abreu Thu, 13 Feb 2003 09:31:28 +0000 gprolog (1.2.13-1) unstable; urgency=low * new upstream version. -- Salvador Abreu Sat, 4 May 2002 23:40:14 +0100 gprolog (1.2.11-4) unstable; urgency=low * new executable file locate in order to prepare to host several variants of gprolog (eg. gprolog-cx) simultaneously. * gprolog.postinst, gprolog.prerm: put #DEBHELPER# line AT THE END, just in case things like update-menus, etc. fail. -- Salvador Abreu Fri, 3 May 2002 11:22:11 +0100 gprolog (1.2.11-3) unstable; urgency=medium * merged fixes from upstream 1.2.12: allow for much larger memory sizes, user settable via GLOBALSZ=NNN, etc. NNN are Kbytes; see docs. * configure for minimal hardware requirements (closes: #143406). -- Salvador Abreu Thu, 18 Apr 2002 13:36:18 +0100 gprolog (1.2.11-2) unstable; urgency=low * REALLY fixed watermark code, this time! * configure --with-c-flags=... instead of specifying in the `make' command line: configure would think it could use machine registers that, in fact, it shouldn't. -- Salvador Abreu Tue, 26 Mar 2002 17:57:56 +0000 gprolog (1.2.11-1) unstable; urgency=low * new upstream version. * doc/Makefile: hh_do_hhc_hhk is to be found here. Patch courtesy of Neal H Walfield (closes: #139643) * added build-dependencies on tetex-extra and gsfonts (closes: #139639) * fix problem with watermark code introduced in 1.2.9. * use autoconf >= 2.52. -- Salvador Abreu Mon, 25 Mar 2002 13:47:05 +0000 gprolog (1.2.9-3) unstable; urgency=low * use M-q instead of C-u M-q in control (closes: #135231 >-) * incorporate top_comp.c changes from 1.2.10. -- Salvador Abreu Thu, 28 Feb 2002 22:21:08 +0000 gprolog (1.2.9-2) unstable; urgency=low * remove alternatives upon package deletion (closes: #127035) -- Salvador Abreu Thu, 3 Jan 2002 16:34:19 +0000 gprolog (1.2.9-1) unstable; urgency=low * new upstream version. * added --enable-watermark to provide for external destructors on choicepoint deletion. * wam2ma: fixed weirdness: dmalloc is no longer a build dependency. fix went upstream also. (closes: #126343) * gprolog-doc: make sure *.html goes in the right place. -- Salvador Abreu Mon, 24 Dec 2001 18:55:15 +0000 gprolog (1.2.7-3) unstable; urgency=low * clean up after calling mkstemp(2). moved upstream into the CVS archive. (closes: #114529) -- Salvador Abreu Sun, 7 Oct 2001 14:46:17 +0100 gprolog (1.2.7-2) unstable; urgency=low * gprolog-doc is now in the "doc" distribution section. * reworked doc-base stuff to properly deal with binary and documentation packages. (closes: #114220) -- Salvador Abreu Tue, 2 Oct 2001 21:17:42 +0100 gprolog (1.2.7-1) unstable; urgency=low * New maintainer. (closes: #71675) * New upstream release. * Added a menu entry and an icon. * Split into two binary packages (gprolog and gprolog-doc). * Complete rewrite of debian/rules. * Fully rebuild docs everytime, produce HTML and PDF versions. * Updated manpages. * Linking wam2ma with dmalloc as regular mallocs seem to cause grief. * New function Update_Water_Mark/2 in EnginePl/wam_inst.c, needed to create external nondeterminate predicates which need to release resources when a choice-point is deleted. * lintian 1.20.14 approved. -- Salvador Abreu Mon, 24 Sep 2001 15:57:15 +0100 gprolog (1.2.1-1) unstable; urgency=low * New upstream release. (Closes:Bug#98347) * Use doc-base. (Closes:Bug#96025) * Added a menu entry. (Closes:Bug#83493) -- Brent A. Fulgham Mon, 24 Sep 2001 20:44:41 -0700 gprolog (1.2.0-3) unstable; urgency=low * Orphaned. -- Milan Zamazal Wed, 29 Aug 2001 10:58:15 +0200 gprolog (1.2.0-2) unstable; urgency=low * Call update-alternatives in prerm, not in postrm; closes: #74558. * New upstream version. -- Milan Zamazal Sun, 30 Jul 2000 20:46:56 +0200 gprolog (1.1.2-1) unstable; urgency=low * New upstream version. * Use .gz extension in links to the main manpage. * Lintian 1.11.2 satisfied. -- Milan Zamazal Sun, 23 Jul 2000 12:16:49 +0200 gprolog (1.1.0-4) frozen unstable; urgency=low * Broken links to man pages in alternatives install fixed; closes: #57238. * Do not install DVI version of the manual. * Very simple man page created. -- Milan Zamazal Wed, 9 Feb 2000 20:48:06 +0100 gprolog (1.1.0-3) unstable; urgency=low * Standards 3.1.1. * Build dependencies introduced. * Download location fixed. * Reference to GPL location on Debian fixed. * Copyright updated. -- Milan Zamazal Sun, 5 Dec 1999 10:32:24 +0100 gprolog (1.1.0-2) unstable; urgency=low * Grr, move include and lib files to the proper location again; closes: #48702. -- Milan Zamazal Sun, 31 Oct 1999 18:43:47 +0100 gprolog (1.1.0-1) unstable; urgency=low * New upstream version. * More cleanups when cleaning. * Lintian 1.10 satisfied. -- Milan Zamazal Sun, 24 Oct 1999 19:48:48 +0200 gprolog (1.0.5-1) unstable; urgency=low * New upstream version. (This is a development version, but the 1.0.0 version does not compile with gcc 2.95 and glibc 2.1 and the development version is suggested for glibc 2.1 systems.) * Moved to FHS. * Compiled with glibc 2.1. * Standards 3.0.1. * Lintian 1.9.2 satisfied. -- Milan Zamazal Fri, 1 Oct 1999 21:31:19 +0200 gprolog (1.0.0-2) unstable; urgency=low * All GIFs removed from the binary package to avoid problems with bad ideas. -- Milan Zamazal Mon, 30 Aug 1999 21:06:56 +0200 gprolog (1.0.0-1) unstable; urgency=low * Initial Release. * Lintian 1.1 satisfied. -- Milan Zamazal Sun, 25 Apr 1999 16:07:35 +0200 debian/patches/0000755000000000000000000000000011350441165010615 5ustar debian/patches/debian-changes-1.3.0-6.10000644000000000000000000120663611350441165014345 0ustar Description: Upstream changes introduced in version 1.3.0-6.1 This patch has been created by dpkg-source during the package build. Here's the last changelog entry, hopefully it gives details on why those changes were made: . gprolog (1.3.0-6.1) unstable; urgency=low . [Jari Aalto] * Non-maintainer upload. - Move to packaging format "3.0 (quilt)" due to patch. * debian/patches - (Number 10): Add patch to fix latex error. Patch thanks to Ilya Barygin https://launchpad.net/ubuntu/+source/gprolog/1.3.0-6ubuntu1 (RC bug FTBFS serious; Closes: #562394). * debian/source/format - New file. . The person named in the Author field signed this changelog entry. Author: Jari Aalto Bug-Debian: http://bugs.debian.org/562394 --- The information above should follow the Patch Tagging Guidelines, please checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here are templates for supplementary fields that you might want to add: Origin: , Bug: Bug-Debian: http://bugs.debian.org/ Forwarded: Reviewed-By: Last-Update: --- /dev/null +++ gprolog-1.3.0/config.sub @@ -0,0 +1,1622 @@ +#! /bin/sh +# Configuration validation subroutine script. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, +# Inc. + +timestamp='2007-01-18' + +# This file is (in principle) common to ALL GNU software. +# The presence of a machine in this file suggests that SOME GNU software +# can handle that machine. It does not imply ALL GNU software can. +# +# This file 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., 51 Franklin Street - Fifth Floor, Boston, MA +# 02110-1301, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + + +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# Configuration subroutine to validate and canonicalize a configuration type. +# Supply the specified configuration type as an argument. +# If it is invalid, we print an error message on stderr and exit with code 1. +# Otherwise, we print the canonical config type on stdout and succeed. + +# This file is supposed to be the same for all GNU packages +# and recognize all the CPU types, system types and aliases +# that are meaningful with *any* GNU software. +# Each package is responsible for reporting which valid configurations +# it does not support. The user should be able to distinguish +# a failure to support a valid configuration from a meaningless +# configuration. + +# The goal of this file is to map all the various variations of a given +# machine specification into a single specification in the form: +# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +# or in some cases, the newer four-part form: +# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +# It is wrong to echo any other type of specification. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + +Canonicalize a configuration name. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.sub ($timestamp) + +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 +Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit ;; + + * ) + break ;; + esac +done + +case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; +esac + +# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). +# Here we must recognize all the valid KERNEL-OS combinations. +maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` +case $maybe_os in + nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \ + uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \ + storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; +esac + +### Let's recognize common machines as not being operating systems so +### that things like config.sub decstation-3100 work. We also +### recognize some manufacturers as not being operating systems, so we +### can provide default operating systems below. +case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis | -knuth | -cray) + os= + basic_machine=$1 + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco6) + os=-sco5v6 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5v6*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; +esac + +# Decode aliases for certain CPU-COMPANY combinations. +case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | am33_2.0 \ + | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \ + | bfin \ + | c4x | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | fido | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | i370 | i860 | i960 | ia64 \ + | ip2k | iq2000 \ + | m32c | m32r | m32rle | m68000 | m68k | m88k \ + | maxq | mb | microblaze | mcore | mep \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64vr | mips64vrel \ + | mips64orion | mips64orionel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mips64vr5900 | mips64vr5900el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64r2 | mipsisa64r2el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | mt \ + | msp430 \ + | nios | nios2 \ + | ns16k | ns32k \ + | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ + | pyramid \ + | score \ + | sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ + | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ + | spu | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ + | v850 | v850e \ + | we32k \ + | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ + | z8k) + basic_machine=$basic_machine-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12) + # Motorola 68HC11/12. + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + ms1) + basic_machine=mt-unknown + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* | avr32-* \ + | bfin-* | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ + | clipper-* | craynv-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* | iq2000-* \ + | m32c-* | m32r-* | m32rle-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | maxq-* | mcore-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mips64vr5900-* | mips64vr5900el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64r2-* | mipsisa64r2el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipstx39-* | mipstx39el-* \ + | mmix-* \ + | mt-* \ + | msp430-* \ + | nios-* | nios2-* \ + | none-* | np1-* | ns16k-* | ns32k-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ + | pyramid-* \ + | romp-* | rs6000-* \ + | sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ + | sparclite-* \ + | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \ + | tahoe-* | thumb-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tron-* \ + | v850-* | v850e-* | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ + | xstormy16-* | xtensa-* \ + | ymp-* \ + | z8k-*) + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + abacus) + basic_machine=abacus-unknown + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amd64-*) + basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + craynv) + basic_machine=craynv-cray + os=-unicosmp + ;; + cr16c) + basic_machine=cr16c-unknown + os=-elf + ;; + crds | unos) + basic_machine=m68k-crds + ;; + crisv32 | crisv32-* | etraxfs*) + basic_machine=crisv32-axis + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + crx) + basic_machine=crx-unknown + os=-elf + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + djgpp) + basic_machine=i586-pc + os=-msdosdjgpp + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; +# I'm not sure what "Sysv32" means. Should this be sysv3.2? + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + mingw32) + basic_machine=i386-pc + os=-mingw32 + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + ms1-*) + basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + openrisc | openrisc-*) + basic_machine=or32-unknown + ;; + os400) + basic_machine=powerpc-ibm + os=-os400 + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pc98) + basic_machine=i386-pc + ;; + pc98-*) + basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc) basic_machine=powerpc-unknown + ;; + ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rdos) + basic_machine=i386-pc + os=-rdos + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + s390 | s390-*) + basic_machine=s390-ibm + ;; + s390x | s390x-*) + basic_machine=s390x-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sde) + basic_machine=mipsisa32-sde + os=-elf + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh5el) + basic_machine=sh5le-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tic54x | c54x*) + basic_machine=tic54x-unknown + os=-coff + ;; + tic55x | c55x*) + basic_machine=tic55x-unknown + os=-coff + ;; + tic6x | c6x*) + basic_machine=tic6x-unknown + os=-coff + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + tpf) + basic_machine=s390x-ibm + os=-tpf + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xbox) + basic_machine=i686-pc + os=-mingw32 + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + +# Here we handle the default manufacturer of certain CPU types. It is in +# some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + mmix) + basic_machine=mmix-knuth + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; +esac + +# Here we canonicalize certain aliases for manufacturers. +case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; +esac + +# Decode manufacturer-specific aliases for certain operating systems. + +if [ x"$os" != x"" ] +then +case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ + | -openbsd* | -solidbsd* \ + | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ + | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* \ + | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \ + | -uxpv* | -beos* | -mpeix* | -udk* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ + | -skyos* | -haiku* | -rdos* | -toppers* | -drops*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux-dietlibc) + os=-linux-dietlibc + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -os400*) + os=-os400 + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -syllable*) + os=-syllable + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -tpf*) + os=-tpf + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -kaos*) + os=-kaos + ;; + -zvmoe) + os=-zvmoe + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; +esac +else + +# Here we handle the default operating systems that come with various machines. +# The value should be what the vendor currently ships out the door with their +# machine or put another way, the most popular os provided with the machine. + +# Note that if you're going to try to match "-MANUFACTURER" here (say, +# "-sun"), then you have to tell the case statement up towards the top +# that MANUFACTURER isn't an operating system. Otherwise, code above +# will signal an error saying that MANUFACTURER isn't an operating +# system, and we'll never get to this point. + +case $basic_machine in + score-*) + os=-elf + ;; + spu-*) + os=-elf + ;; + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + # This also exists in the configure program, but was not the + # default. + # os=-sunos4 + ;; + m68*-cisco) + os=-aout + ;; + mep-*) + os=-elf + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-haiku) + os=-haiku + ;; + *-ibm) + os=-aix + ;; + *-knuth) + os=-mmixware + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; +esac +fi + +# Here we handle the case where we know the os, and the CPU type, but not the +# manufacturer. We pick the logical manufacturer. +vendor=unknown +case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -os400*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -tpf*) + vendor=ibm + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; +esac + +echo $basic_machine$os +exit + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: --- /dev/null +++ gprolog-1.3.0/config.guess @@ -0,0 +1,1516 @@ +#! /bin/sh +# Attempt to guess a canonical system name. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, +# Inc. + +timestamp='2007-03-06' + +# This file 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., 51 Franklin Street - Fifth Floor, Boston, MA +# 02110-1301, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + + +# Originally written by Per Bothner . +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# This script attempts to guess a canonical system name similar to +# config.sub. If it succeeds, it prints the system name on stdout, and +# exits with 0. Otherwise, it exits with 1. +# +# The plan is that this can be called by configure scripts if you +# don't specify an explicit build system type. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 +Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ; set_cc_for_build= ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + sh5el) machine=sh5le-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep __ELF__ >/dev/null + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit ;; + *:OpenBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} + exit ;; + *:ekkoBSD:*:*) + echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} + exit ;; + *:SolidBSD:*:*) + echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} + exit ;; + macppc:MirBSD:*:*) + echo powerpc-unknown-mirbsd${UNAME_RELEASE} + exit ;; + *:MirBSD:*:*) + echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} + exit ;; + alpha:OSF1:*:*) + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + ;; + *5.*) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + ;; + esac + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Pn.n version is a patched version. + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + exit ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit ;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit ;; + *:z/VM:*:*) + echo s390-ibm-zvmoe + exit ;; + *:OS400:*:*) + echo powerpc-ibm-os400 + exit ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit ;; + arm:riscos:*:*|arm:RISCOS:*:*) + echo arm-unknown-riscos + exit ;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit ;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit ;; + DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7; exit ;; + esac ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + i86pc:SunOS:5.*:*) + echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit ;; + m68k:machten:*:*) + echo m68k-apple-machten${UNAME_RELEASE} + exit ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && + dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && + SYSTEM_NAME=`$dummy $dummyarg` && + { echo "$SYSTEM_NAME"; exit; } + echo mips-mips-riscos${UNAME_RELEASE} + exit ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` + then + echo "$SYSTEM_NAME" + else + echo rs6000-ibm-aix3.2.5 + fi + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit ;; + *:AIX:*:[45]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + eval $set_cc_for_build + + # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating + # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler + # generating 64-bit code. GNU and HP use different nomenclature: + # + # $ CC_FOR_BUILD=cc ./config.guess + # => hppa2.0w-hp-hpux11.23 + # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess + # => hppa64-hp-hpux11.23 + + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | + grep __LP64__ >/dev/null + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + echo unknown-hitachi-hiuxwe2 + exit ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + *:UNICOS/mp:*:*) + echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:FreeBSD:*:*) + case ${UNAME_MACHINE} in + pc98) + echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + amd64) + echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + *) + echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + esac + exit ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit ;; + *:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit ;; + i*:windows32*:*) + # uname -m includes "-pc" on this system. + echo ${UNAME_MACHINE}-mingw32 + exit ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit ;; + *:Interix*:[3456]*) + case ${UNAME_MACHINE} in + x86) + echo i586-pc-interix${UNAME_RELEASE} + exit ;; + EM64T | authenticamd) + echo x86_64-unknown-interix${UNAME_RELEASE} + exit ;; + esac ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit ;; + amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) + echo x86_64-unknown-cygwin + exit ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + *:GNU:*:*) + # the GNU system + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland + echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu + exit ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit ;; + arm*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + avr32*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + cris:Linux:*:*) + echo cris-axis-linux-gnu + exit ;; + crisv32:Linux:*:*) + echo crisv32-axis-linux-gnu + exit ;; + frv:Linux:*:*) + echo frv-unknown-linux-gnu + exit ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + m32r*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + mips:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips + #undef mipsel + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mipsel + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips + #else + CPU= + #endif + #endif +EOF + eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' + /^CPU/{ + s: ::g + p + }'`" + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } + ;; + mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips64 + #undef mips64el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mips64el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips64 + #else + CPU= + #endif + #endif +EOF + eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' + /^CPU/{ + s: ::g + p + }'`" + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } + ;; + or32:Linux:*:*) + echo or32-unknown-linux-gnu + exit ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-gnu + exit ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-gnu + exit ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null + if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi + echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} + exit ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-gnu ;; + PA8*) echo hppa2.0-unknown-linux-gnu ;; + *) echo hppa-unknown-linux-gnu ;; + esac + exit ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-gnu + exit ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux + exit ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + vax:Linux:*:*) + echo ${UNAME_MACHINE}-dec-linux-gnu + exit ;; + x86_64:Linux:*:*) + echo x86_64-unknown-linux-gnu + exit ;; + xtensa:Linux:*:*) + echo xtensa-unknown-linux-gnu + exit ;; + i*86:Linux:*:*) + # The BFD linker knows what the default object file format is, so + # first see if it will tell us. cd to the root directory to prevent + # problems with other programs or directories called `ld' in the path. + # Set LC_ALL=C to ensure ld outputs messages in English. + ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ + | sed -ne '/supported targets:/!d + s/[ ][ ]*/ /g + s/.*supported targets: *// + s/ .*// + p'` + case "$ld_supported_targets" in + elf32-i386) + TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" + ;; + a.out-i386-linux) + echo "${UNAME_MACHINE}-pc-linux-gnuaout" + exit ;; + coff-i386) + echo "${UNAME_MACHINE}-pc-linux-gnucoff" + exit ;; + "") + # Either a pre-BFD a.out linker (linux-gnuoldld) or + # one that does not give us useful --help. + echo "${UNAME_MACHINE}-pc-linux-gnuoldld" + exit ;; + esac + # Determine whether the default compiler is a.out or elf + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #ifdef __ELF__ + # ifdef __GLIBC__ + # if __GLIBC__ >= 2 + LIBC=gnu + # else + LIBC=gnulibc1 + # endif + # else + LIBC=gnulibc1 + # endif + #else + #if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) + LIBC=gnu + #else + LIBC=gnuaout + #endif + #endif + #ifdef __dietlibc__ + LIBC=dietlibc + #endif +EOF + eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' + /^LIBC/{ + s: ::g + p + }'`" + test x"${LIBC}" != x && { + echo "${UNAME_MACHINE}-pc-linux-${LIBC}" + exit + } + test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; } + ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit ;; + i*86:syllable:*:*) + echo ${UNAME_MACHINE}-pc-syllable + exit ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit ;; + i*86:*:5:[678]*) + # UnixWare 7.x, OpenUNIX and OpenServer 6. + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i386. + echo i386-pc-msdosdjgpp + exit ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit ;; + M68*:*:R3V[5678]*:*) + test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4; exit; } ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit ;; + i*86:VOS:*:*) + # From Paul.Green@stratus.com. + echo ${UNAME_MACHINE}-stratus-vos + exit ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit ;; + SX-7:SUPER-UX:*:*) + echo sx7-nec-superux${UNAME_RELEASE} + exit ;; + SX-8:SUPER-UX:*:*) + echo sx8-nec-superux${UNAME_RELEASE} + exit ;; + SX-8R:SUPER-UX:*:*) + echo sx8r-nec-superux${UNAME_RELEASE} + exit ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Darwin:*:*) + UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown + case $UNAME_PROCESSOR in + unknown) UNAME_PROCESSOR=powerpc ;; + esac + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit ;; + NSE-?:NONSTOP_KERNEL:*:*) + echo nse-tandem-nsk${UNAME_RELEASE} + exit ;; + NSR-?:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit ;; + *:DragonFly:*:*) + echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` + exit ;; + *:*VMS:*:*) + UNAME_MACHINE=`(uname -p) 2>/dev/null` + case "${UNAME_MACHINE}" in + A*) echo alpha-dec-vms ; exit ;; + I*) echo ia64-dec-vms ; exit ;; + V*) echo vax-dec-vms ; exit ;; + esac ;; + *:XENIX:*:SysV) + echo i386-pc-xenix + exit ;; + i*86:skyos:*:*) + echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' + exit ;; + i*86:rdos:*:*) + echo ${UNAME_MACHINE}-pc-rdos + exit ;; +esac + +#echo '(No uname command or uname output not recognized.)' 1>&2 +#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 + +eval $set_cc_for_build +cat >$dummy.c < +# include +#endif +main () +{ +#if defined (sony) +#if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); +#else +#include + printf ("m68k-sony-newsos%s\n", +#ifdef NEWSOS4 + "4" +#else + "" +#endif + ); exit (0); +#endif +#endif + +#if defined (__arm) && defined (__acorn) && defined (__unix) + printf ("arm-acorn-riscix\n"); exit (0); +#endif + +#if defined (hp300) && !defined (hpux) + printf ("m68k-hp-bsd\n"); exit (0); +#endif + +#if defined (NeXT) +#if !defined (__ARCHITECTURE__) +#define __ARCHITECTURE__ "m68k" +#endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); +#endif + +#if defined (MULTIMAX) || defined (n16) +#if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); +#else +#if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); +#else + printf ("ns32k-encore-bsd\n"); exit (0); +#endif +#endif +#endif + +#if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); +#endif + +#if defined (sequent) +#if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); +#endif +#if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); +#endif +#endif + +#if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); + +#endif + +#if defined (vax) +# if !defined (ultrix) +# include +# if defined (BSD) +# if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); +# else +# if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# endif +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# else + printf ("vax-dec-ultrix\n"); exit (0); +# endif +#endif + +#if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); +#endif + + exit (1); +} +EOF + +$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + +# Apollos put the system type in the environment. + +test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } + +# Convex versions that predate uname can use getsysinfo(1) + +if [ -x /usr/convex/getsysinfo ] +then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + c34*) + echo c34-convex-bsd + exit ;; + c38*) + echo c38-convex-bsd + exit ;; + c4*) + echo c4-convex-bsd + exit ;; + esac +fi + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: --- gprolog-1.3.0.orig/src/configure.in +++ gprolog-1.3.0/src/configure.in @@ -47,6 +47,8 @@ AC_SUBST(PROLOG_NAME) AC_SUBST(PROLOG_VERSION) AC_SUBST(PROLOG_DATE) AC_SUBST(PROLOG_COPYRIGHT) +AC_SUBST(PROLOG_BINDIR) +AC_SUBST(PROLOG_LIBDIR) AC_SUBST(TOP_LEVEL) AC_SUBST(GPLC) @@ -197,6 +199,13 @@ if test "$USE_EBP" = no; then AC_DEFINE(NO_USE_EBP) fi +AC_ARG_ENABLE(watermark, [ --enable-watermark define choice-point deletion foreign destructors], + [case "$enableval" in + yes) AC_DEFINE(USE_WATERMARK) USE_WATERMARK=yes;; + *) USE_WATERMARK=no;; + esac]) + + # *********************** @@ -322,9 +331,11 @@ else case "$host" in mips*irix*) AC_DEFINE(M_mips_irix);; + mips*linux*) AC_DEFINE(M_mips_linux);; sparc*sunos*) AC_DEFINE(M_sparc_sunos);; sparc*solaris*) AC_DEFINE(M_sparc_solaris);; sparc*bsd*) AC_DEFINE(M_sparc_bsd);; + sparc*linux*) AC_DEFINE(M_sparc_linux);; alpha*osf*) AC_DEFINE(M_alpha_osf);; alpha*linux*) AC_DEFINE(M_alpha_linux);; x86_64*linux*) AC_DEFINE(M_x86_64_linux);; @@ -413,9 +424,9 @@ else mips*irix*) CFLAGS_MACHINE='-march=4000';; *sparc*sunos4.1.3) CFLAGS_MACHINE='-msupersparc';; *sparc*solaris) CFLAGS_MACHINE='-msupersparc';; - i686*) CFLAGS_MACHINE='-march=pentiumpro';; - i586*) CFLAGS_MACHINE='-march=pentium';; - i*86*) CFLAGS_MACHINE='-march=i486';; +dnl i686*) CFLAGS_MACHINE='-march=pentiumpro';; +dnl i586*) CFLAGS_MACHINE='-march=pentium';; + i*86) CFLAGS_MACHINE='-march=i486';; powerpc*darwin*) CFLAGS_MACHINE='-mpowerpc -no-cpp-precomp';; esac @@ -504,6 +515,8 @@ AC_DEFINE_UNQUOTED(PROLOG_NAME1, "$P AC_DEFINE_UNQUOTED(PROLOG_VERSION, "$PROLOG_VERSION") AC_DEFINE_UNQUOTED(PROLOG_DATE, "$PROLOG_DATE") AC_DEFINE_UNQUOTED(PROLOG_COPYRIGHT, "$PROLOG_COPYRIGHT") +AC_DEFINE_UNQUOTED(PROLOG_BINDIR, "$bindir") +AC_DEFINE_UNQUOTED(PROLOG_LIBDIR, "$libdir") AC_DEFINE_UNQUOTED(TOP_LEVEL, "$TOP_LEVEL") AC_DEFINE_UNQUOTED(GPLC, "$GPLC") @@ -660,7 +673,7 @@ echo "--> Examples: $EXAMPLES_ if test "$IN_PLACE" = no; then - TXT_FILES='COPYING VERSION NEWS ChangeLog' + TXT_FILES='VERSION NEWS ChangeLog' else TXT_FILES= fi @@ -671,6 +684,7 @@ LIB_FILES= INC_FILES="$PROLOG_NAME1.h fd_to_c.h" DOC_FILES='???*.dvi ???*.ps ???*.pdf ???*.chm ???*.eps ???*.html ???*.gif' +DOC_FILES='???*.pdf' HTML_FILES='???*.html ???*.gif ???*.css' EXPL_FILES='Makefile README PROGS ??*.pl' EXC_FILES='Makefile README ??*.pl ??*_c.c' --- gprolog-1.3.0.orig/src/Makefile.in +++ gprolog-1.3.0/src/Makefile.in @@ -5,6 +5,9 @@ ROOT_DIR = @ROOT_DIR@ PKG_NAME = @PKG_NAME@ INSTALL_DIR = $(DESTDIR)@INSTALL_DIR@ +INSTALL_BIN = $(INSTALL_DIR)/bin +INSTALL_LIB = $(INSTALL_DIR)/lib/@PROLOG_NAME1@ +INSTALL_INC = $(INSTALL_DIR)/include/@PROLOG_NAME1@ LINKS_DIR = $(DESTDIR)@LINKS_DIR@ DOC_DIR = $(DESTDIR)@DOC_DIR@ HTML_DIR = $(DESTDIR)@HTML_DIR@ @@ -55,24 +58,25 @@ install-strip: install: install-system install-doc install-html install-examples install-links install-system: - ./mkinstalldirs $(INSTALL_DIR) $(INSTALL_DIR)/bin \ - $(INSTALL_DIR)/include $(INSTALL_DIR)/lib - for i in $(TXT_FILES); do $(INSTALL_DATA) ../$$i $(INSTALL_DIR); done - for i in $(BIN_FILES); do $(INSTALL_PROGRAM) */$$i $(INSTALL_DIR)/bin; done - for i in $(OBJ_FILES); do $(INSTALL_DATA) */$$i $(INSTALL_DIR)/lib; done - for i in $(LIB_FILES); do $(INSTALL_DATA) */$$i $(INSTALL_DIR)/lib; done - for i in $(INC_FILES); do $(INSTALL_DATA) */$$i $(INSTALL_DIR)/include; done - for i in $(INSTALL_DIR)/lib/*.a; do $(RANLIB) $$i; done + ./mkinstalldirs $(INSTALL_DIR) $(INSTALL_BIN) \ + $(INSTALL_INC) $(INSTALL_LIB) + for i in $(TXT_FILES); do $(INSTALL_DATA) ../$$i $(INSTALL_LIB); done + for i in $(BIN_FILES); do $(INSTALL_PROGRAM) */$$i $(INSTALL_BIN); done + for i in $(OBJ_FILES); do $(INSTALL_DATA) */$$i $(INSTALL_LIB); done + for i in $(LIB_FILES); do $(INSTALL_DATA) */$$i $(INSTALL_LIB); done + for i in $(INC_FILES); do $(INSTALL_DATA) */$$i $(INSTALL_INC); done + for i in $(INSTALL_LIB)/*.a; do $(RANLIB) $$i; done uninstall: uninstall-links uninstall-html uninstall-doc uninstall-examples - for i in $(BIN_FILES); do rm -f $(INSTALL_DIR)/bin/$$i; done - rmdir -p $(INSTALL_DIR)/bin 2>/dev/null || exit 0 - for i in $(LIB_FILES) $(OBJ_FILES); do rm -f $(INSTALL_DIR)/lib/$$i; done - rmdir -p $(INSTALL_DIR)/lib 2>/dev/null || exit 0 - for i in $(INC_FILES); do rm -f $(INSTALL_DIR)/include/$$i; done - rmdir -p $(INSTALL_DIR)/include 2>/dev/null || exit 0 - for i in $(TXT_FILES); do rm -f $(INSTALL_DIR)/$$i; done + for i in $(BIN_FILES); do rm -f $(INSTALL_BIN)/$$i; done + rmdir -p $(INSTALL_BIN) 2>/dev/null || exit 0 + for i in $(LIB_FILES) $(OBJ_FILES); do rm -f $(INSTALL_LIB)/$$i; done + rmdir -p $(INSTALL_LIB) 2>/dev/null || exit 0 + for i in $(INC_FILES); do rm -f $(INSTALL_INC)/$$i; done + rmdir -p $(INSTALL_INC) 2>/dev/null || exit 0 + for i in $(TXT_FILES); do rm -f $(INSTALL_LIB)/$$i; done + rmdir -p $(INSTALL_LIB) 2>/dev/null || exit 0 rmdir $(INSTALL_DIR) 2>/dev/null || exit 0 @@ -81,7 +85,7 @@ uninstall: uninstall-links uninstall-htm install-links: uninstall-links if test $(LINKS_DIR) != none; then \ ./mkinstalldirs $(LINKS_DIR); \ - (cd $(LINKS_DIR) ; $(LN_S) $(INSTALL_DIR)/bin/* .); \ + (cd $(LINKS_DIR) ; $(LN_S) $(INSTALL_BIN)/* .); \ fi uninstall-links: --- /dev/null +++ gprolog-1.3.0/src/BipsFD/fd_math_fd.c @@ -0,0 +1,9069 @@ +/* C file generated for /Users/spa/work/maint/gprolog-1.3.0/src/BipsFD/fd_math_fd.fd */ + +#include "fd_to_c.h" + +/* line:27 begin included code */ + +#include "bips_fd.h" +#define ite(i,t,e) ((i) ? (t) : (e)) + +/* line:30 end included code */ + + /*-------------------------*/ + /* User constraint: x_eq_y */ + /*-------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minY,maxY,1) + fd_tell_interval(0,minY,maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_eq_y_bloc_1,0,1) + fd_add_dependency(1,min_max) + fd_call_internal(x_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minX,maxX,0) + fd_tell_interval(1,minX,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_eq_y_bloc_2,1,1) + fd_add_dependency(0,min_max) + fd_call_internal(x_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_eq_y */ + +fd_begin_user_constraint(x_eq_y(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x_eq_y_bloc_1_inst) + fd_call_internal(x_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------------*/ + /* User constraint: x_plus_c_eq_y */ + /*--------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_c_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(intC) + + fd_load_min_max(minY,maxY,2) + fd_load_int(intC,1) + fd_tell_interval(0,minY-intC,maxY-intC) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_eq_y_bloc_1,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(x_plus_c_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_c_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intC) + + fd_load_min_max(minX,maxX,0) + fd_load_int(intC,1) + fd_tell_interval(2,minX+intC,maxX+intC) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_eq_y_bloc_2,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(x_plus_c_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_c_eq_y */ + +fd_begin_user_constraint(x_plus_c_eq_y(FdArg(X),FdArg(C),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_plus_c_eq_y_bloc_1_inst) + fd_call_internal(x_plus_c_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------*/ + /* User constraint: x_eq_y_F */ + /*---------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_eq_y_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,1) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_eq_y_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_eq_y_F_bloc_1,0,1) + fd_add_dependency(1,dom) + fd_call_internal(x_eq_y_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_eq_y_F_bloc_2) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,0) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_eq_y_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_eq_y_F_bloc_2,1,1) + fd_add_dependency(0,dom) + fd_call_internal(x_eq_y_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_eq_y_F */ + +fd_begin_user_constraint(x_eq_y_F(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x_eq_y_F_bloc_1_inst) + fd_call_internal(x_eq_y_F_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------*/ + /* User constraint: x_plus_c_eq_y_F */ + /*----------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_c_eq_y_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intC) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,2) + fd_load_int(intC,1) + fd_range_copy(0,1) + fd_range_sub_value(0,intC) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_eq_y_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_eq_y_F_bloc_1,0,1) + fd_add_dependency(2,dom) + fd_call_internal(x_plus_c_eq_y_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_c_eq_y_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intC) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,0) + fd_load_int(intC,1) + fd_range_copy(0,1) + fd_range_add_value(0,intC) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_eq_y_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_eq_y_F_bloc_2,2,1) + fd_add_dependency(0,dom) + fd_call_internal(x_plus_c_eq_y_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_c_eq_y_F */ + +fd_begin_user_constraint(x_plus_c_eq_y_F(FdArg(X),FdArg(C),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_plus_c_eq_y_F_bloc_1_inst) + fd_call_internal(x_plus_c_eq_y_F_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: x_neq_c */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_neq_c_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intC) + + fd_load_int(intC,1) + fd_tell_not_value(0,intC) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_neq_c */ + +fd_begin_user_constraint(x_neq_c(FdArg(X),FdArg(C))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + + fd_before_add_constraint + fd_call_internal(x_neq_c_bloc_1) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: x_neq_y */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_neq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(valY) + + fd_load_val(valY,1) + fd_tell_not_value(0,valY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_neq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_neq_y_bloc_1,0,1) + fd_add_dependency(1,val) + fd_call_internal(x_neq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_neq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(valX) + + fd_load_val(valX,0) + fd_tell_not_value(1,valX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_neq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_neq_y_bloc_2,1,1) + fd_add_dependency(0,val) + fd_call_internal(x_neq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_neq_y */ + +fd_begin_user_constraint(x_neq_y(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x_neq_y_bloc_1_inst) + fd_call_internal(x_neq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: x_plus_c_neq_y */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_c_neq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(valY) + fd_local_value_var(intC) + + fd_load_val(valY,2) + fd_load_int(intC,1) + fd_tell_not_value(0,valY-intC) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_neq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_neq_y_bloc_1,0,1) + fd_add_dependency(2,val) + fd_call_internal(x_plus_c_neq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_c_neq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(valX) + fd_local_value_var(intC) + + fd_load_val(valX,0) + fd_load_int(intC,1) + fd_tell_not_value(2,valX+intC) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_neq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_neq_y_bloc_2,2,1) + fd_add_dependency(0,val) + fd_call_internal(x_plus_c_neq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_c_neq_y */ + +fd_begin_user_constraint(x_plus_c_neq_y(FdArg(X),FdArg(C),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_plus_c_neq_y_bloc_1_inst) + fd_call_internal(x_plus_c_neq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-------------------------*/ + /* User constraint: x_lt_y */ + /*-------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_lt_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(0,0,maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_lt_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_lt_y_bloc_1,0,1) + fd_add_dependency(1,max) + fd_call_internal(x_lt_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_lt_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + + fd_load_min(minX,0) + fd_tell_interval(1,minX+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_lt_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_lt_y_bloc_2,1,1) + fd_add_dependency(0,min) + fd_call_internal(x_lt_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_lt_y */ + +fd_begin_user_constraint(x_lt_y(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x_lt_y_bloc_1_inst) + fd_call_internal(x_lt_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: x_lte_c */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_lte_c_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intC) + + fd_load_int(intC,1) + fd_tell_interval(0,0,intC) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_lte_c */ + +fd_begin_user_constraint(x_lte_c(FdArg(X),FdArg(C))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + + fd_before_add_constraint + fd_call_internal(x_lte_c_bloc_1) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: x_lte_y */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_lte_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(0,0,maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_lte_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_lte_y_bloc_1,0,1) + fd_add_dependency(1,max) + fd_call_internal(x_lte_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_lte_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + + fd_load_min(minX,0) + fd_tell_interval(1,minX,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_lte_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_lte_y_bloc_2,1,1) + fd_add_dependency(0,min) + fd_call_internal(x_lte_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_lte_y */ + +fd_begin_user_constraint(x_lte_y(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x_lte_y_bloc_1_inst) + fd_call_internal(x_lte_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: x_plus_c_lte_y */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_c_lte_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(maxY) + fd_local_value_var(intC) + + fd_load_max(maxY,2) + fd_load_int(intC,1) + fd_tell_interval(0,0,maxY-intC) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_lte_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_lte_y_bloc_1,0,1) + fd_add_dependency(2,max) + fd_call_internal(x_plus_c_lte_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_c_lte_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(intC) + + fd_load_min(minX,0) + fd_load_int(intC,1) + fd_tell_interval(2,minX+intC,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_lte_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_lte_y_bloc_2,2,1) + fd_add_dependency(0,min) + fd_call_internal(x_plus_c_lte_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_c_lte_y */ + +fd_begin_user_constraint(x_plus_c_lte_y(FdArg(X),FdArg(C),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_plus_c_lte_y_bloc_1_inst) + fd_call_internal(x_plus_c_lte_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: x_gte_c */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_gte_c_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intC) + + fd_load_int(intC,1) + fd_tell_interval(0,intC,max_integer) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_gte_c */ + +fd_begin_user_constraint(x_gte_c(FdArg(X),FdArg(C))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + + fd_before_add_constraint + fd_call_internal(x_gte_c_bloc_1) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: x_plus_c_gte_y */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_c_gte_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(intC) + + fd_load_min(minY,2) + fd_load_int(intC,1) + fd_tell_interval(0,minY-intC,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_gte_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_gte_y_bloc_1,0,1) + fd_add_dependency(2,min) + fd_call_internal(x_plus_c_gte_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_c_gte_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxX) + fd_local_value_var(intC) + + fd_load_max(maxX,0) + fd_load_int(intC,1) + fd_tell_interval(2,0,maxX+intC) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_c_gte_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_c_gte_y_bloc_2,2,1) + fd_add_dependency(0,max) + fd_call_internal(x_plus_c_gte_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_c_gte_y */ + +fd_begin_user_constraint(x_plus_c_gte_y(FdArg(X),FdArg(C),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(C,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_plus_c_gte_y_bloc_1_inst) + fd_call_internal(x_plus_c_gte_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: ax_eq_y */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(intA) + + fd_load_min_max(minY,maxY,2) + fd_load_int(intA,0) + fd_tell_interval(1,DivUp(minY,intA),DivDn(maxY,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_eq_y_bloc_1,1,1) + fd_add_dependency(2,min_max) + fd_call_internal(ax_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_tell_interval(2,intA*minX,intA*maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_eq_y_bloc_2,2,1) + fd_add_dependency(1,min_max) + fd_call_internal(ax_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_eq_y */ + +fd_begin_user_constraint(ax_eq_y(FdArg(A),FdArg(X),FdArg(Y))) + + fd_create_a_frame(3) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(ax_eq_y_bloc_1_inst) + fd_call_internal(ax_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------------*/ + /* User constraint: x_plus_y_eq_z */ + /*--------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_y_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minZ,maxZ,2) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(0,minZ-maxY,maxZ-minY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_eq_z_bloc_1,0,1) + fd_add_dependency(2,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(x_plus_y_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_y_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minZ,maxZ,2) + fd_load_min_max(minX,maxX,0) + fd_tell_interval(1,minZ-maxX,maxZ-minX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_eq_z_bloc_2,1,1) + fd_add_dependency(2,min_max) + fd_add_dependency(0,min_max) + fd_call_internal(x_plus_y_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(x_plus_y_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,minX+minY,maxX+maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_eq_z_bloc_3,2,1) + fd_add_dependency(0,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(x_plus_y_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_y_eq_z */ + +fd_begin_user_constraint(x_plus_y_eq_z(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(x_plus_y_eq_z_bloc_1_inst) + fd_call_internal(x_plus_y_eq_z_bloc_2_inst) + fd_call_internal(x_plus_y_eq_z_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: ax_plus_y_eq_z */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_y_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(intA) + + fd_load_min_max(minZ,maxZ,3) + fd_load_min_max(minY,maxY,2) + fd_load_int(intA,0) + fd_tell_interval(1,DivUp(minZ-maxY,intA),DivDn(maxZ-minY,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_eq_z_bloc_1,1,1) + fd_add_dependency(3,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(ax_plus_y_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_y_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minZ,maxZ,3) + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_tell_interval(2,minZ-intA*maxX,maxZ-intA*minX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_eq_z_bloc_2,2,1) + fd_add_dependency(3,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(ax_plus_y_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_y_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_min_max(minY,maxY,2) + fd_tell_interval(3,intA*minX+minY,intA*maxX+maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_eq_z_bloc_3,3,1) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(ax_plus_y_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_y_eq_z */ + +fd_begin_user_constraint(ax_plus_y_eq_z(FdArg(A),FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(4) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_fdv_in_a_frame(Y,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(ax_plus_y_eq_z_bloc_1_inst) + fd_call_internal(ax_plus_y_eq_z_bloc_2_inst) + fd_call_internal(ax_plus_y_eq_z_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------*/ + /* User constraint: ax_plus_by_eq_z */ + /*----------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_by_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intB) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(intA) + + fd_load_min_max(minZ,maxZ,4) + fd_load_int(intB,2) + fd_load_min_max(minY,maxY,3) + fd_load_int(intA,0) + fd_tell_interval(1,DivUp(minZ-intB*maxY,intA),DivDn(maxZ-intB*minY,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_eq_z_bloc_1,1,1) + fd_add_dependency(4,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(ax_plus_by_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_by_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intB) + + fd_load_min_max(minZ,maxZ,4) + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_int(intB,2) + fd_tell_interval(3,DivUp(minZ-intA*maxX,intB),DivDn(maxZ-intA*minX,intB)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_eq_z_bloc_2,3,1) + fd_add_dependency(4,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(ax_plus_by_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_by_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intB) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_int(intB,2) + fd_load_min_max(minY,maxY,3) + fd_tell_interval(4,intA*minX+intB*minY,intA*maxX+intB*maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_eq_z_bloc_3,4,1) + fd_add_dependency(1,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(ax_plus_by_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_by_eq_z */ + +fd_begin_user_constraint(ax_plus_by_eq_z(FdArg(A),FdArg(X),FdArg(B),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(5) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_int_in_a_frame(B,2) + fd_fdv_in_a_frame(Y,3) + fd_fdv_in_a_frame(Z,4) + + fd_before_add_constraint + fd_call_internal(ax_plus_by_eq_z_bloc_1_inst) + fd_call_internal(ax_plus_by_eq_z_bloc_2_inst) + fd_call_internal(ax_plus_by_eq_z_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------------*/ + /* User constraint: x_plus_y_plus_z_eq_t */ + /*---------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minT,maxT,3) + fd_load_min_max(minY,maxY,1) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,minT-maxY-maxZ,maxT-minY-minZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_bloc_1,0,1) + fd_add_dependency(3,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minT,maxT,3) + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(1,minT-maxX-maxZ,maxT-minX-minZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_bloc_2,1,1) + fd_add_dependency(3,min_max) + fd_add_dependency(0,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minT,maxT,3) + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,minT-maxX-maxY,maxT-minX-minY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_bloc_3,2,1) + fd_add_dependency(3,min_max) + fd_add_dependency(0,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minY,maxY,1) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(3,minX+minY+minZ,maxX+maxY+maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_bloc_4,3,1) + fd_add_dependency(0,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_y_plus_z_eq_t */ + +fd_begin_user_constraint(x_plus_y_plus_z_eq_t(FdArg(X),FdArg(Y),FdArg(Z),FdArg(T))) + + fd_create_a_frame(4) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + fd_fdv_in_a_frame(T,3) + + fd_before_add_constraint + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_1_inst) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_2_inst) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_3_inst) + fd_call_internal(x_plus_y_plus_z_eq_t_bloc_4_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------------*/ + /* User constraint: ax_plus_y_plus_z_eq_t */ + /*----------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intA) + + fd_load_min_max(minT,maxT,4) + fd_load_min_max(minY,maxY,2) + fd_load_min_max(minZ,maxZ,3) + fd_load_int(intA,0) + fd_tell_interval(1,DivUp(minT-maxY-maxZ,intA),DivDn(maxT-minY-minZ,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_bloc_1,1,1) + fd_add_dependency(4,min_max) + fd_add_dependency(2,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minT,maxT,4) + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_min_max(minZ,maxZ,3) + fd_tell_interval(2,minT-intA*maxX-maxZ,maxT-intA*minX-minZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_bloc_2,2,1) + fd_add_dependency(4,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minT,maxT,4) + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_min_max(minY,maxY,2) + fd_tell_interval(3,minT-intA*maxX-maxY,maxT-intA*minX-minY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_bloc_3,3,1) + fd_add_dependency(4,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_min_max(minY,maxY,2) + fd_load_min_max(minZ,maxZ,3) + fd_tell_interval(4,intA*minX+minY+minZ,intA*maxX+maxY+maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_bloc_4,4,1) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_y_plus_z_eq_t */ + +fd_begin_user_constraint(ax_plus_y_plus_z_eq_t(FdArg(A),FdArg(X),FdArg(Y),FdArg(Z),FdArg(T))) + + fd_create_a_frame(5) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_fdv_in_a_frame(Y,2) + fd_fdv_in_a_frame(Z,3) + fd_fdv_in_a_frame(T,4) + + fd_before_add_constraint + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_1_inst) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_2_inst) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_3_inst) + fd_call_internal(ax_plus_y_plus_z_eq_t_bloc_4_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-----------------------------------------*/ + /* User constraint: ax_plus_by_plus_z_eq_t */ + /*-----------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(intB) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intA) + + fd_load_min_max(minT,maxT,5) + fd_load_int(intB,2) + fd_load_min_max(minY,maxY,3) + fd_load_min_max(minZ,maxZ,4) + fd_load_int(intA,0) + fd_tell_interval(1,DivUp(minT-intB*maxY-maxZ,intA),DivDn(maxT-intB*minY-minZ,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_bloc_1,1,1) + fd_add_dependency(5,min_max) + fd_add_dependency(3,min_max) + fd_add_dependency(4,min_max) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intB) + + fd_load_min_max(minT,maxT,5) + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_min_max(minZ,maxZ,4) + fd_load_int(intB,2) + fd_tell_interval(3,DivUp(minT-intA*maxX-maxZ,intB),DivDn(maxT-intA*minX-minZ,intB)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_bloc_2,3,1) + fd_add_dependency(5,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(4,min_max) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minT) + fd_local_value_var(maxT) + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intB) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minT,maxT,5) + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_int(intB,2) + fd_load_min_max(minY,maxY,3) + fd_tell_interval(4,minT-intA*maxX-intB*maxY,maxT-intA*minX-intB*minY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_bloc_3,4,1) + fd_add_dependency(5,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intB) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_int(intA,0) + fd_load_min_max(minX,maxX,1) + fd_load_int(intB,2) + fd_load_min_max(minY,maxY,3) + fd_load_min_max(minZ,maxZ,4) + fd_tell_interval(5,intA*minX+intB*minY+minZ,intA*maxX+intB*maxY+maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_bloc_4,5,1) + fd_add_dependency(1,min_max) + fd_add_dependency(3,min_max) + fd_add_dependency(4,min_max) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_by_plus_z_eq_t */ + +fd_begin_user_constraint(ax_plus_by_plus_z_eq_t(FdArg(A),FdArg(X),FdArg(B),FdArg(Y),FdArg(Z),FdArg(T))) + + fd_create_a_frame(6) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_int_in_a_frame(B,2) + fd_fdv_in_a_frame(Y,3) + fd_fdv_in_a_frame(Z,4) + fd_fdv_in_a_frame(T,5) + + fd_before_add_constraint + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_1_inst) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_2_inst) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_3_inst) + fd_call_internal(ax_plus_by_plus_z_eq_t_bloc_4_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------*/ + /* User constraint: ax_eq_y_F */ + /*----------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_eq_y_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,2) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_div_value(0,intA) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_eq_y_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_eq_y_F_bloc_1,1,1) + fd_add_dependency(2,dom) + fd_call_internal(ax_eq_y_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_eq_y_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,1) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_mul_value(0,intA) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_eq_y_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_eq_y_F_bloc_2,2,1) + fd_add_dependency(1,dom) + fd_call_internal(ax_eq_y_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_eq_y_F */ + +fd_begin_user_constraint(ax_eq_y_F(FdArg(A),FdArg(X),FdArg(Y))) + + fd_create_a_frame(3) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(ax_eq_y_F_bloc_1_inst) + fd_call_internal(ax_eq_y_F_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------*/ + /* User constraint: x_plus_y_eq_z_F */ + /*----------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_y_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,2) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_eq_z_F_bloc_1,0,1) + fd_add_dependency(2,dom) + fd_add_dependency(1,dom) + fd_call_internal(x_plus_y_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_y_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,2) + fd_load_dom(2,0) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_eq_z_F_bloc_2,1,1) + fd_add_dependency(2,dom) + fd_add_dependency(0,dom) + fd_call_internal(x_plus_y_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(x_plus_y_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_eq_z_F_bloc_3,2,1) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_call_internal(x_plus_y_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_y_eq_z_F */ + +fd_begin_user_constraint(x_plus_y_eq_z_F(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(x_plus_y_eq_z_F_bloc_1_inst) + fd_call_internal(x_plus_y_eq_z_F_bloc_2_inst) + fd_call_internal(x_plus_y_eq_z_F_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-----------------------------------*/ + /* User constraint: ax_plus_y_eq_z_F */ + /*-----------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_y_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,3) + fd_load_dom(2,2) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_range_div_value(0,intA) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_eq_z_F_bloc_1,1,1) + fd_add_dependency(3,dom) + fd_add_dependency(2,dom) + fd_call_internal(ax_plus_y_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_y_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,3) + fd_load_dom(2,1) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_eq_z_F_bloc_2,2,1) + fd_add_dependency(3,dom) + fd_add_dependency(1,dom) + fd_call_internal(ax_plus_y_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_y_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,1) + fd_load_int(intA,0) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_mul_value(0,intA) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_eq_z_F_bloc_3,3,1) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(ax_plus_y_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_y_eq_z_F */ + +fd_begin_user_constraint(ax_plus_y_eq_z_F(FdArg(A),FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(4) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_fdv_in_a_frame(Y,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(ax_plus_y_eq_z_F_bloc_1_inst) + fd_call_internal(ax_plus_y_eq_z_F_bloc_2_inst) + fd_call_internal(ax_plus_y_eq_z_F_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*------------------------------------*/ + /* User constraint: ax_plus_by_eq_z_F */ + /*------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_by_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intB) + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,4) + fd_load_dom(2,3) + fd_load_int(intB,2) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_mul_value(1,intB) + fd_range_sub_range(0,1) + fd_range_div_value(0,intA) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_eq_z_F_bloc_1,1,1) + fd_add_dependency(4,dom) + fd_add_dependency(3,dom) + fd_call_internal(ax_plus_by_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_by_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(intB) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,4) + fd_load_dom(2,1) + fd_load_int(intA,0) + fd_load_int(intB,2) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_range_div_value(0,intB) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_eq_z_F_bloc_2,3,1) + fd_add_dependency(4,dom) + fd_add_dependency(1,dom) + fd_call_internal(ax_plus_by_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_by_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(intB) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,1) + fd_load_int(intA,0) + fd_load_dom(2,3) + fd_load_int(intB,2) + fd_range_copy(0,1) + fd_range_mul_value(0,intA) + fd_range_copy(1,2) + fd_range_mul_value(1,intB) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(4,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_eq_z_F_bloc_3,4,1) + fd_add_dependency(1,dom) + fd_add_dependency(3,dom) + fd_call_internal(ax_plus_by_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_by_eq_z_F */ + +fd_begin_user_constraint(ax_plus_by_eq_z_F(FdArg(A),FdArg(X),FdArg(B),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(5) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_int_in_a_frame(B,2) + fd_fdv_in_a_frame(Y,3) + fd_fdv_in_a_frame(Z,4) + + fd_before_add_constraint + fd_call_internal(ax_plus_by_eq_z_F_bloc_1_inst) + fd_call_internal(ax_plus_by_eq_z_F_bloc_2_inst) + fd_call_internal(ax_plus_by_eq_z_F_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-----------------------------------------*/ + /* User constraint: x_plus_y_plus_z_eq_t_F */ + /*-----------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,3) + fd_load_dom(3,1) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_F_bloc_1,0,1) + fd_add_dependency(3,dom) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_2) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,3) + fd_load_dom(3,0) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_F_bloc_2,1,1) + fd_add_dependency(3,dom) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_3) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,3) + fd_load_dom(3,0) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_F_bloc_3,2,1) + fd_add_dependency(3,dom) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_4) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(3,1) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_add_range(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_plus_y_plus_z_eq_t_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_plus_y_plus_z_eq_t_F_bloc_4,3,1) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_plus_y_plus_z_eq_t_F */ + +fd_begin_user_constraint(x_plus_y_plus_z_eq_t_F(FdArg(X),FdArg(Y),FdArg(Z),FdArg(T))) + + fd_create_a_frame(4) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + fd_fdv_in_a_frame(T,3) + + fd_before_add_constraint + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_1_inst) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_2_inst) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_3_inst) + fd_call_internal(x_plus_y_plus_z_eq_t_F_bloc_4_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*------------------------------------------*/ + /* User constraint: ax_plus_y_plus_z_eq_t_F */ + /*------------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,4) + fd_load_dom(3,2) + fd_load_dom(2,3) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_range_div_value(0,intA) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_F_bloc_1,1,1) + fd_add_dependency(4,dom) + fd_add_dependency(2,dom) + fd_add_dependency(3,dom) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,4) + fd_load_dom(3,1) + fd_load_int(intA,0) + fd_load_dom(2,3) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_F_bloc_2,2,1) + fd_add_dependency(4,dom) + fd_add_dependency(1,dom) + fd_add_dependency(3,dom) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,4) + fd_load_dom(3,1) + fd_load_int(intA,0) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_F_bloc_3,3,1) + fd_add_dependency(4,dom) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,1) + fd_load_int(intA,0) + fd_load_dom(3,2) + fd_load_dom(2,3) + fd_range_copy(0,1) + fd_range_mul_value(0,intA) + fd_range_copy(1,3) + fd_range_add_range(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(4,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_y_plus_z_eq_t_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_y_plus_z_eq_t_F_bloc_4,4,1) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_add_dependency(3,dom) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_y_plus_z_eq_t_F */ + +fd_begin_user_constraint(ax_plus_y_plus_z_eq_t_F(FdArg(A),FdArg(X),FdArg(Y),FdArg(Z),FdArg(T))) + + fd_create_a_frame(5) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_fdv_in_a_frame(Y,2) + fd_fdv_in_a_frame(Z,3) + fd_fdv_in_a_frame(T,4) + + fd_before_add_constraint + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_1_inst) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_2_inst) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_3_inst) + fd_call_internal(ax_plus_y_plus_z_eq_t_F_bloc_4_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-------------------------------------------*/ + /* User constraint: ax_plus_by_plus_z_eq_t_F */ + /*-------------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intB) + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,5) + fd_load_dom(3,3) + fd_load_int(intB,2) + fd_load_dom(2,4) + fd_load_int(intA,0) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_mul_value(1,intB) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_range_div_value(0,intA) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_F_bloc_1,1,1) + fd_add_dependency(5,dom) + fd_add_dependency(3,dom) + fd_add_dependency(4,dom) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(intB) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,5) + fd_load_dom(3,1) + fd_load_int(intA,0) + fd_load_dom(2,4) + fd_load_int(intB,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_range_div_value(0,intB) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_F_bloc_2,3,1) + fd_add_dependency(5,dom) + fd_add_dependency(1,dom) + fd_add_dependency(4,dom) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(intB) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,5) + fd_load_dom(3,1) + fd_load_int(intA,0) + fd_load_dom(2,3) + fd_load_int(intB,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_mul_value(1,intB) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(4,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_F_bloc_3,4,1) + fd_add_dependency(5,dom) + fd_add_dependency(1,dom) + fd_add_dependency(3,dom) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(intB) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,1) + fd_load_int(intA,0) + fd_load_dom(3,3) + fd_load_int(intB,2) + fd_load_dom(2,4) + fd_range_copy(0,1) + fd_range_mul_value(0,intA) + fd_range_copy(1,3) + fd_range_mul_value(1,intB) + fd_range_add_range(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(5,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(ax_plus_by_plus_z_eq_t_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(ax_plus_by_plus_z_eq_t_F_bloc_4,5,1) + fd_add_dependency(1,dom) + fd_add_dependency(3,dom) + fd_add_dependency(4,dom) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for ax_plus_by_plus_z_eq_t_F */ + +fd_begin_user_constraint(ax_plus_by_plus_z_eq_t_F(FdArg(A),FdArg(X),FdArg(B),FdArg(Y),FdArg(Z),FdArg(T))) + + fd_create_a_frame(6) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(X,1) + fd_int_in_a_frame(B,2) + fd_fdv_in_a_frame(Y,3) + fd_fdv_in_a_frame(Z,4) + fd_fdv_in_a_frame(T,5) + + fd_before_add_constraint + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_1_inst) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_2_inst) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_3_inst) + fd_call_internal(ax_plus_by_plus_z_eq_t_F_bloc_4_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*------------------------------------*/ + /* User constraint: zero_power_n_eq_y */ + /*------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(zero_power_n_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minN) + fd_local_value_var(maxN) + + fd_load_min_max(minN,maxN,0) + fd_tell_interval(1,ite(maxN==0,1,0),ite(minN==0,1,0)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(zero_power_n_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(zero_power_n_eq_y_bloc_1,1,1) + fd_add_dependency(0,min_max) + fd_call_internal(zero_power_n_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(zero_power_n_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minY,maxY,1) + fd_tell_interval(0,ite(maxY==0,1,0),ite(minY==0,max_integer,0)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(zero_power_n_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(zero_power_n_eq_y_bloc_2,0,1) + fd_add_dependency(1,min_max) + fd_call_internal(zero_power_n_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for zero_power_n_eq_y */ + +fd_begin_user_constraint(zero_power_n_eq_y(FdArg(N),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(N,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(zero_power_n_eq_y_bloc_1_inst) + fd_call_internal(zero_power_n_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: a_power_n_eq_y */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(a_power_n_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minN) + fd_local_value_var(maxN) + + fd_load_int(intA,0) + fd_load_min_max(minN,maxN,1) + fd_tell_interval(2,Power(intA,minN),Power(intA,maxN)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(a_power_n_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(a_power_n_eq_y_bloc_1,2,1) + fd_add_dependency(1,min_max) + fd_call_internal(a_power_n_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(a_power_n_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_int(intA,0) + fd_load_min_max(minY,maxY,2) + fd_tell_interval(1,Find_Expon_Up(intA,minY),Find_Expon_Dn(intA,maxY)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(a_power_n_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(a_power_n_eq_y_bloc_2,1,1) + fd_add_dependency(2,min_max) + fd_call_internal(a_power_n_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for a_power_n_eq_y */ + +fd_begin_user_constraint(a_power_n_eq_y(FdArg(A),FdArg(N),FdArg(Y))) + + fd_create_a_frame(3) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(N,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(a_power_n_eq_y_bloc_1_inst) + fd_call_internal(a_power_n_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: x_power_a_eq_y */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_power_a_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intA) + + fd_load_min_max(minX,maxX,0) + fd_load_int(intA,1) + fd_tell_interval(2,Power(minX,intA),Power(maxX,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_power_a_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_power_a_eq_y_bloc_1,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(x_power_a_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_power_a_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(intA) + + fd_load_min_max(minY,maxY,2) + fd_load_int(intA,1) + fd_tell_interval(0,Nth_Root_Up(minY,intA),Nth_Root_Dn(maxY,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_power_a_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_power_a_eq_y_bloc_2,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(x_power_a_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_power_a_eq_y */ + +fd_begin_user_constraint(x_power_a_eq_y(FdArg(X),FdArg(A),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_power_a_eq_y_bloc_1_inst) + fd_call_internal(x_power_a_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: x2_eq_y */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x2_eq_y_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minY,maxY,1) + fd_tell_interval(0,Sqrt_Up(minY),Sqrt_Dn(maxY)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x2_eq_y_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x2_eq_y_bloc_1,0,1) + fd_add_dependency(1,min_max) + fd_call_internal(x2_eq_y_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x2_eq_y_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minX,maxX,0) + fd_tell_interval(1,minX*minX,maxX*maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x2_eq_y_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x2_eq_y_bloc_2,1,1) + fd_add_dependency(0,min_max) + fd_call_internal(x2_eq_y_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x2_eq_y */ + +fd_begin_user_constraint(x2_eq_y(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x2_eq_y_bloc_1_inst) + fd_call_internal(x2_eq_y_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------*/ + /* User constraint: xy_eq_z */ + /*--------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(xy_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minY,maxY,1) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,ite(maxY==0,0,DivUp(minZ,maxY)),ite(minY==0,max_integer,DivDn(maxZ,minY))) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_bloc_1,0,1) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(xy_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(xy_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(1,ite(maxX==0,0,DivUp(minZ,maxX)),ite(minX==0,max_integer,DivDn(maxZ,minX))) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_bloc_2,1,1) + fd_add_dependency(0,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(xy_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(xy_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,minX*minY,maxX*maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_bloc_3,2,1) + fd_add_dependency(0,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(xy_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for xy_eq_z */ + +fd_begin_user_constraint(xy_eq_z(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(xy_eq_z_bloc_1_inst) + fd_call_internal(xy_eq_z_bloc_2_inst) + fd_call_internal(xy_eq_z_bloc_3_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-----------------------------------*/ + /* User constraint: a_power_n_eq_y_F */ + /*-----------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(a_power_n_eq_y_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_int(intA,0) + fd_load_dom(0,1) + fd_range_copy(1,0) + fd_range_fct(Full_Coeff_Power_Var,0,arg_2(intA,range_arg(1))) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(a_power_n_eq_y_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(a_power_n_eq_y_F_bloc_1,2,1) + fd_add_dependency(1,dom) + fd_call_internal(a_power_n_eq_y_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(a_power_n_eq_y_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_int(intA,0) + fd_load_dom(0,2) + fd_range_copy(1,0) + fd_range_fct(Full_Find_Expon,0,arg_2(intA,range_arg(1))) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(a_power_n_eq_y_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(a_power_n_eq_y_F_bloc_2,1,1) + fd_add_dependency(2,dom) + fd_call_internal(a_power_n_eq_y_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for a_power_n_eq_y_F */ + +fd_begin_user_constraint(a_power_n_eq_y_F(FdArg(A),FdArg(N),FdArg(Y))) + + fd_create_a_frame(3) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(N,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(a_power_n_eq_y_F_bloc_1_inst) + fd_call_internal(a_power_n_eq_y_F_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-----------------------------------*/ + /* User constraint: x_power_a_eq_y_F */ + /*-----------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x_power_a_eq_y_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(0,0) + fd_load_int(intA,1) + fd_range_copy(1,0) + fd_range_fct(Full_Var_Power_Coeff,0,arg_2(range_arg(1),intA)) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_power_a_eq_y_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_power_a_eq_y_F_bloc_1,2,1) + fd_add_dependency(0,dom) + fd_call_internal(x_power_a_eq_y_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x_power_a_eq_y_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(0,2) + fd_load_int(intA,1) + fd_range_copy(1,0) + fd_range_fct(Full_Nth_Root,0,arg_2(range_arg(1),intA)) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x_power_a_eq_y_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x_power_a_eq_y_F_bloc_2,0,1) + fd_add_dependency(2,dom) + fd_call_internal(x_power_a_eq_y_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x_power_a_eq_y_F */ + +fd_begin_user_constraint(x_power_a_eq_y_F(FdArg(X),FdArg(A),FdArg(Y))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(Y,2) + + fd_before_add_constraint + fd_call_internal(x_power_a_eq_y_F_bloc_1_inst) + fd_call_internal(x_power_a_eq_y_F_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------*/ + /* User constraint: x2_eq_y_F */ + /*----------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(x2_eq_y_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(0,0) + fd_range_copy(1,0) + fd_range_fct(Full_Var_Power_2,0,arg_1(range_arg(1))) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x2_eq_y_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(x2_eq_y_F_bloc_1,1,1) + fd_add_dependency(0,dom) + fd_call_internal(x2_eq_y_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(x2_eq_y_F_bloc_2) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(0,1) + fd_range_copy(1,0) + fd_range_fct(Full_Sqrt_Var,0,arg_1(range_arg(1))) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(x2_eq_y_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(x2_eq_y_F_bloc_2,0,1) + fd_add_dependency(1,dom) + fd_call_internal(x2_eq_y_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for x2_eq_y_F */ + +fd_begin_user_constraint(x2_eq_y_F(FdArg(X),FdArg(Y))) + + fd_create_a_frame(2) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + + fd_before_add_constraint + fd_call_internal(x2_eq_y_F_bloc_1_inst) + fd_call_internal(x2_eq_y_F_bloc_2_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------*/ + /* User constraint: xy_eq_z_F */ + /*----------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(xy_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_mul_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_F_bloc_1,2,1) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_call_internal(xy_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(xy_eq_z_F_bloc_2) + + fd_local_fdv_adr + + fd_tell_interval(1,1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(xy_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,2) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_div_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_F_bloc_3,0,1) + fd_add_dependency(2,dom) + fd_add_dependency(1,dom) + fd_call_internal(xy_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(xy_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,2) + fd_load_dom(2,0) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_div_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_F_bloc_4,1,1) + fd_add_dependency(2,dom) + fd_add_dependency(0,dom) + fd_call_internal(xy_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(xy_eq_z_F_case_group_1) + + fd_call_internal(xy_eq_z_F_bloc_2) + fd_call_internal(xy_eq_z_F_bloc_3_inst) + fd_call_internal(xy_eq_z_F_bloc_4_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(xy_eq_z_F_bloc_5) + + fd_local_fdv_adr + + fd_tell_value(0,0) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(xy_eq_z_F_bloc_6) + + fd_local_fdv_adr + + fd_tell_value(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minY) + fd_local_value_var(minX) + + fd_load_min_max(minZ,maxZ,2) + fd_load_min(minY,1) + fd_load_min(minX,0) + fd_test_switch_condition(minZ>0,xy_eq_z_F_case_group_1) + fd_test_switch_condition(maxZ==0&&minY>0,xy_eq_z_F_bloc_5) + fd_test_switch_condition(maxZ==0&&minX>0,xy_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(xy_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(xy_eq_z_F_switch_1,-1,0) + fd_add_dependency(2,min_max) + fd_add_dependency(1,min) + fd_add_dependency(0,min) + fd_call_internal_and_test_switch(xy_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for xy_eq_z_F */ + +fd_begin_user_constraint(xy_eq_z_F(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(3) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(xy_eq_z_F_bloc_1_inst) + fd_call_internal_and_test_switch_simple(xy_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-------------------------------*/ + /* User constraint: min_x_y_eq_z */ + /*-------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(min_x_y_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(minY) + + fd_load_min(minX,0) + fd_load_min(minY,1) + fd_tell_interval(2,math_min(minX,minY),max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_1,2,1) + fd_cf_in_a_frame(3) + fd_add_dependency(0,min) + fd_add_dependency(1,min) + fd_call_internal(min_x_y_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(min_x_y_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxX) + + fd_load_max(maxX,0) + fd_tell_interval(2,0,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,max) + fd_call_internal(min_x_y_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(min_x_y_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,2) + fd_tell_interval(0,minZ,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_3,0,1) + fd_cf_in_a_frame(5) + fd_add_dependency(2,min) + fd_call_internal(min_x_y_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(min_x_y_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(2,0,maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_4,2,1) + fd_cf_in_a_frame(6) + fd_add_dependency(1,max) + fd_call_internal(min_x_y_eq_z_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(min_x_y_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,2) + fd_tell_interval(1,minZ,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_5,1,1) + fd_cf_in_a_frame(7) + fd_add_dependency(2,min) + fd_call_internal(min_x_y_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(min_x_y_eq_z_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minX,maxX,0) + fd_tell_interval(2,minX,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_6,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(min_x_y_eq_z_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #7 */ + +fd_begin_internal(min_x_y_eq_z_bloc_7) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,minZ,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_7_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_7,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(min_x_y_eq_z_bloc_7) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(min_x_y_eq_z_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_stop_constraint(6) + fd_stop_constraint(7) + fd_call_internal(min_x_y_eq_z_bloc_6_inst) + fd_call_internal(min_x_y_eq_z_bloc_7_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #8 */ + +fd_begin_internal(min_x_y_eq_z_bloc_8) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,minY,maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_8_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_8,2,1) + fd_add_dependency(1,min_max) + fd_call_internal(min_x_y_eq_z_bloc_8) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #9 */ + +fd_begin_internal(min_x_y_eq_z_bloc_9) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(1,minZ,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_bloc_9_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_bloc_9,1,1) + fd_add_dependency(2,min_max) + fd_call_internal(min_x_y_eq_z_bloc_9) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #2 */ + +fd_begin_internal(min_x_y_eq_z_case_group_2) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_stop_constraint(6) + fd_stop_constraint(7) + fd_call_internal(min_x_y_eq_z_bloc_8_inst) + fd_call_internal(min_x_y_eq_z_bloc_9_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxZ) + fd_local_value_var(minX) + + fd_load_min(minY,1) + fd_load_max(maxZ,2) + fd_load_min(minX,0) + fd_test_switch_condition(minY>maxZ,min_x_y_eq_z_case_group_1) + fd_test_switch_condition(minX>maxZ,min_x_y_eq_z_case_group_2) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_switch_1,-1,0) + fd_add_dependency(1,min) + fd_add_dependency(2,max) + fd_add_dependency(0,min) + fd_call_internal_and_test_switch(min_x_y_eq_z_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for min_x_y_eq_z */ + +fd_begin_user_constraint(min_x_y_eq_z(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(8) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(min_x_y_eq_z_bloc_1_inst) + fd_call_internal(min_x_y_eq_z_bloc_2_inst) + fd_call_internal(min_x_y_eq_z_bloc_3_inst) + fd_call_internal(min_x_y_eq_z_bloc_4_inst) + fd_call_internal(min_x_y_eq_z_bloc_5_inst) + fd_call_internal_and_test_switch_simple(min_x_y_eq_z_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-------------------------------*/ + /* User constraint: min_x_a_eq_z */ + /*-------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(min_x_a_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(intA) + + fd_load_min(minX,0) + fd_load_int(intA,1) + fd_tell_interval(2,math_min(minX,intA),max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_bloc_1,2,1) + fd_cf_in_a_frame(3) + fd_add_dependency(0,min) + fd_call_internal(min_x_a_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(min_x_a_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxX) + + fd_load_max(maxX,0) + fd_tell_interval(2,0,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,max) + fd_call_internal(min_x_a_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(min_x_a_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,2) + fd_tell_interval(0,minZ,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_bloc_3,0,1) + fd_cf_in_a_frame(5) + fd_add_dependency(2,min) + fd_call_internal(min_x_a_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(min_x_a_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + + fd_load_int(intA,1) + fd_tell_interval(2,0,intA) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(min_x_a_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minX,maxX,0) + fd_tell_interval(2,minX,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_bloc_5,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(min_x_a_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(min_x_a_eq_z_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,minZ,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_bloc_6,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(min_x_a_eq_z_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(min_x_a_eq_z_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_call_internal(min_x_a_eq_z_bloc_5_inst) + fd_call_internal(min_x_a_eq_z_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_switch_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(maxZ) + + fd_load_int(intA,1) + fd_load_max(maxZ,2) + fd_test_switch_condition(intA>maxZ,min_x_a_eq_z_case_group_1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_switch_1,-1,0) + fd_add_dependency(2,max) + fd_call_internal_and_test_switch(min_x_a_eq_z_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for min_x_a_eq_z */ + +fd_begin_user_constraint(min_x_a_eq_z(FdArg(X),FdArg(A),FdArg(Z))) + + fd_create_a_frame(6) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(min_x_a_eq_z_bloc_1_inst) + fd_call_internal(min_x_a_eq_z_bloc_2_inst) + fd_call_internal(min_x_a_eq_z_bloc_3_inst) + fd_call_internal(min_x_a_eq_z_bloc_4) + fd_call_internal_and_test_switch_simple(min_x_a_eq_z_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: min_x_y_eq_z_F */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_1,2,1) + fd_cf_in_a_frame(3) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_call_internal(min_x_y_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxX) + + fd_load_max(maxX,0) + fd_tell_interval(2,0,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,max) + fd_call_internal(min_x_y_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,2) + fd_tell_interval(0,minZ,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_3,0,1) + fd_cf_in_a_frame(5) + fd_add_dependency(2,min) + fd_call_internal(min_x_y_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(2,0,maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_4,2,1) + fd_cf_in_a_frame(6) + fd_add_dependency(1,max) + fd_call_internal(min_x_y_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,2) + fd_tell_interval(1,minZ,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_5,1,1) + fd_cf_in_a_frame(7) + fd_add_dependency(2,min) + fd_call_internal(min_x_y_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_6) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,0) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_6,2,1) + fd_add_dependency(0,dom) + fd_call_internal(min_x_y_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #7 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_7) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,2) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_7_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_7,0,1) + fd_add_dependency(2,dom) + fd_call_internal(min_x_y_eq_z_F_bloc_7) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(min_x_y_eq_z_F_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_stop_constraint(6) + fd_stop_constraint(7) + fd_call_internal(min_x_y_eq_z_F_bloc_6_inst) + fd_call_internal(min_x_y_eq_z_F_bloc_7_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #8 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_8) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,1) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_8_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_8,2,1) + fd_add_dependency(1,dom) + fd_call_internal(min_x_y_eq_z_F_bloc_8) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #9 */ + +fd_begin_internal(min_x_y_eq_z_F_bloc_9) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,2) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_bloc_9_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_bloc_9,1,1) + fd_add_dependency(2,dom) + fd_call_internal(min_x_y_eq_z_F_bloc_9) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #2 */ + +fd_begin_internal(min_x_y_eq_z_F_case_group_2) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_stop_constraint(6) + fd_stop_constraint(7) + fd_call_internal(min_x_y_eq_z_F_bloc_8_inst) + fd_call_internal(min_x_y_eq_z_F_bloc_9_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,1) + fd_load_dom(2,2) + fd_load_dom(0,0) + fd_range_copy(3,1) + fd_range_copy(1,2) + fd_test_switch_condition(Range_Test_Null_Inter(range_arg(3),range_arg(1)),min_x_y_eq_z_F_case_group_1) + fd_range_copy(1,0) + fd_range_copy(0,2) + fd_test_switch_condition(Range_Test_Null_Inter(range_arg(1),range_arg(0)),min_x_y_eq_z_F_case_group_2) + fd_exit_point + fd_deallocate + fd_return + +fd_end_internal + +fd_begin_internal(min_x_y_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_y_eq_z_F_switch_1,-1,0) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_add_dependency(0,dom) + fd_call_internal_and_test_switch(min_x_y_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for min_x_y_eq_z_F */ + +fd_begin_user_constraint(min_x_y_eq_z_F(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(8) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(min_x_y_eq_z_F_bloc_1_inst) + fd_call_internal(min_x_y_eq_z_F_bloc_2_inst) + fd_call_internal(min_x_y_eq_z_F_bloc_3_inst) + fd_call_internal(min_x_y_eq_z_F_bloc_4_inst) + fd_call_internal(min_x_y_eq_z_F_bloc_5_inst) + fd_call_internal_and_test_switch_simple(min_x_y_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------*/ + /* User constraint: min_x_a_eq_z_F */ + /*---------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(min_x_a_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,0) + fd_load_int(intA,1) + fd_range_copy(0,1) + fd_range_set_value(0,intA) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_F_bloc_1,2,1) + fd_cf_in_a_frame(3) + fd_add_dependency(0,dom) + fd_call_internal(min_x_a_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(min_x_a_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxX) + + fd_load_max(maxX,0) + fd_tell_interval(2,0,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_F_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,max) + fd_call_internal(min_x_a_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(min_x_a_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,2) + fd_tell_interval(0,minZ,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_F_bloc_3,0,1) + fd_cf_in_a_frame(5) + fd_add_dependency(2,min) + fd_call_internal(min_x_a_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(min_x_a_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + + fd_load_int(intA,1) + fd_tell_interval(2,0,intA) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(min_x_a_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,0) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_F_bloc_5,2,1) + fd_add_dependency(0,dom) + fd_call_internal(min_x_a_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(min_x_a_eq_z_F_bloc_6) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,2) + fd_range_copy(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_F_bloc_6,0,1) + fd_add_dependency(2,dom) + fd_call_internal(min_x_a_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(min_x_a_eq_z_F_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_call_internal(min_x_a_eq_z_F_bloc_5_inst) + fd_call_internal(min_x_a_eq_z_F_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(maxZ) + + fd_load_int(intA,1) + fd_load_max(maxZ,2) + fd_test_switch_condition(intA>maxZ,min_x_a_eq_z_F_case_group_1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(min_x_a_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(min_x_a_eq_z_F_switch_1,-1,0) + fd_add_dependency(2,max) + fd_call_internal_and_test_switch(min_x_a_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for min_x_a_eq_z_F */ + +fd_begin_user_constraint(min_x_a_eq_z_F(FdArg(X),FdArg(A),FdArg(Z))) + + fd_create_a_frame(6) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(min_x_a_eq_z_F_bloc_1_inst) + fd_call_internal(min_x_a_eq_z_F_bloc_2_inst) + fd_call_internal(min_x_a_eq_z_F_bloc_3_inst) + fd_call_internal(min_x_a_eq_z_F_bloc_4) + fd_call_internal_and_test_switch_simple(min_x_a_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-------------------------------*/ + /* User constraint: max_x_y_eq_z */ + /*-------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(max_x_y_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(maxX) + fd_local_value_var(maxY) + + fd_load_max(maxX,0) + fd_load_max(maxY,1) + fd_tell_interval(2,0,math_max(maxX,maxY)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_1,2,1) + fd_cf_in_a_frame(3) + fd_add_dependency(0,max) + fd_add_dependency(1,max) + fd_call_internal(max_x_y_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(max_x_y_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + + fd_load_min(minX,0) + fd_tell_interval(2,minX,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,min) + fd_call_internal(max_x_y_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(max_x_y_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(maxZ) + + fd_load_max(maxZ,2) + fd_tell_interval(0,0,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_3,0,1) + fd_cf_in_a_frame(5) + fd_add_dependency(2,max) + fd_call_internal(max_x_y_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(max_x_y_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(minY) + + fd_load_min(minY,1) + fd_tell_interval(2,minY,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_4,2,1) + fd_cf_in_a_frame(6) + fd_add_dependency(1,min) + fd_call_internal(max_x_y_eq_z_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(max_x_y_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(maxZ) + + fd_load_max(maxZ,2) + fd_tell_interval(1,0,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_5,1,1) + fd_cf_in_a_frame(7) + fd_add_dependency(2,max) + fd_call_internal(max_x_y_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(max_x_y_eq_z_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_min_max(minX,maxX,0) + fd_tell_interval(2,minX,maxX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_6,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(max_x_y_eq_z_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #7 */ + +fd_begin_internal(max_x_y_eq_z_bloc_7) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,minZ,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_7_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_7,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(max_x_y_eq_z_bloc_7) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(max_x_y_eq_z_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_stop_constraint(6) + fd_stop_constraint(7) + fd_call_internal(max_x_y_eq_z_bloc_6_inst) + fd_call_internal(max_x_y_eq_z_bloc_7_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #8 */ + +fd_begin_internal(max_x_y_eq_z_bloc_8) + + fd_local_fdv_adr + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,minY,maxY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_8_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_8,2,1) + fd_add_dependency(1,min_max) + fd_call_internal(max_x_y_eq_z_bloc_8) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #9 */ + +fd_begin_internal(max_x_y_eq_z_bloc_9) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(1,minZ,maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_bloc_9_inst) + + fd_local_cf_pointer + fd_create_c_frame(max_x_y_eq_z_bloc_9,1,1) + fd_add_dependency(2,min_max) + fd_call_internal(max_x_y_eq_z_bloc_9) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #2 */ + +fd_begin_internal(max_x_y_eq_z_case_group_2) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_stop_constraint(6) + fd_stop_constraint(7) + fd_call_internal(max_x_y_eq_z_bloc_8_inst) + fd_call_internal(max_x_y_eq_z_bloc_9_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(max_x_y_eq_z_switch_1) + + fd_local_fdv_adr + fd_local_value_var(maxY) + fd_local_value_var(minZ) + fd_local_value_var(maxX) + + fd_load_max(maxY,1) + fd_load_min(minZ,2) + fd_load_max(maxX,0) + fd_test_switch_condition(maxY=maxY,abs_x_minus_y_eq_z_case_group_1) + fd_test_switch_condition(minY>=maxX,abs_x_minus_y_eq_z_case_group_2) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_switch_1,-1,0) + fd_add_dependency(0,min_max) + fd_add_dependency(1,min_max) + fd_call_internal_and_test_switch(abs_x_minus_y_eq_z_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for abs_x_minus_y_eq_z */ + +fd_begin_user_constraint(abs_x_minus_y_eq_z(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(6) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(abs_x_minus_y_eq_z_bloc_1_inst) + fd_call_internal(abs_x_minus_y_eq_z_bloc_2_inst) + fd_call_internal(abs_x_minus_y_eq_z_bloc_3_inst) + fd_call_internal_and_test_switch_simple(abs_x_minus_y_eq_z_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*-------------------------------------*/ + /* User constraint: abs_x_minus_a_eq_z */ + /*-------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_int(intA,1) + fd_load_min_max(minZ,maxZ,2) + fd_range_interval(0,intA+minZ,intA+maxZ) + fd_range_interval(1,intA-maxZ,intA-minZ) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_bloc_1,0,1) + fd_cf_in_a_frame(3) + fd_add_dependency(2,min_max) + fd_call_internal(abs_x_minus_a_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_min_max(minX,maxX,0) + fd_load_int(intA,1) + fd_range_interval(0,minX-intA,maxX-intA) + fd_range_interval(1,intA-maxX,intA-minX) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,min_max) + fd_call_internal(abs_x_minus_a_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_int(intA,1) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,intA+minZ,intA+maxZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_bloc_3,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(abs_x_minus_a_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intA) + + fd_load_min_max(minX,maxX,0) + fd_load_int(intA,1) + fd_tell_interval(2,minX-intA,maxX-intA) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_bloc_4,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(abs_x_minus_a_eq_z_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(abs_x_minus_a_eq_z_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_call_internal(abs_x_minus_a_eq_z_bloc_3_inst) + fd_call_internal(abs_x_minus_a_eq_z_bloc_4_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_int(intA,1) + fd_load_min_max(minZ,maxZ,2) + fd_tell_interval(0,intA-maxZ,intA-minZ) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_bloc_5,0,1) + fd_add_dependency(2,min_max) + fd_call_internal(abs_x_minus_a_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minX) + fd_local_value_var(maxX) + + fd_load_int(intA,1) + fd_load_min_max(minX,maxX,0) + fd_tell_interval(2,intA-maxX,intA-minX) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_bloc_6,2,1) + fd_add_dependency(0,min_max) + fd_call_internal(abs_x_minus_a_eq_z_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #2 */ + +fd_begin_internal(abs_x_minus_a_eq_z_case_group_2) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_call_internal(abs_x_minus_a_eq_z_bloc_5_inst) + fd_call_internal(abs_x_minus_a_eq_z_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intA) + + fd_load_min_max(minX,maxX,0) + fd_load_int(intA,1) + fd_test_switch_condition(minX>=intA,abs_x_minus_a_eq_z_case_group_1) + fd_test_switch_condition(intA>=maxX,abs_x_minus_a_eq_z_case_group_2) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_switch_1,-1,0) + fd_add_dependency(0,min_max) + fd_call_internal_and_test_switch(abs_x_minus_a_eq_z_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for abs_x_minus_a_eq_z */ + +fd_begin_user_constraint(abs_x_minus_a_eq_z(FdArg(X),FdArg(A),FdArg(Z))) + + fd_create_a_frame(5) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(abs_x_minus_a_eq_z_bloc_1_inst) + fd_call_internal(abs_x_minus_a_eq_z_bloc_2_inst) + fd_call_internal_and_test_switch_simple(abs_x_minus_a_eq_z_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------------*/ + /* User constraint: abs_x_minus_y_eq_z_F */ + /*---------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(2,1) + fd_load_dom(3,2) + fd_range_copy(0,2) + fd_range_copy(1,3) + fd_range_add_range(0,1) + fd_range_copy(1,2) + fd_range_copy(2,3) + fd_range_sub_range(1,2) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_1,0,1) + fd_cf_in_a_frame(3) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(2,0) + fd_load_dom(3,2) + fd_range_copy(0,2) + fd_range_copy(1,3) + fd_range_add_range(0,1) + fd_range_copy(1,2) + fd_range_copy(2,3) + fd_range_sub_range(1,2) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_2,1,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(3,0) + fd_load_dom(2,1) + fd_range_copy(0,3) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_copy(2,3) + fd_range_sub_range(1,2) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_3,2,1) + fd_cf_in_a_frame(5) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,1) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_4,0,1) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_5,1,1) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_6) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_6,2,1) + fd_add_dependency(0,dom) + fd_add_dependency(1,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_4_inst) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_5_inst) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #7 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_7) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,1) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_7_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_7,0,1) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_7) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #8 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_8) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_8_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_8,1,1) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_8) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #9 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_9) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,1) + fd_load_dom(2,0) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_bloc_9_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_bloc_9,2,1) + fd_add_dependency(1,dom) + fd_add_dependency(0,dom) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_9) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #2 */ + +fd_begin_internal(abs_x_minus_y_eq_z_F_case_group_2) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_stop_constraint(5) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_7_inst) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_8_inst) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_9_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minY,maxY,1) + fd_test_switch_condition(minX>=maxY,abs_x_minus_y_eq_z_F_case_group_1) + fd_test_switch_condition(minY>=maxX,abs_x_minus_y_eq_z_F_case_group_2) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_y_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_y_eq_z_F_switch_1,-1,0) + fd_add_dependency(0,min_max) + fd_add_dependency(1,min_max) + fd_call_internal_and_test_switch(abs_x_minus_y_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for abs_x_minus_y_eq_z_F */ + +fd_begin_user_constraint(abs_x_minus_y_eq_z_F(FdArg(X),FdArg(Y),FdArg(Z))) + + fd_create_a_frame(6) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_1_inst) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_2_inst) + fd_call_internal(abs_x_minus_y_eq_z_F_bloc_3_inst) + fd_call_internal_and_test_switch_simple(abs_x_minus_y_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*---------------------------------------*/ + /* User constraint: abs_x_minus_a_eq_z_F */ + /*---------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(3,2) + fd_load_int(intA,1) + fd_range_copy(0,3) + fd_range_add_value(0,intA) + fd_range_interval(1,intA,intA) + fd_range_copy(2,3) + fd_range_sub_range(1,2) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_bloc_1,0,1) + fd_cf_in_a_frame(3) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(3,0) + fd_load_int(intA,1) + fd_range_copy(0,3) + fd_range_sub_value(0,intA) + fd_range_interval(1,intA,intA) + fd_range_copy(2,3) + fd_range_sub_range(1,2) + fd_range_union(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_bloc_2,2,1) + fd_cf_in_a_frame(4) + fd_add_dependency(0,dom) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,2) + fd_load_int(intA,1) + fd_range_copy(0,1) + fd_range_add_value(0,intA) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_bloc_3,0,1) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + + fd_allocate + fd_load_dom(1,0) + fd_load_int(intA,1) + fd_range_copy(0,1) + fd_range_sub_value(0,intA) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_bloc_4,2,1) + fd_add_dependency(0,dom) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #1 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_case_group_1) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_3_inst) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_4_inst) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_int(intA,1) + fd_load_dom(2,2) + fd_range_interval(0,intA,intA) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_bloc_5,0,1) + fd_add_dependency(2,dom) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_int(intA,1) + fd_load_dom(2,0) + fd_range_interval(0,intA,intA) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_bloc_6,2,1) + fd_add_dependency(0,dom) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Group of case #2 */ + +fd_begin_internal(abs_x_minus_a_eq_z_F_case_group_2) + + fd_stop_constraint(3) + fd_stop_constraint(4) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_5_inst) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(intA) + + fd_load_min_max(minX,maxX,0) + fd_load_int(intA,1) + fd_test_switch_condition(minX>=intA,abs_x_minus_a_eq_z_F_case_group_1) + fd_test_switch_condition(intA>=maxX,abs_x_minus_a_eq_z_F_case_group_2) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(abs_x_minus_a_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(abs_x_minus_a_eq_z_F_switch_1,-1,0) + fd_add_dependency(0,min_max) + fd_call_internal_and_test_switch(abs_x_minus_a_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for abs_x_minus_a_eq_z_F */ + +fd_begin_user_constraint(abs_x_minus_a_eq_z_F(FdArg(X),FdArg(A),FdArg(Z))) + + fd_create_a_frame(5) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(Z,2) + + fd_before_add_constraint + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_1_inst) + fd_call_internal(abs_x_minus_a_eq_z_F_bloc_2_inst) + fd_call_internal_and_test_switch_simple(abs_x_minus_a_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------------------*/ + /* User constraint: quot_rem_x_y_r_eq_z */ + /*--------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minR) + + fd_load_min(minR,2) + fd_tell_interval(1,minR+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_1,1,1) + fd_add_dependency(2,min) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(2,0,maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_2,2,1) + fd_add_dependency(1,max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minR) + fd_local_value_var(maxR) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minR,maxR,2) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(3,DivUp(minX-maxR,maxY),DivDn(maxX-minR,minY)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_3,3,1) + fd_add_dependency(0,min_max) + fd_add_dependency(2,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minZ,maxZ,3) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,minX-maxZ*maxY,maxX-minZ*minY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_4,2,1) + fd_add_dependency(0,min_max) + fd_add_dependency(3,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minY) + fd_local_value_var(maxY) + fd_local_value_var(minR) + fd_local_value_var(maxR) + + fd_load_min_max(minZ,maxZ,3) + fd_load_min_max(minY,maxY,1) + fd_load_min_max(minR,maxR,2) + fd_tell_interval(0,minZ*minY+minR,maxZ*maxY+maxR) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_5,0,1) + fd_add_dependency(3,min_max) + fd_add_dependency(1,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxZ) + + fd_load_min(minX,0) + fd_load_max(maxZ,3) + fd_tell_interval(1,DivDn(minX,maxZ+1)+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_6,1,1) + fd_add_dependency(0,min) + fd_add_dependency(3,max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #7 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_7) + + fd_local_fdv_adr + fd_local_value_var(maxZ) + fd_local_value_var(maxY) + + fd_load_max(maxZ,3) + fd_load_max(maxY,1) + fd_tell_interval(0,0,(maxZ+1)*maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_7_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_7,0,1) + fd_add_dependency(3,max) + fd_add_dependency(1,max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_7) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #8 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_8) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minR) + fd_local_value_var(maxR) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minR,maxR,2) + fd_load_min_max(minZ,maxZ,3) + fd_tell_interval(1,DivUp(minX-maxR,maxZ),DivDn(maxX-minR,minZ)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_bloc_8_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_bloc_8,1,1) + fd_add_dependency(0,min_max) + fd_add_dependency(2,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_8) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,3) + fd_test_switch_condition(minZ>0,quot_rem_x_y_r_eq_z_bloc_8_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_switch_1,-1,0) + fd_add_dependency(3,min) + fd_call_internal_and_test_switch(quot_rem_x_y_r_eq_z_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for quot_rem_x_y_r_eq_z */ + +fd_begin_user_constraint(quot_rem_x_y_r_eq_z(FdArg(X),FdArg(Y),FdArg(R),FdArg(Z))) + + fd_create_a_frame(4) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(R,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_1_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_2_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_3_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_4_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_5_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_6_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_bloc_7_inst) + fd_call_internal_and_test_switch_simple(quot_rem_x_y_r_eq_z_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------------------*/ + /* User constraint: quot_rem_a_y_r_eq_z */ + /*--------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minR) + + fd_load_min(minR,2) + fd_tell_interval(1,minR+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_bloc_1,1,1) + fd_add_dependency(2,min) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(2,0,maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_bloc_2,2,1) + fd_add_dependency(1,max) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(maxZ) + + fd_load_int(intA,0) + fd_load_max(maxZ,3) + fd_tell_interval(1,DivDn(intA,maxZ+1)+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_bloc_3,1,1) + fd_add_dependency(3,max) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minR) + fd_local_value_var(maxR) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_int(intA,0) + fd_load_min_max(minR,maxR,2) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(3,DivUp(intA-maxR,maxY),DivDn(intA-minR,minY)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_bloc_4,3,1) + fd_add_dependency(2,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(minY) + fd_local_value_var(maxY) + + fd_load_int(intA,0) + fd_load_min_max(minZ,maxZ,3) + fd_load_min_max(minY,maxY,1) + fd_tell_interval(2,intA-maxZ*maxY,intA-minZ*minY) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_bloc_5,2,1) + fd_add_dependency(3,min_max) + fd_add_dependency(1,min_max) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(minR) + fd_local_value_var(maxR) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + + fd_load_int(intA,0) + fd_load_min_max(minR,maxR,2) + fd_load_min_max(minZ,maxZ,3) + fd_tell_interval(1,DivUp(intA-maxR,maxZ),DivDn(intA-minR,minZ)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_bloc_6,1,1) + fd_add_dependency(2,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,3) + fd_test_switch_condition(minZ>0,quot_rem_a_y_r_eq_z_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_switch_1,-1,0) + fd_add_dependency(3,min) + fd_call_internal_and_test_switch(quot_rem_a_y_r_eq_z_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for quot_rem_a_y_r_eq_z */ + +fd_begin_user_constraint(quot_rem_a_y_r_eq_z(FdArg(A),FdArg(Y),FdArg(R),FdArg(Z))) + + fd_create_a_frame(4) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(R,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_1_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_2_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_3_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_4_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_bloc_5_inst) + fd_call_internal_and_test_switch_simple(quot_rem_a_y_r_eq_z_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*--------------------------------------*/ + /* User constraint: quot_rem_x_a_r_eq_z */ + /*--------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + + fd_load_int(intA,1) + fd_tell_interval(2,0,intA-1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minR) + fd_local_value_var(maxR) + fd_local_value_var(intA) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minR,maxR,2) + fd_load_int(intA,1) + fd_tell_interval(3,DivUp(minX-maxR,intA),DivDn(maxX-minR,intA)) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_bloc_2,3,1) + fd_add_dependency(0,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxX) + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intA) + + fd_load_min_max(minX,maxX,0) + fd_load_min_max(minZ,maxZ,3) + fd_load_int(intA,1) + fd_tell_interval(2,minX-maxZ*intA,maxX-minZ*intA) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_bloc_3,2,1) + fd_add_dependency(0,min_max) + fd_add_dependency(3,min_max) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(minZ) + fd_local_value_var(maxZ) + fd_local_value_var(intA) + fd_local_value_var(minR) + fd_local_value_var(maxR) + + fd_load_min_max(minZ,maxZ,3) + fd_load_int(intA,1) + fd_load_min_max(minR,maxR,2) + fd_tell_interval(0,minZ*intA+minR,maxZ*intA+maxR) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_bloc_4,0,1) + fd_add_dependency(3,min_max) + fd_add_dependency(2,min_max) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(maxZ) + fd_local_value_var(intA) + + fd_load_max(maxZ,3) + fd_load_int(intA,1) + fd_tell_interval(0,0,(maxZ+1)*intA-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_bloc_5,0,1) + fd_add_dependency(3,max) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for quot_rem_x_a_r_eq_z */ + +fd_begin_user_constraint(quot_rem_x_a_r_eq_z(FdArg(X),FdArg(A),FdArg(R),FdArg(Z))) + + fd_create_a_frame(4) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(R,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_1) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_2_inst) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_3_inst) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_4_inst) + fd_call_internal(quot_rem_x_a_r_eq_z_bloc_5_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------------*/ + /* User constraint: quot_rem_x_y_r_eq_z_F */ + /*----------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minR) + + fd_load_min(minR,2) + fd_tell_interval(1,minR+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_1,1,1) + fd_add_dependency(2,min) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(2,0,maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_2,2,1) + fd_add_dependency(1,max) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(3,2) + fd_load_dom(2,1) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_div_range(0,1) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_3,3,1) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_add_dependency(1,dom) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,3) + fd_load_dom(3,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_copy(2,3) + fd_range_mul_range(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_4,2,1) + fd_add_dependency(0,dom) + fd_add_dependency(3,dom) + fd_add_dependency(1,dom) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,3) + fd_load_dom(3,1) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_mul_range(0,1) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_5,0,1) + fd_add_dependency(3,dom) + fd_add_dependency(1,dom) + fd_add_dependency(2,dom) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(minX) + fd_local_value_var(maxZ) + + fd_load_min(minX,0) + fd_load_max(maxZ,3) + fd_tell_interval(1,DivDn(minX,maxZ+1)+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_6,1,1) + fd_add_dependency(0,min) + fd_add_dependency(3,max) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #7 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_7) + + fd_local_fdv_adr + fd_local_value_var(maxZ) + fd_local_value_var(maxY) + + fd_load_max(maxZ,3) + fd_load_max(maxY,1) + fd_tell_interval(0,0,(maxZ+1)*maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_7_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_7,0,1) + fd_add_dependency(3,max) + fd_add_dependency(1,max) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_7) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #8 */ + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_8) + + fd_local_fdv_adr + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(3,2) + fd_load_dom(2,3) + fd_range_copy(0,1) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_div_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_bloc_8_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_bloc_8,1,1) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_add_dependency(3,dom) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_8) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,3) + fd_test_switch_condition(minZ>0,quot_rem_x_y_r_eq_z_F_bloc_8_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_y_r_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_y_r_eq_z_F_switch_1,-1,0) + fd_add_dependency(3,min) + fd_call_internal_and_test_switch(quot_rem_x_y_r_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for quot_rem_x_y_r_eq_z_F */ + +fd_begin_user_constraint(quot_rem_x_y_r_eq_z_F(FdArg(X),FdArg(Y),FdArg(R),FdArg(Z))) + + fd_create_a_frame(4) + fd_fdv_in_a_frame(X,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(R,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_1_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_2_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_3_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_4_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_5_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_6_inst) + fd_call_internal(quot_rem_x_y_r_eq_z_F_bloc_7_inst) + fd_call_internal_and_test_switch_simple(quot_rem_x_y_r_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------------*/ + /* User constraint: quot_rem_a_y_r_eq_z_F */ + /*----------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(minR) + + fd_load_min(minR,2) + fd_tell_interval(1,minR+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_bloc_1,1,1) + fd_add_dependency(2,min) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(maxY) + + fd_load_max(maxY,1) + fd_tell_interval(2,0,maxY-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_bloc_2,2,1) + fd_add_dependency(1,max) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_value_var(maxZ) + + fd_load_int(intA,0) + fd_load_max(maxZ,3) + fd_tell_interval(1,DivDn(intA,maxZ+1)+1,max_integer) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_bloc_3,1,1) + fd_add_dependency(3,max) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_int(intA,0) + fd_load_dom(3,2) + fd_load_dom(2,1) + fd_range_interval(0,intA,intA) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_div_range(0,1) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_bloc_4,3,1) + fd_add_dependency(2,dom) + fd_add_dependency(1,dom) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_int(intA,0) + fd_load_dom(2,3) + fd_load_dom(3,1) + fd_range_interval(0,intA,intA) + fd_range_copy(1,2) + fd_range_copy(2,3) + fd_range_mul_range(1,2) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_bloc_5,2,1) + fd_add_dependency(3,dom) + fd_add_dependency(1,dom) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #6 */ + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_6) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + fd_local_range_var(3) + + fd_allocate + fd_load_int(intA,0) + fd_load_dom(3,2) + fd_load_dom(2,3) + fd_range_interval(0,intA,intA) + fd_range_copy(1,3) + fd_range_sub_range(0,1) + fd_range_copy(1,2) + fd_range_div_range(0,1) + fd_deallocate + fd_tell_range(1,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_bloc_6_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_bloc_6,1,1) + fd_add_dependency(2,dom) + fd_add_dependency(3,dom) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_6) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_switch_1) + + fd_local_fdv_adr + fd_local_value_var(minZ) + + fd_load_min(minZ,3) + fd_test_switch_condition(minZ>0,quot_rem_a_y_r_eq_z_F_bloc_6_inst) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_a_y_r_eq_z_F_switch_1_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_a_y_r_eq_z_F_switch_1,-1,0) + fd_add_dependency(3,min) + fd_call_internal_and_test_switch(quot_rem_a_y_r_eq_z_F_switch_1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for quot_rem_a_y_r_eq_z_F */ + +fd_begin_user_constraint(quot_rem_a_y_r_eq_z_F(FdArg(A),FdArg(Y),FdArg(R),FdArg(Z))) + + fd_create_a_frame(4) + fd_int_in_a_frame(A,0) + fd_fdv_in_a_frame(Y,1) + fd_fdv_in_a_frame(R,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_1_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_2_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_3_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_4_inst) + fd_call_internal(quot_rem_a_y_r_eq_z_F_bloc_5_inst) + fd_call_internal_and_test_switch_simple(quot_rem_a_y_r_eq_z_F_switch_1_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + + + /*----------------------------------------*/ + /* User constraint: quot_rem_x_a_r_eq_z_F */ + /*----------------------------------------*/ + + + /* Bloc #1 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_1) + + fd_local_fdv_adr + fd_local_value_var(intA) + + fd_load_int(intA,1) + fd_tell_interval(2,0,intA-1) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #2 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_2) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,2) + fd_load_int(intA,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_sub_range(0,1) + fd_range_div_value(0,intA) + fd_deallocate + fd_tell_range(3,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_2_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_F_bloc_2,3,1) + fd_add_dependency(0,dom) + fd_add_dependency(2,dom) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_2) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #3 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_3) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,0) + fd_load_dom(2,3) + fd_load_int(intA,1) + fd_range_copy(0,1) + fd_range_copy(1,2) + fd_range_mul_value(1,intA) + fd_range_sub_range(0,1) + fd_deallocate + fd_tell_range(2,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_3_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_F_bloc_3,2,1) + fd_add_dependency(0,dom) + fd_add_dependency(3,dom) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_3) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #4 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_4) + + fd_local_fdv_adr + fd_local_value_var(intA) + fd_local_range_var(0) + fd_local_range_var(1) + fd_local_range_var(2) + + fd_allocate + fd_load_dom(1,3) + fd_load_int(intA,1) + fd_load_dom(2,2) + fd_range_copy(0,1) + fd_range_mul_value(0,intA) + fd_range_copy(1,2) + fd_range_add_range(0,1) + fd_deallocate + fd_tell_range(0,0) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_4_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_F_bloc_4,0,1) + fd_add_dependency(3,dom) + fd_add_dependency(2,dom) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_4) + fd_exit_point + fd_return + +fd_end_internal + + + /* Bloc #5 */ + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_5) + + fd_local_fdv_adr + fd_local_value_var(maxZ) + fd_local_value_var(intA) + + fd_load_max(maxZ,3) + fd_load_int(intA,1) + fd_tell_interval(0,0,(maxZ+1)*intA-1) + fd_exit_point + fd_return + +fd_end_internal + +fd_begin_internal(quot_rem_x_a_r_eq_z_F_bloc_5_inst) + + fd_local_cf_pointer + fd_create_c_frame(quot_rem_x_a_r_eq_z_F_bloc_5,0,1) + fd_add_dependency(3,max) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_5) + fd_exit_point + fd_return + +fd_end_internal + + + /* Entry point for quot_rem_x_a_r_eq_z_F */ + +fd_begin_user_constraint(quot_rem_x_a_r_eq_z_F(FdArg(X),FdArg(A),FdArg(R),FdArg(Z))) + + fd_create_a_frame(4) + fd_fdv_in_a_frame(X,0) + fd_int_in_a_frame(A,1) + fd_fdv_in_a_frame(R,2) + fd_fdv_in_a_frame(Z,3) + + fd_before_add_constraint + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_1) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_2_inst) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_3_inst) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_4_inst) + fd_call_internal(quot_rem_x_a_r_eq_z_F_bloc_5_inst) + fd_after_add_constraint + fd_exit_point + fd_return + +fd_end_user_constraint + --- gprolog-1.3.0.orig/src/Wam2Ma/wam_parser.c +++ gprolog-1.3.0/src/Wam2Ma/wam_parser.c @@ -45,8 +45,8 @@ #define MAX_FCT_ARITY 10 #define MAX_LINE_LEN 32767 -#define MAX_STR_LEN 4096 -#define MAX_ARGS 4096 +#define MAX_STR_LEN 8192 +#define MAX_ARGS 131072 --- gprolog-1.3.0.orig/src/Ma2Asm/ma_parser.c +++ gprolog-1.3.0/src/Ma2Asm/ma_parser.c @@ -44,10 +44,10 @@ * Constants * *---------------------------------*/ -#define MAX_LINE_LEN 32767 +#define MAX_LINE_LEN 262144 /* 256K */ #define MAX_STR_LEN 2048 #define MAX_ARGS 128 -#define MAX_SWITCH_CASES 10240 +#define MAX_SWITCH_CASES 32768 /* 32K */ --- gprolog-1.3.0.orig/src/Ma2Asm/ma2asm_inst.c +++ gprolog-1.3.0/src/Ma2Asm/ma2asm_inst.c @@ -65,6 +65,10 @@ #include "mips_irix.c" +#elif defined(M_mips_linux) + +#include "mips_linux.c" + #elif defined(M_powerpc) #include "powerpc_any.c" --- gprolog-1.3.0.orig/src/Ma2Asm/Makefile.in +++ gprolog-1.3.0/src/Ma2Asm/Makefile.in @@ -14,7 +14,7 @@ ma2asm@OBJ_SUFFIX@: ma2asm.c ma_protos.h ma2asm_inst@OBJ_SUFFIX@: ma2asm_inst.c ma_parser.h ../EnginePl/wam_regs.h \ ix86_any.c powerpc_any.c sparc_any.c \ - mips_irix.c alpha_any.c x86_64_any.c + mips_irix.c mips_linux.c alpha_any.c x86_64_any.c $(CC) $(CFLAGS) -c ma2asm_inst.c ma2asm@EXE_SUFFIX@: ma2asm@OBJ_SUFFIX@ ma_parser@OBJ_SUFFIX@ \ --- /dev/null +++ gprolog-1.3.0/src/Ma2Asm/mips_linux.c @@ -0,0 +1,1242 @@ +/*-------------------------------------------------------------------------* + * GNU Prolog * + * * + * Part : mini-assembler to assembler translator * + * File : mips_linux.c * + * Descr.: translation file for Linux on MIPS * + * Author: Thiemo Seufer * + * * + * Copyright (C) 2005,2007 Thiemo Seufer * + * * + * Derived from the mips_irix.c support, with the original copyright * + * notice: * + * * + * Author: Alexander Diemand, Daniel Diaz * + * * + * Copyright (C) 1999 Daniel Diaz * + * * + * GNU Prolog 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, or any later version. * + * * + * GNU Prolog 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. * + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. * + *-------------------------------------------------------------------------*/ + +#include +#include +#include +#include + +/*---------------------------------* + * Constants * + *---------------------------------*/ + +#define STRING_PREFIX ".LC" + +#define MAX_C_ARGS_IN_C_CODE 32 + +/*---------------------------------* + * Type Definitions * + *---------------------------------*/ + +/*---------------------------------* + * Global Variables * + *---------------------------------*/ + +char asm_reg_bank[16]; +char asm_reg_e[16]; +char asm_reg_b[16]; +char asm_reg_cp[16]; + +int w_label = 0; + +static char dbl_arg_buffer[8192] = "\0"; /* a temp buffer for the double arguments */ + +char act_routine[512] = "\0"; /* remembers the actual routine we are building */ + +int inPrologCode = 0; /* whether we are currently compiling a prolog code */ + + /* variables for ma_parser.c / ma2asm.c */ + +char *comment_prefix = "#"; +char *local_symb_prefix = ".L"; +int strings_need_null = 1; +int call_c_reverse_args = 0; + +char *inline_asm_data[] = { NULL }; + +int double_args; +int seen_int_arg; +int double_pad; + +/*---------------------------------* + * Function Prototypes * + *---------------------------------*/ + + +/*-------------------------------------------------------------------------* + * INLINED CODE * + * * + *-------------------------------------------------------------------------*/ +/* all %s will be replaced with the function's name + * all %d will be replaced with the current nb_inlines + */ +static long nb_inlines = 0; +static char *def_inlines[] = { + /* name code */ + 0, 0 /* end of list */ +}; + + + +/*-------------------------------------------------------------------------* + * MAKE_INLINE * + * * + *-------------------------------------------------------------------------*/ +/* when it finds a function to inline it will do so immediatly and return 1 + * else it fails and returns 0 + */ +static int +make_inline(char *fct_name, int nb_args) +{ + char *fp; + int counter; + + return 0; /* not yet */ + + /* user can set an environment variable to control this */ + if (!getenv("GPROLOG_ASM_INLINE")) + return 0; + + counter = 0; + while (def_inlines[counter]) + { + if (strcmp(fct_name, def_inlines[counter]) == 0) + { + /* found code to inline, emit */ + fp = def_inlines[++counter]; + while (*fp != '\0') + { + if (*fp == '%' && *(fp + 1) == 's') + { + String_Out(fct_name); + fp++; + } + else if (*fp == '%' && *(fp + 1) == 'd') + { + Int_Out(nb_inlines); + fp++; + } + else + { + Char_Out(*fp); + } + fp++; + } + nb_inlines++; + return 1; + } + counter++; + } + return 0; +} + + + + +/*-------------------------------------------------------------------------* + * ASM_START * + * * + *-------------------------------------------------------------------------*/ +void +Asm_Start(void) +{ +#ifdef MAP_REG_BANK + sprintf(asm_reg_bank, "%s", MAP_REG_BANK); +#else + strcpy(asm_reg_bank, "$16"); +#endif + +#ifdef MAP_REG_E + sprintf(asm_reg_e, "%s", MAP_REG_E); +#else +/* strcpy(asm_reg_e,"$21"); */ + sprintf(asm_reg_e, "%d(%s)", MAP_OFFSET_E, asm_reg_bank); +#endif + +#ifdef MAP_REG_B + sprintf(asm_reg_b, "%s", MAP_REG_B); +#else +/* sprintf(asm_reg_b,"$18"); */ + sprintf(asm_reg_b, "%d(%s)", MAP_OFFSET_B, asm_reg_bank); +#endif + +#ifdef MAP_REG_CP + sprintf(asm_reg_cp, "%s", MAP_REG_CP); +#else +/* sprintf(asm_reg_cp,"$20"); */ + sprintf(asm_reg_cp, "%d(%s)", MAP_OFFSET_CP, asm_reg_bank); +#endif + + Inst_Printf(".option", "pic2"); /* gcc uses this */ + Inst_Printf("#.set", "noat"); + Inst_Printf("#.set", "noreorder"); /* let the assembler reorder instructions */ + + Inst_Printf("# asm_reg_bank ", asm_reg_bank); + Inst_Printf("# asm_reg_e ", asm_reg_e); + Inst_Printf("# asm_reg_b ", asm_reg_b); + Inst_Printf("# asm_reg_cp ", asm_reg_cp); + + Label_Printf("\t.section\t.text"); + +} + + + + +/*-------------------------------------------------------------------------* + * ASM_STOP * + * * + *-------------------------------------------------------------------------*/ +void +Asm_Stop(void) +{ + /* we are printing the fixed doubles at the end of the file, + * they will appear in the data section */ + if (dbl_arg_buffer[0] != '\0') + { + Label_Printf(".section\t.rodata"); + Label_Printf(dbl_arg_buffer); + dbl_arg_buffer[0] = '\0'; + } +} + + + + +/*-------------------------------------------------------------------------* + * CODE_START * + * * + *-------------------------------------------------------------------------*/ +void +Code_Start(char *label, int prolog, int global) +{ + + if (act_routine[0] != '\0') + Code_Stop(); /* we first have to close the previous code */ + + Inst_Printf(".text", ""); + Inst_Printf(".align", "2"); + Inst_Printf(".ent", "%s", label); + if (global) + Inst_Printf(".globl", "%s", label); + + Label(label); + + /* remember this label */ + strcpy(act_routine, label); + + if (prolog) + { + /* prolog code does not need any stack space */ + inPrologCode = 1; + Inst_Printf(".frame", "$sp,0,$31"); + Inst_Printf(".mask", "0x00000000,0"); + Inst_Printf(".fmask", "0x00000000,0"); + } + else + { + /* for c code we need to save some registers */ + inPrologCode = 0; + /* */ + Inst_Printf(".frame", "$sp,%d,$31", MAX_C_ARGS_IN_C_CODE * 4 + 16); + Inst_Printf(".mask", "0x10000000,-16"); + Inst_Printf(".fmask", "0x00000000,0"); + Inst_Printf(".set", "noreorder"); + Inst_Printf(".cpload", "$25"); + Inst_Printf(".set", "reorder"); + Inst_Printf("subu", "$sp,%d", MAX_C_ARGS_IN_C_CODE * 4 + 16); + Inst_Printf(".cprestore", "%d", MAX_C_ARGS_IN_C_CODE * 4 + 4); + Inst_Printf("sw", "$31,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 0); + } +} + + + + +/*-------------------------------------------------------------------------* + * CODE_STOP * + * * + *-------------------------------------------------------------------------*/ +void +Code_Stop(void) +{ + Inst_Printf(".end", "%s", act_routine); + + act_routine[0] = '\0'; +} + + + + +/*-------------------------------------------------------------------------* + * LABEL * + * * + *-------------------------------------------------------------------------*/ +void +Label(char *label) +{ + Label_Printf("\n%s:", label); +} + + + + +/*-------------------------------------------------------------------------* + * RELOAD_E_IN_REGISTER * + * * + *-------------------------------------------------------------------------*/ +void +Reload_E_In_Register(void) +{ +} + + + + +/*-------------------------------------------------------------------------* + * PL_JUMP * + * * + *-------------------------------------------------------------------------*/ +void +Pl_Jump(char *label) +{ + Inst_Printf("la", "$25,%s", label); + Inst_Printf("jr", "$25"); +} + + + + +/*-------------------------------------------------------------------------* + * PREP_CP * + * * + *-------------------------------------------------------------------------*/ +void +Prep_CP(void) +{ +#ifdef MAP_REG_CP + Inst_Printf("la", "%s,.Lcont%d", asm_reg_cp, w_label); /* CP = .Lcont%d */ +#else + Inst_Printf("la", "$13,.Lcont%d", w_label); + Inst_Printf("sw", "$13,%s", asm_reg_cp); /* CP = .Lcont%d */ +#endif +} + + + + +/*-------------------------------------------------------------------------* + * HERE_CP * + * * + *-------------------------------------------------------------------------*/ +void +Here_CP(void) +{ + Label_Printf(".Lcont%d:", w_label++); +} + + + + +/*-------------------------------------------------------------------------* + * PL_CALL * + * * + *-------------------------------------------------------------------------*/ +void +Pl_Call(char *label) +{ + Prep_CP(); + Pl_Jump(label); + Here_CP(); +} + + + + +/*-------------------------------------------------------------------------* + * PL_FAIL * + * * + *-------------------------------------------------------------------------*/ +void +Pl_Fail(void) +{ +#ifdef MAP_REG_B + Inst_Printf("lw", "$25,-4(%s)", asm_reg_b); +#else + Inst_Printf("lw", "$13,%s", asm_reg_b); + Inst_Printf("lw", "$25,-4($13)"); +#endif + Inst_Printf("jr", "$25"); +} + + + + +/*-------------------------------------------------------------------------* + * PL_RET * + * * + *-------------------------------------------------------------------------*/ +void +Pl_Ret(void) +{ + Inst_Printf(".align", "3"); + Inst_Printf("# nop", ""); /* I don't really know why, but it helps ;-) */ +#ifdef MAP_REG_CP + Inst_Printf("move", "$25,%s", asm_reg_cp); +#else + Inst_Printf("lw", "$25,%s", asm_reg_cp); +#endif + Inst_Printf("jr", "$25"); +} + + + + +/*-------------------------------------------------------------------------* + * JUMP * + * * + *-------------------------------------------------------------------------*/ +void +Jump(char *label) +{ + Inst_Printf("la", "$25,%s", label); + Inst_Printf("jr", "$25"); +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_FROM_REG_X * + * * + *-------------------------------------------------------------------------*/ +void +Move_From_Reg_X(int index) +{ + Inst_Printf("lw", "$24,%d(%s)", 4 * index, asm_reg_bank); /* asm_reg_bank */ +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_FROM_REG_Y * + * * + *-------------------------------------------------------------------------*/ +void +Move_From_Reg_Y(int index) +{ +#ifdef MAP_REG_E + Inst_Printf("lw", "$24,%d(%s)", Y_OFFSET(index), asm_reg_e); +#else + Inst_Printf("lw", "$13,%s", asm_reg_e); + Inst_Printf("lw", "$24,%d($13)", Y_OFFSET(index)); +#endif +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_TO_REG_X * + * * + *-------------------------------------------------------------------------*/ +void +Move_To_Reg_X(int index) +{ + Inst_Printf("sw", "$24,%d(%s)", 4 * index, asm_reg_bank); +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_TO_REG_Y * + * * + *-------------------------------------------------------------------------*/ +void +Move_To_Reg_Y(int index) +{ +#ifdef MAP_REG_E + Inst_Printf("sw", "$24,%d(%s)", Y_OFFSET(index), asm_reg_e); +#else + Inst_Printf("lw", "$13,%s", asm_reg_e); + Inst_Printf("sw", "$24,%d($13)", Y_OFFSET(index)); +#endif +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_START * + * * + *-------------------------------------------------------------------------*/ +void +Call_C_Start(char *fct_name, int fc, int nb_args, int nb_args_in_words, + char **p_inline) +{ + double_args = 0; + seen_int_arg = 0; + double_pad = 0; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_INT * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Int(int offset, long int_val) +{ + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + Inst_Printf("li", "$4,%d", int_val); + break; + case 1: + Inst_Printf("li", "$5,%d", int_val); + break; + case 2: + Inst_Printf("li", "$6,%d", int_val); + break; + case 3: + Inst_Printf("li", "$7,%d", int_val); + break; + default: + Inst_Printf("li", "$24,%d", int_val); + Inst_Printf("sw", "$24,%d($sp)", (offset + double_args + double_pad) * 4); + } + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_DOUBLE * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Double(int offset, double dbl_val) +{ + char buf[1024]; + + sprintf(buf, "\t.align 3\n.LD%d:\n\t.double %1.20e\n", w_label++, + dbl_val); + strcat(dbl_arg_buffer, buf); + Inst_Printf("la", "$24,.LD%d", (w_label - 1)); + if (!seen_int_arg && (double_args == 0 || double_args == 1)) + { + switch (offset) + { + case 0: + Inst_Printf("l.d", "$f12,($24)"); + break; + case 1: + Inst_Printf("l.d", "$f14,($24)"); + break; + default: + /* shall never happen */ + break; + } + } + else + { + if ((offset + double_args) & 1) + { + double_pad++; + } + Inst_Printf("l.d", "$f4,($24)"); + Inst_Printf("s.d", "$f4,%d($sp)", (offset + double_args + double_pad) * 4); + } + double_args++; + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_STRING * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_String(int offset, int str_no) +{ + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + Inst_Printf("la", "$4,%s%d", STRING_PREFIX, str_no); + break; + case 1: + Inst_Printf("la", "$5,%s%d", STRING_PREFIX, str_no); + break; + case 2: + Inst_Printf("la", "$6,%s%d", STRING_PREFIX, str_no); + break; + case 3: + Inst_Printf("la", "$7,%s%d", STRING_PREFIX, str_no); + break; + default: + Inst_Printf("la", "$24,%s%d", STRING_PREFIX, str_no); + Inst_Printf("sw", "$24,%d($sp)", (offset + double_args + double_pad) * 4); + } + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_MEM_L * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Mem_L(int offset, int adr_of, char *name, int index) +{ + char dest[8]; + + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + sprintf(dest, "%s", "$4"); + break; + case 1: + sprintf(dest, "%s", "$5"); + break; + case 2: + sprintf(dest, "%s", "$6"); + break; + case 3: + sprintf(dest, "%s", "$7"); + break; + default: + sprintf(dest, "%s", "$24"); + break; + } + + if (!adr_of) + { + Inst_Printf("la", "$25,%s", name); + Inst_Printf("lw", "%s,%d($25)", dest, index * 4); + } + else + { + Inst_Printf("la", "%s,%s+%d", dest, name, index * 4); + } + if ((offset + double_args) > 3) + { + Inst_Printf("sw", "%s,%d($sp)", dest, (offset + double_args + double_pad) * 4); + } + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_REG_X * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Reg_X(int offset, int adr_of, int index) +{ + char dest[8]; + + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + sprintf(dest, "%s", "$4"); + break; + case 1: + sprintf(dest, "%s", "$5"); + break; + case 2: + sprintf(dest, "%s", "$6"); + break; + case 3: + sprintf(dest, "%s", "$7"); + break; + default: + sprintf(dest, "%s", "$24"); + break; + } + + if (!adr_of) + { + Inst_Printf("lw", "%s,%d(%s)", dest, index * 4, asm_reg_bank); + } + else + { + if (index == 0) + { + Inst_Printf("move", "%s,%s", dest, asm_reg_bank); + } + else + { + Inst_Printf("la", "%s,%d(%s)", dest, index * 4, asm_reg_bank); + } + } + if ((offset + double_args) > 3) + { + Inst_Printf("sw", "%s,%d($sp)", dest, (offset + double_args + double_pad) * 4); + } + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_REG_Y * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Reg_Y(int offset, int adr_of, int index) +{ + char dest[8]; + + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + sprintf(dest, "%s", "$4"); + break; + case 1: + sprintf(dest, "%s", "$5"); + break; + case 2: + sprintf(dest, "%s", "$6"); + break; + case 3: + sprintf(dest, "%s", "$7"); + break; + default: + sprintf(dest, "%s", "$24"); + break; + } + + if (!adr_of) + { +#ifdef MAP_REG_E + Inst_Printf("lw", "%s,%d(%s)", dest, Y_OFFSET(index), asm_reg_e); +#else + Inst_Printf("lw", "$12,%s", asm_reg_e); + Inst_Printf("lw", "%s,%d($12)", dest, Y_OFFSET(index)); +#endif + } + else + { +#ifdef MAP_REG_E + Inst_Printf("la", "%s,%d(%s)", dest, Y_OFFSET(index), asm_reg_e); +#else + Inst_Printf("lw", "$12,%s", asm_reg_e); + Inst_Printf("la", "%s,%d($12)", dest, Y_OFFSET(index)); +#endif + } + if ((offset + double_args) > 3) + { + Inst_Printf("sw", "%s,%d($sp)", dest, (offset + double_args + double_pad) * 4); + } + + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_FOREIGN_L * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Foreign_L(int offset, int adr_of, int index) +{ + char dest[8]; + + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + sprintf(dest, "%s", "$4"); + break; + case 1: + sprintf(dest, "%s", "$5"); + break; + case 2: + sprintf(dest, "%s", "$6"); + break; + case 3: + sprintf(dest, "%s", "$7"); + break; + default: + sprintf(dest, "%s", "$24"); + break; + } + + Inst_Printf("la", "$2,foreign_long"); + if (!adr_of) + { + Inst_Printf("lw", "%s,%d($2)", dest, index * 4); + } + else + { + Inst_Printf("la", "%s,%d($2)", dest, index * 4); + } + if ((offset + double_args) > 3) + { + Inst_Printf("sw", "%s,%d($sp)", dest, (offset + double_args + double_pad) * 4); + } + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_ARG_FOREIGN_D * + * * + *-------------------------------------------------------------------------*/ +int +Call_C_Arg_Foreign_D(int offset, int adr_of, int index) +{ + char *dest; + + if (adr_of) + { + seen_int_arg = 1; + + switch (offset + double_args) + { + case 0: + dest = "$4"; + break; + case 1: + dest = "$5"; + break; + case 2: + dest = "$6"; + break; + case 3: + dest = "$7"; + break; + default: + dest = "$24"; + break; + } + Inst_Printf("la", "%s,foreign_double", dest); + Inst_Printf("addu", "%s,%d", dest, index * 8); + if ((offset + double_args) > 3) + { + Inst_Printf("sw", "%s,%d($sp)", dest, (offset + double_args + double_pad) * 4); + } + } + else + { + Inst_Printf("la", "$24,foreign_double"); + if (!seen_int_arg && (double_args == 0 || double_args == 1)) + { + switch (offset) + { + case 0: + dest = "$f12"; + break; + case 1: + dest = "$f14"; + break; + default: + /* shall never happen */ + break; + } + Inst_Printf("l.d", "%s,%d($24)", dest, index * 8); + } + else + { + dest = "$f4"; + Inst_Printf("l.d", "%s,%d($24)", dest, index * 8); + if ((offset + double_args) & 1) + { + double_pad++; + } + Inst_Printf("s.d", "%s,%d($sp)", dest, (offset + double_args + double_pad) * 4); + } + double_args++; + } + return 1; +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_INVOKE * + * * + *-------------------------------------------------------------------------*/ +void +Call_C_Invoke(char *fct_name, int fc, int nb_args, int nb_args_in_words) +{ +/* if (!make_inline (fct_name, nb_args)) { */ + Inst_Printf("sw", "$gp,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 4); + Inst_Printf("sw", "$31,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 0); + Inst_Printf("la", "$25,%s", fct_name); + Inst_Printf("jalr", "$25"); + Inst_Printf("lw", "$gp,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 4); + Inst_Printf("lw", "$31,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 0); +/* } */ +} + + + + +/*-------------------------------------------------------------------------* + * CALL_C_STOP * + * * + *-------------------------------------------------------------------------*/ +void +Call_C_Stop(char *fct_name, int nb_args, char **p_inline) +{ +} + + + + +/*-------------------------------------------------------------------------* + * JUMP_RET * + * * + *-------------------------------------------------------------------------*/ +void +Jump_Ret(void) +{ + Inst_Printf("move", "$25,$2"); + Inst_Printf("jr", "$25"); +} + + + + +/*-------------------------------------------------------------------------* + * FAIL_RET * + * * + *-------------------------------------------------------------------------*/ +void +Fail_Ret(void) +{ + Inst_Printf("bne", "$2,$0,.Lcont%d", w_label); + Pl_Fail(); + Label_Printf(".Lcont%d:", w_label++); +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_RET_TO_MEM_L * + * * + *-------------------------------------------------------------------------*/ +void +Move_Ret_To_Mem_L(char *name, int index) +{ + Inst_Printf("la", "$13,%s", name); + Inst_Printf("sw", "$2,%d($13)", index * 4); +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_RET_TO_REG_X * + * * + *-------------------------------------------------------------------------*/ +void +Move_Ret_To_Reg_X(int index) +{ /* same as Move_To_Reg_X */ + Inst_Printf("sw", "$2,%d(%s)", index * 4, asm_reg_bank); +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_RET_TO_REG_Y * + * * + *-------------------------------------------------------------------------*/ +void +Move_Ret_To_Reg_Y(int index) +{ /* same as Move_To_Reg_Y */ +#ifdef MAP_REG_E + Inst_Printf("sw", "$2,%d(%s)", Y_OFFSET(index), asm_reg_e); +#else + Inst_Printf("lw", "$13,%s", asm_reg_e); + Inst_Printf("sw", "$2,%d($13)", Y_OFFSET(index)); +#endif +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_RET_TO_FOREIGN_L * + * * + *-------------------------------------------------------------------------*/ +void +Move_Ret_To_Foreign_L(int index) +{ + Inst_Printf("la", "$13,foreign_long"); + Inst_Printf("sw", "$2,%d($13)", index * 4); +} + + + + +/*-------------------------------------------------------------------------* + * MOVE_RET_TO_FOREIGN_D * + * * + *-------------------------------------------------------------------------*/ +void +Move_Ret_To_Foreign_D(int index) +{ + Inst_Printf("la", "$13,foreign_double"); + Inst_Printf("s.d", "$f0,%d($13)", index * 8); +} + + + + +/*-------------------------------------------------------------------------* + * CMP_RET_AND_INT * + * * + *-------------------------------------------------------------------------*/ +void +Cmp_Ret_And_Int(long int_val) +{ + Inst_Printf("li", "$24,%d", int_val); + Inst_Printf("sub", "$12,$2,$24"); /* $2 - $24 -> $12 */ +} + + + + +/*-------------------------------------------------------------------------* + * JUMP_IF_EQUAL * + * * + *-------------------------------------------------------------------------*/ +void +Jump_If_Equal(char *label) +{ + Inst_Printf("beqz", "$12,%s", label); /* $12 == 0 */ +} + + + + +/*-------------------------------------------------------------------------* + * JUMP_IF_GREATER * + * * + *-------------------------------------------------------------------------*/ +void +Jump_If_Greater(char *label) +{ + Inst_Printf("bgtz", "$12,%s", label); /* $12 > 0 */ +} + + + + +/*-------------------------------------------------------------------------* + * C_RET * + * * + *-------------------------------------------------------------------------*/ +void +C_Ret(void) +{ + Inst_Printf("lw", "$gp,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 4); + Inst_Printf("lw", "$31,%d($sp)", MAX_C_ARGS_IN_C_CODE * 4 + 0); + Inst_Printf("addiu", "$sp,%d", MAX_C_ARGS_IN_C_CODE * 4 + 16); + Inst_Printf("jr", "$31"); +} + + + + +/*-------------------------------------------------------------------------* + * DICO_STRING_START * + * * + *-------------------------------------------------------------------------*/ +void +Dico_String_Start(int nb_consts) +{ + Label_Printf(".section\t.rodata"); + Inst_Printf(".align", "3"); +} + + + + +/*-------------------------------------------------------------------------* + * DICO_STRING * + * * + *-------------------------------------------------------------------------*/ +void +Dico_String(int str_no, char *asciiz) +{ + + Label_Printf("%s%d:", STRING_PREFIX, str_no); + Inst_Printf(".ascii", "%s", asciiz); +} + + + + +/*-------------------------------------------------------------------------* + * DICO_STRING_STOP * + * * + *-------------------------------------------------------------------------*/ +void +Dico_String_Stop(int nb_consts) +{ +} + + + + +/*-------------------------------------------------------------------------* + * DICO_LONG_START * + * * + *-------------------------------------------------------------------------*/ +void +Dico_Long_Start(int nb_longs) +{ + Label_Printf(".section\t.sdata"); + Inst_Printf(".align", "3"); +} + + + + +/*-------------------------------------------------------------------------* + * DICO_LONG * + * * + *-------------------------------------------------------------------------*/ +void +Dico_Long(char *name, int global, VType vtype, long value) +{ + switch (vtype) + { + case NONE: + value = 1; /* then in case ARRAY_SIZE */ + case ARRAY_SIZE: + Label_Printf(".section\t.bss"); + if (!global) + { + Label_Printf("%s:", name); + Inst_Printf(".align", "3"); + Inst_Printf(".space", "%d", value * 4); + /* Inst_Printf(".popsection",""); */ + } + else + { + Inst_Printf(".comm", "%s,%d", name, value * 4); + } + break; + + case INITIAL_VALUE: + Label_Printf(".section\t.rodata"); + if (global) + { + Inst_Printf(".globl", "%s", name); + Inst_Printf(".align", "3"); + Inst_Printf(".size", "%s,4", name); + Label_Printf("%s:", name); + Inst_Printf(".word", "%d", value); + } + else + { + Inst_Printf(".align", "3"); + Inst_Printf(".size", "%s,4", name); + Label_Printf("%s:", name); + Inst_Printf(".word", "%d", value); + } + break; + } +} + + + + +/*-------------------------------------------------------------------------* + * DICO_LONG_STOP * + * * + *-------------------------------------------------------------------------*/ +void +Dico_Long_Stop(int nb_longs) +{ +} + + + + +/*-------------------------------------------------------------------------* + * DATA_START * + * * + *-------------------------------------------------------------------------*/ +void +Data_Start(char *initializer_fct) +{ + /* last routine has to be closed first */ + if (act_routine[0] != '\0') + { + Inst_Printf("jr", "$31"); + Inst_Printf(".end", "%s", act_routine); + + act_routine[0] = '\0'; + } + + if (initializer_fct == NULL) + return; + + Inst_Printf(".section", ".ctors,\"aw\",@progbits"); + Inst_Printf(".word", "%s", initializer_fct); +} + + + + +/*-------------------------------------------------------------------------* + * DATA_STOP * + * * + *-------------------------------------------------------------------------*/ +void +Data_Stop(char *initializer_fct) +{ +} --- gprolog-1.3.0.orig/src/TopComp/top_comp.c +++ gprolog-1.3.0/src/TopComp/top_comp.c @@ -878,8 +878,12 @@ Find_File(char *file, char *suff, char * sprintf(name, "%s%s", file, suff); if (!devel_mode) { +#ifdef DEBIAN + sprintf(file_path, PROLOG_LIBDIR "/%s", name); +#else sprintf(file_path, "%s" DIR_SEP_S "lib" DIR_SEP_S "%s", start_path, name); +#endif if (access(file_path, F_OK) == 0) return; } --- gprolog-1.3.0.orig/src/TopComp/prolog_path.c +++ gprolog-1.3.0/src/TopComp/prolog_path.c @@ -201,6 +201,12 @@ Search_Path(char *file) int l; static char buff[MAXPATHLEN]; +#ifdef PROLOG_BINDIR + sprintf (buff, PROLOG_BINDIR DIR_SEP_S "%s", file); + if (access (buff, X_OK) == 0) + return buff; +#endif + if (path == NULL) return NULL; --- /dev/null +++ gprolog-1.3.0/src/Win32/gp-setup.iss @@ -0,0 +1,65 @@ +; GNU Prolog WIN32 installation script for Inno Setup 4 + +[Setup] +AppName=GNU Prolog +AppVerName=GNU Prolog version 1.3.0 +AppVersion=1.3.0 +AppPublisher=Daniel Diaz +AppPublisherURL=http://www.gprolog.org +AppSupportURL=http://www.gprolog.org +AppUpdatesURL=http://www.gprolog.org +DefaultDirName={sd}\GNU-Prolog +DefaultGroupName=GNU Prolog +AllowNoIcons=yes +SourceDir=\gprolog_win32 +OutputDir= +OutputBaseFileName=setup-gprolog-1.3.0 + +; TO DO: create an association for .pl and .pro files +; ChangesAssociations=yes + +; uncomment the following line if you want your installation to run on NT 3.51 too. +; MinVersion=4,3.51 + +[Tasks] +Name: "desktopicon"; Description: "Create a &desktop icon"; GroupDescription: "Additional icons:"; MinVersion: 4,4 + +[Files] +Source: "*.*"; DestDir: "{app}"; Flags: ignoreversion +Source: "bin\*.*"; DestDir: "{app}\bin"; Flags: ignoreversion +Source: "lib\*.*"; DestDir: "{app}\lib"; Flags: ignoreversion +Source: "lib\*.dll"; DestDir: "{app}\bin"; Flags: ignoreversion skipifsourcedoesntexist +Source: "include\*.*"; DestDir: "{app}\include"; Flags: ignoreversion +Source: "doc\*.*"; DestDir: "{app}\doc"; Flags: ignoreversion +Source: "doc\html_node\*.*"; DestDir: "{app}\doc\html_node"; Flags: ignoreversion +Source: "ExamplesPl\*.*"; DestDir: "{app}\ExamplesPl"; Flags: ignoreversion +Source: "ExamplesFD\*.*"; DestDir: "{app}\ExamplesFD"; Flags: ignoreversion +Source: "ExamplesC\*.*"; DestDir: "{app}\ExamplesC"; Flags: ignoreversion + +[INI] +Filename: "{app}\gprolog.url"; Section: "InternetShortcut"; Key: "URL"; String: "http://www.gprolog.org" + +[Icons] +Name: "{group}\GNU Prolog"; Filename: "{app}\bin\gprolog.exe" +Name: "{group}\Help"; Filename: "{app}\doc\manual.chm" +Name: "{group}\Html Manual"; Filename: "{app}\doc\html_node\index.html" +Name: "{group}\The GNU Prolog Web Site"; Filename: "{app}\gprolog.url" +Name: "{group}\Uninstall GNU Prolog"; Filename: "{uninstallexe}" + +Name: "{userdesktop}\GNU Prolog"; Filename: "{app}\bin\gprolog.exe"; MinVersion: 4,4; Tasks: desktopicon + +[Registry] +Root: HKCU; Subkey: "Software\GnuProlog"; ValueType: string; ValueName: "Version"; ValueData: "1.3.0" +Root: HKCU; Subkey: "Software\GnuProlog"; ValueType: string; ValueName: "RootPath"; ValueData: "{app}" + +[Run] +Filename: "{app}\bin\create_bat.exe"; Parameters: """{sd}"" ""{app}"" install"; Description: "Create {sd}\gprologvars.bat and update autoexec.bat" +Filename: "{app}\bin\gprolog.exe"; Description: "Launch GNU Prolog"; Flags: nowait postinstall skipifsilent + +[UninstallRun] +Filename: "{app}\bin\create_bat.exe"; Parameters: """{sd}"" ""{app}"" uninstall" + +[UninstallDelete] +Type: files; Name: "{app}\gprolog.url" + + --- gprolog-1.3.0.orig/src/EnginePl/engine.h +++ gprolog-1.3.0/src/EnginePl/engine.h @@ -60,7 +60,7 @@ int os_argc; char **os_argv; -char glob_buff[10240]; +char glob_buff[1024*1024]; /* FIXME: 1M is better than 10K */ long *base_fl; /* overwritten by foreign if present */ double *base_fd; /* overwritten by foreign if present */ --- gprolog-1.3.0.orig/src/EnginePl/wam_archi.def +++ gprolog-1.3.0/src/EnginePl/wam_archi.def @@ -107,10 +107,10 @@ typedef WamWord *WamWordP; @begin stacks -@stack trail 3072 TR /* Trail stack */ -@stack cstr 3072 CS /* Constraint stack */ -@stack global 8192 H /* Global stack */ -@stack local 4096 Local_Top /* Local stack (after global) */ +@stack trail 16384 TR /* Trail stack */ +@stack cstr 8192 CS /* Constraint stack */ +@stack global 32768 H /* Global stack */ +@stack local 8192 Local_Top /* Local stack (after global) */ @end stacks --- gprolog-1.3.0.orig/src/EnginePl/machine1.c +++ gprolog-1.3.0/src/EnginePl/machine1.c @@ -482,6 +482,12 @@ M_Spawn(char *arg[]) if (pid == 0) /* child process */ { +#ifdef DEBIAN + char exec_path[MAXPATHLEN]; + + sprintf (exec_path, "%s/%s", PROLOG_BINDIR, arg[0]); + execv(exec_path, arg); /* ignore error... */ +#endif execvp(arg[0], arg); /* only returns on error */ exit((errno == ENOENT || errno == ENOTDIR) ? 126 : 127); } @@ -544,6 +550,10 @@ M_Spawn_Redirect(char *arg[], int detach { if (!detach || fork() == 0) /* pid needed ? */ { /* nested fork to detach exec process to avoid zombie process */ +#ifdef DEBIAN + char exec_path[MAXPATHLEN]; +#endif + if (f_in && (close(pipe_in[1]) || (pipe_in[0] != 0 && (dup2(pipe_in[0], 0) == -1 || close(pipe_in[0]))))) @@ -568,6 +578,10 @@ M_Spawn_Redirect(char *arg[], int detach goto err; } +#ifdef DEBIAN + sprintf (exec_path, "%s/%s", PROLOG_BINDIR, arg[0]); + execv(exec_path, arg); /* ignore error... */ +#endif execvp(arg[0], arg); /* only returns on error */ #ifdef DEBUG DBGPRINTF("ERROR EXEC errno=%d\n", errno); --- gprolog-1.3.0.orig/src/EnginePl/gp_config.h.in +++ gprolog-1.3.0/src/EnginePl/gp_config.h.in @@ -73,7 +73,9 @@ /* Define if you don't want to include the FD constraint solver */ #undef NO_USE_FD_SOLVER - +/* Define if you want to use the foreign destructor in choicepoint functions */ +#undef USE_WATERMARK + /* Define if the cpu is a mips */ @@ -126,6 +128,9 @@ /* Define if the system is an mips/irix */ #undef M_mips_irix +/* Define if the system is an mips/linux */ +#undef M_mips_linux + /* Define if the system is an alpha/linux */ #undef M_alpha_linux @@ -186,6 +191,8 @@ #define PROLOG_VERSION any #define PROLOG_DATE any #define PROLOG_COPYRIGHT any +#define PROLOG_BINDIR any +#define PROLOG_LIBDIR any #define TOP_LEVEL any #define GPLC any --- gprolog-1.3.0.orig/src/EnginePl/machine.c +++ gprolog-1.3.0/src/EnginePl/machine.c @@ -389,7 +389,7 @@ M_Allocate_Stacks(void) } #if defined(M_sparc_solaris) || defined(M_ix86_solaris) || \ - defined(M_ix86_sco) || defined(M_x86_64_linux) + defined(M_ix86_sco) || defined(M_mips_linux) || defined(M_x86_64_linux) { struct sigaction act; @@ -452,7 +452,6 @@ SIGSEGV_Handler(int sig, int code, struc #elif defined(M_ix86_linux) || defined(M_powerpc_linux) || \ defined(M_alpha_linux) -#include #if 0 /* old linux */ static void @@ -482,6 +481,10 @@ SIGSEGV_Handler(WamWord *addr) void SIGSEGV_Handler(int sig, int code, struct sigcontext *scp) +#elif defined(M_mips_linux) +void +SIGSEGV_Handler(int sig, siginfo_t *sip, void *scp) + #elif defined(M_x86_64_linux) void SIGSEGV_Handler(int sig, siginfo_t *sip, void *scp) @@ -509,6 +512,10 @@ SIGSEGV_Handler(int sig) WamWord *addr = (WamWord *) scp.cr2; +#elif defined(M_mips_linux) + + WamWord *addr = (WamWord *) sip->si_addr; + #elif defined(M_x86_64_linux) WamWord *addr = (WamWord *) sip->si_addr; --- gprolog-1.3.0.orig/src/EnginePl/wam_inst.h +++ gprolog-1.3.0/src/EnginePl/wam_inst.h @@ -517,8 +517,58 @@ long chain_len; +#ifndef USE_WATERMARK + +/* -- regular GNU Prolog w/o watermark code -------------------------------- */ + +#define Call_CP_Destructors(b) 0 +#define Create_Water_Mark(a,b) +#define Update_Water_Mark(a,b) + #define Assign_B(newB) (B = (newB), HB1 = HB(B)) +#else /* USE_WATERMARK defined: */ +#ifndef FRAMES_ONLY + +/* -- support for watermarks ----------------------------------------------- */ + +#define Assign_B(newB) (B = (newB), HB1 = HB(B), Call_CP_Destructors(B)) + +#ifndef MAXWMARK /* Number of active watermarks */ +#define MAXWMARK 10240 /* ie. pending destructors */ +#endif + +typedef struct Watermark { /* A watermark on the stack: */ + WamWord *Bvalue; /* Choice-point */ + void (*destructor) (void *); /* Function to call */ + void *parameter; /* parameter to above */ +} Watermark, *WatermarkP; + +extern int wmark_count; /* number of active watermarks */ +extern Watermark wmark[]; /* The stack of watermarks */ +extern WatermarkP wmp; /* Top of watermark stack */ + +static inline WamWord *Call_CP_Destructors (WamWord *TargetB) +{ + while ((wmark_count > 0) && (TargetB < wmp->Bvalue)) { + (*wmp->destructor) (wmp->parameter); + +#ifdef DEBUG + fprintf (stderr,"xgoing up: WM%d %d LT%d\n",WMark[Wqty],Wqty,Local_Top); +#endif + --wmp; + --wmark_count; + } + return TargetB; +} + +void Create_Water_Mark (void (*fun)(), void *par); +void Update_Water_Mark (void (*fun)(), void *par); + +/* ------------------------------------------------------------------------- */ +#endif /* FRAMES_ONLY */ +#endif /* USE_WATERMARK */ + #define Delete_Last_Choice_Point() Assign_B(BB(B)) --- gprolog-1.3.0.orig/src/EnginePl/engine1.c +++ gprolog-1.3.0/src/EnginePl/engine1.c @@ -75,7 +75,7 @@ Call_Compiled(CodePtr codep) _asm mov ebx, reg_bank -#elif defined(M_mips_irix) +#elif defined(M_mips) register WamWord *rb asm("$16") = reg_bank; ensure_reserved = (WamWord *) rb; /* to avoid gcc warning */ --- gprolog-1.3.0.orig/src/EnginePl/wam_inst.c +++ gprolog-1.3.0/src/EnginePl/wam_inst.c @@ -1140,6 +1140,49 @@ Switch_On_Structure(SwtTbl t, int size) } +#ifdef USE_WATERMARK + +/*-------------------------------------------------------------------------*/ +/* CREATE_WATER_MARK */ +/* */ +/* Request warning if backtracking is not complete. */ +/*-------------------------------------------------------------------------*/ + +int wmark_count = 0; /* number of active watermarks */ +Watermark wmark[MAXWMARK]; /* The stack of watermarks */ +WatermarkP wmp = wmark-1; /* Top of watermark stack */ + +void Create_Water_Mark (void (*fun)(), void *par) +{ + if (++wmark_count >= MAXWMARK) { + Fatal_Error ("Watermark stack size (%d) exceeded! - aborting", MAXWMARK); + } + ++wmp; + wmp->Bvalue = B; + wmp->destructor = fun; + wmp->parameter = par; + +#ifdef DEBUG + fprintf(stderr,"Water Mark at: %d Position: %d %dB %dBB(B)\n",B,Wqty,WMark[Wqty],BB(B)); +#endif +} + +void Update_Water_Mark (void (*fun)(), void *par) +{ + if (wmark_count > 0) { + wmp->destructor = fun; + wmp->parameter = par; + } + else { + fprintf(stderr, "Update_Water_Mark called with empty stack!\n"); + } +#ifdef DEBUG + fprintf(stderr,"Water Mark at: %d Position: %d %dB %dBB(B)\n",B,Wqty,WMark[Wqty],BB(B)); +#endif +} +#endif /* USE_WATERMARK */ + + /*-------------------------------------------------------------------------* --- gprolog-1.3.0.orig/src/BipsPl/b_params.h +++ gprolog-1.3.0/src/BipsPl/b_params.h @@ -26,6 +26,6 @@ #define MAX_VAR_NAME_LENGTH 256 -#define MAX_VAR_IN_TERM 2048 +#define MAX_VAR_IN_TERM 16384 #define MAX_SYS_VARS 256 --- gprolog-1.3.0.orig/src/BipsPl/format_c.c +++ gprolog-1.3.0/src/BipsPl/format_c.c @@ -74,7 +74,7 @@ Format_3(WamWord sora_word, WamWord form int stm; StmInf *pstm; char *str; - char buff[2048]; + char buff[64*1024]; /* FIXME: manually increased from 2K */ stm = (sora_word == NOT_A_WAM_WORD) @@ -134,7 +134,7 @@ Format(StmInf *pstm, char *format, WamWo int i, k; char *format_stack[256]; char **top_stack = format_stack; - char buff[2048]; + char buff[64*1024]; /* FIXME: manually increased from 2K */ *top_stack++ = format; --- gprolog-1.3.0.orig/src/BipsPl/stream_supp.c +++ gprolog-1.3.0/src/BipsPl/stream_supp.c @@ -1484,13 +1484,27 @@ int Stream_Printf(StmInf *pstm, char *format, ...) { va_list arg_ptr; - static char str[BIG_BUFFER]; + int strmax = 128*1024; /* FIXME: up(?) from BIG_BUFFER */ + char *str = alloca (strmax); + int nchars; char *p; int c; va_start(arg_ptr, format); - vsprintf(str, format, arg_ptr); + for (;;) { + nchars = vsnprintf(str, strmax, format, arg_ptr); + if (nchars < 0) { /* doesn't fit & old vsnprintf */ + strmax *= 2; /* just returns -1: */ + str = alloca (strmax); /* grab more space (double it) and retry */ + } + else if (nchars >= strmax) { /* doesn't fit & new vsnprintf */ + strmax = nchars+1; /* nchars is needed size (minus 1) */ + str = alloca (strmax); /* grab all that's needed and retry */ + } + else + break; /* it fits: leave it at that */ + } va_end(arg_ptr); for (p = str; *p; p++) --- gprolog-1.3.0.orig/doc/intro.tex +++ gprolog-1.3.0/doc/intro.tex @@ -22,7 +22,7 @@ executables at link-time. A lot of work has been devoted to the ISO compatibility. Indeed, GNU Prolog is very close to the -\MyUrl{http://www.logic-programming.org/prolog\_std.html}{ISO standard for +\MyUrl{http://www.cs.kuleuven.ac.be/~dtai/projects/ALP/}{ISO standard for Prolog} \cite{iso-part1}. GNU Prolog also offers various extensions very useful in practice (global --- gprolog-1.3.0.orig/doc/Makefile +++ gprolog-1.3.0/doc/Makefile @@ -55,14 +55,14 @@ all: dvi pdf ps html chm dvi: $(DVINAME) $(DVINAME): $(TEX_SRC) compil-scheme.eps debug-box.eps - do_latex -dvi $(TRACE) $(MAIN) + ./do_latex -dvi $(TRACE) $(MAIN) pdf: $(PDFNAME) $(PDFNAME): $(TEX_SRC) compil-scheme.pdf debug-box.pdf - do_latex -pdf $(TRACE) $(MAIN) + ./do_latex -pdf $(TRACE) $(MAIN) ps: $(PSNAME) --- gprolog-1.3.0.orig/doc/use.tex +++ gprolog-1.3.0/doc/use.tex @@ -998,7 +998,7 @@ arithmetics) \\ \IdxKD{--min-bips} & shorthand for: \texttt{--no-top-level} \texttt{--min-pl-bips} \texttt{--min-fd-bips} \\ -\IdxKD{--min-size} & shorthand² for: \texttt{--min-bips} \texttt{--strip} \\ +\IdxKD{--min-size} & shorthand for: \texttt{--min-bips} \texttt{--strip} \\ \IdxKD{--no-fd-lib} & do not look for the FD library (maintenance only) \\ debian/patches/series0000644000000000000000000000005411350006364012027 0ustar 10-latex-fix.patch debian-changes-1.3.0-6.1 debian/patches/10-latex-fix.patch0000644000000000000000000000341011350006220013740 0ustar From 2e6e123c3289f55370072c7fe3f9e11402fe0006 Mon Sep 17 00:00:00 2001 From: Jari Aalto Date: Wed, 17 Mar 2010 00:55:58 +0200 Subject: [PATCH] rename 'pdf' variable to 'pdfgprolog' by Ilya Barygin Organization: Private Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Signed-off-by: Jari Aalto --- doc/macros.tex | 4 ++-- doc/packages.tex | 10 +++++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/doc/macros.tex b/doc/macros.tex index ebf774f..3fa342d 100644 --- a/doc/macros.tex +++ b/doc/macros.tex @@ -81,7 +81,7 @@ % Url in LaTeX output -\ifpdf +\ifpdfgprolog \newcommand{\Tilde}[1]{~#1} \newcommand{\MyUrl}[2]{\href{#1}{#2}} \newcommand{\MyUrlHtml}[2]{\href{#1}{#2}} @@ -237,7 +237,7 @@ % |textbf does not seem to work with hyperref (pdflatex)... remove it -\ifpdf +\ifpdfgprolog \newcommand{\IndexBold}[1]{\index{#1}} \else \newcommand{\IndexBold}[1]{\index{#1|textbf}} diff --git a/doc/packages.tex b/doc/packages.tex index 749cd32..96c01f1 100644 --- a/doc/packages.tex +++ b/doc/packages.tex @@ -1,11 +1,11 @@ -\newif\ifpdf +\newif\ifpdfgprolog \ifx\pdfoutput\undefined - \pdffalse % we are not running PDFLaTeX + \pdfgprologfalse % we are not running PDFLaTeX \else \ifnum\pdfoutput=0 - \pdffalse % we are not running PDFLaTeX + \pdfgprologfalse % we are not running PDFLaTeX \else - \pdfoutput=1 \pdftrue % we are running PDFLaTeX + \pdfoutput=1 \pdfgprologtrue % we are running PDFLaTeX \fi \fi @@ -19,7 +19,7 @@ \usepackage{makeidx} \usepackage{ifthen} \usepackage{fancyhdr} -\ifpdf +\ifpdfgprolog \usepackage[pdftex]{graphicx} \usepackage[pdftex=true]{hyperref} \hypersetup{% -- 1.7.0 debian/gprolog.docs0000644000000000000000000000002511350005224011476 0ustar NEWS README PROBLEMS debian/rules0000755000000000000000000002100311350005224010232 0ustar #! /usr/bin/make -f # $Id: rules,v 1.9 2003/03/22 10:12:21 spa Exp $ # ============================================================================= # debian/rules for the GNU Prolog packages: # architecture-dependant package (gprolog-doc), # architecture-independent package (gprolog). # # Written by Salvador Abreu based on the template in # /usr/share/doc/debhelper/examples/rules.multi, with the following header: # ============================================================================= # # Sample debian/rules that uses debhelper. # This file is public domain software, originally written by Joey Hess. # SHELL=/bin/sh # may be iso, cx... variant=iso LIBDIR=/usr/lib/gprolog-$(variant) ifeq ($(variant),iso) PACKAGE = gprolog DOCDIR = /usr/share/doc/gprolog-doc else PACKAGE = gprolog-$(variant) DOCDIR = /usr/share/doc/gprolog-$(variant)-doc endif version=$(shell pwd | sed -e 's;.*/;;' -e 's;gprolog-;;') SRCDIR=src DBGFLAGS=-g DBGFLAGS=-O3 -fomit-frame-pointer BCFLAGS=-funsigned-char # ============================================================================= CPPFLAGS = \ -DDEBIAN CONFOPTIONS = \ --prefix=/usr \ --bindir=$(LIBDIR)/bin \ --libdir=$(LIBDIR) \ --includedir=$(LIBDIR)/include \ --with-doc-dir=$(DOCDIR) \ --with-html-dir=$(DOCDIR)/gprolog.html \ --with-examples-dir=$(DOCDIR)/examples \ --with-c-flags="$(DBGFLAGS) $(BCFLAGS) -Wall $(CPPFLAGS)" \ --without-links \ --without-ebp \ --disable-regs \ --enable-watermark INSTALLDIRS = \ INSTALL_DIR=$(CURDIR)/debian/$(PACKAGE)$(LIBDIR) \ INSTALL_BIN=$(CURDIR)/debian/$(PACKAGE)$(LIBDIR)/bin \ INSTALL_LIB=$(CURDIR)/debian/$(PACKAGE)$(LIBDIR) \ INSTALL_INC=$(CURDIR)/debian/$(PACKAGE)$(LIBDIR)/include \ DOC_DIR=$(CURDIR)/debian/$(PACKAGE)-doc$(DOCDIR) \ HTML_DIR=$(CURDIR)/debian/$(PACKAGE)-doc$(DOCDIR)/gprolog.html \ EXAMPLES_DIR=$(CURDIR)/debian/$(PACKAGE)-doc$(DOCDIR)/examples ROOT = $(shell pwd) SRCPATH = $(ROOT)/src SRCXDIRS = TopComp EnginePl Pl2Wam Wam2Ma Ma2Asm Fd2C DevUtils SRCXPATH := $(foreach dir,$(SRCXDIRS),$(SRCPATH)/$(dir):) SRCXPATH := $(shell echo $(SRCXPATH) | tr -d ' ') PATH = $(SRCXPATH):/usr/bin:/bin PL_PATH = ${CURDIR}/src CC = gcc # == build binaries and documentation ========================================= build: build-indep build-arch stamp-config: config config: dh_testdir # ----------------------------------------------------------------------------- ( PATH=${PATH}; \ if [ ! -f $(SRCDIR)/Makefile -o \ ! -f $(SRCDIR)/configure -o \ $(SRCDIR)/Makefile.in -nt $(SRCDIR)/Makefile ]; then \ cd $(SRCDIR); \ rm -f config.sub config.guess; \ cp /usr/share/misc/config.sub .; \ cp /usr/share/misc/config.guess .; \ autoconf && \ CC=$(CC) CPPFLAGS="${CPPFLAGS}" ./configure $(CONFOPTIONS); fi ) # ----------------------------------------------------------------------------- touch stamp-config build-indep: stamp-build-indep stamp-build-indep: stamp-config dh_testdir # -- commands to configure and build the package ------------------------------ PATH=${PATH} make -C doc pdf html # ----------------------------------------------------------------------------- touch stamp-build-indep build-arch: stamp-build-arch stamp-build-arch: stamp-config dh_testdir # -- commands to configure and build the package ------------------------------ # fix up the time stamp on generated files in the Debian diff, # which can't be regenerated during build w/o a tool that depends # on them! if [ -f src/BipsPl/arith_inl.wam ]; then \ touch src/BipsPl/arith_inl.wam; \ fi PATH=${PATH} PL_PATH=${PL_PATH} make -C $(SRCDIR) # ----------------------------------------------------------------------------- touch stamp-build-arch # == clean up everything ====================================================== clean: clean: stamp-config dh_testdir dh_testroot rm -f stamp-build-arch stamp-build-indep stamp-config # -- commands to clean up after the build process ----------------------------- set -e; PATH=${PATH} make -C $(SRCDIR) distclean rm -rf $(SRCDIR)/autom4te.cache rm -f $(SRCDIR)/config.sub $(SRCDIR)/config.guess # -- now, get rid of some more generated files -------------------------------- set -e; \ find -name Makefile -o -name configure | \ while read FILE; do \ if [ -f "$$FILE.in" ]; then rm -f "$$FILE"; fi; done find src -name VERSION | xargs -r rm -f rm -rf src/autom4te.cache # -- make sure all *.wam files are more recent than *.pl ---------------------- find src -name \*.wam | xargs touch # -- clean up docs ------------------------------------------------------------ make -C doc clean-full find doc -name \*.pdf | xargs -r rm -f find doc -name \*.hh[ck] | xargs -r rm -f find doc -name \*.hrf | xargs -r rm -f find doc -name \*.fp | xargs -r rm -f find doc -name manual\*.html | xargs -r rm -f # -- clean up examples -------------------------------------------------------- ls -d src/Examples* | while read DIR; do \ if [ -f $$DIR/Makefile ]; then \ make -C "$$DIR" clean; \ fi; \ done # ----------------------------------------------------------------------------- dh_clean # == arch-dependent installation ============================================== install-arch: install-arch: build-arch dh_testdir dh_testroot dh_clean -k dh_installdirs -A # -- install the package into the staging area -------------------------------- make -C $(SRCDIR) $(INSTALLDIRS) install-system # -- create gprolog-$(variant) etc, links in /usr/bin ------------------------- mkdir -p debian/$(PACKAGE)/usr/bin/ for PROG in gplc gprolog hexgplc; do \ ln -sf ../lib/gprolog-$(variant)/bin/$$PROG \ debian/$(PACKAGE)/usr/bin/$$PROG-$(variant); \ done # -- Install manpages --------------------------------------------------------- mkdir -p debian/$(PACKAGE)/usr/share/man/man1/ cat debian/manpage | \ sed -e "s/@PACKAGE@/$(PACKAGE)/g" | \ gzip -9 > debian/$(PACKAGE)/usr/share/man/man1/$(PACKAGE).1.gz for CMD in gplc hexgplc pl2wam wam2ma ma2asm fd2c; do \ ln -sf $(PACKAGE).1.gz \ debian/$(PACKAGE)/usr/share/man/man1/$$CMD.1.gz; \ done for CMD in gplc gprolog hexgplc; do \ ln -sf $(PACKAGE).1.gz \ debian/$(PACKAGE)/usr/share/man/man1/$$CMD-$(variant).1.gz; \ done # -- Install auxiliary stuff -------------------------------------------------- mkdir -p debian/$(PACKAGE)/usr/share/icons/ install -c -m 444 debian/$(PACKAGE).xpm \ debian/$(PACKAGE)/usr/share/icons/ # ----------------------------------------------------------------------------- # dh_movefiles # == arch-independent installation ============================================ install-indep: install-indep: build-indep dh_testdir dh_testroot dh_clean -k dh_installdirs -A # -- commands to install the package into the staging area -------------------- make -C $(SRCDIR) $(INSTALLDIRS) \ install-doc install-html install-examples # -- remove stray PDFs -------------------------------------------------------- find debian/$(PACKAGE)-doc -name compil-scheme.pdf\* | xargs -r rm -f find debian/$(PACKAGE)-doc -name debug-box.pdf\* | xargs -r rm -f # ----------------------------------------------------------------------------- # dh_movefiles # == build architecture-independent files ===================================== binary-indep: build-indep install-indep dh_testdir -i dh_testroot -i # dh_installdebconf -i dh_installdocs -i # -pgprolog-doc dh_installexamples -i # dh_installmenu -i dh_installemacsen -i # dh_installman -i dh_installinfo -i dh_installchangelogs -i dh_link -i dh_compress -i -X.pdf dh_fixperms -i dh_installdeb -i dh_gencontrol -i dh_md5sums -i dh_builddeb -i # Build architecture-dependent files here. binary-arch: build-arch install-arch dh_testdir -a dh_testroot -a # dh_installdebconf -a dh_installdocs -a # dh_installexamples -a # dh_installmenu -a dh_installman -a # dh_installinfo -a dh_installchangelogs ChangeLog dh_link -a dh_strip -a dh_compress -a dh_fixperms -a # dh_makeshlibs -a for CTLFILE in postinst prerm; do \ ( echo "# -- Prolog variant ---------"; \ echo LIB=/usr/lib/gprolog-${variant}; \ echo VARIANT=${variant}; \ echo "# ---------------------------" ) \ >> debian/$(PACKAGE).$$CTLFILE.debhelper; \ done dh_installdeb -a dh_shlibdeps -a dh_gencontrol -a dh_md5sums -a dh_builddeb -a binary: binary-indep binary-arch .PHONY: build build-arch build-indep clean binary-indep binary-arch binary install debian/README.Debian0000644000000000000000000000146311350005224011223 0ustar == GNU Prolog for Debian ====================================================== -- Packaging notes: ----------------------------------------------------------- - The .orig.tar.gz file was obtained from the CVS archive after removing *all* CVS subdirectories, doing a "make clean-full" in the "doc/" directory and removing all configure-generated Makefiles in "src/". The "src/src/debian" (also found as a link at the top level dir) has also been removed. - The icon is the usual "Logic Programming motto" :-) -- Acknowledgements: ---------------------------------------------------------- Thanks are due to Milan Zamazal for the initial packaging and to Gergely Nagy for his help in debugging previous versions of these packages. ../salvador Abreu debian/gprolog.doc-base0000644000000000000000000000111111350005224012220 0ustar Document: gprolog Title: GNU Prolog compiler Author: Daniel Diaz Abstract: GNU Prolog is a free Prolog compiler with constraint solving over finite domains (FD) developed by Daniel Diaz. GNU Prolog is based on two systems developed by the same author (with lot of code rewriting and a lot of new extensions): wamcc and clp(FD). A lot of work has been devoted to the ISO compatibility, GNU Prolog is very close to the ISO standard. Section: Apps/Programming Format: text Files: /usr/share/doc/gprolog/README.gz /usr/share/doc/gprolog/NEWS.gz /usr/share/doc/gprolog/README.Debian debian/gprolog.xpm0000644000000000000000000000255211350005224011361 0ustar /* XPM */ static char * gprolog_xpm[] = { "32 32 12 1", " c None", ". c #000000", "+ c #FFFFFF", "@ c #191919", "# c #7F7F7F", "$ c #333333", "% c #4C4C4C", "& c #CCCCCC", "* c #666667", "= c #B2B2B2", "- c #999999", "; c #E5E5E5", " ", " ........ ", " .............. ", " ................ ", " .................... ", " ...................... ", " ........................ ", " ........................ ", " .......................... ", " ..++-@.....#++++++@@++-@.... ", " ..++=$@....#++++++%@++=$@... ", " ..++;=####.%==&&&&*$++&%@... ", " ...++++++++$@$%%%%%$@++=%@.... ", " ...++++++++*@@.@@@@@.++&%@.... ", "....++&-####*-++++++@@++++++++$ ", "....++&*$$@$@#++++++*@++++++++* ", "....++;=####@%-=&=&=*$++;&&=&&# ", "....++++++++$@$%%*%%$@++&#*%%%% ", " ...++++++++*$.@@@@@@.++&%@@@.@ ", " ...++&####**-++++++@@++&%@.... ", " ...++&*$$$@@#++++++%@++&%@.... ", " ..++&%@....#++++++#$++=%@... ", " ..@%*$@....@$*###**@@**$@... ", " .@@$@......@$@$@$@.@@$@... ", " ........................ ", " ........................ ", " ...................... ", " .................... ", " ................ ", " .............. ", " .......... ", " "}; debian/copyright0000644000000000000000000000166511350005224011121 0ustar This Package is now in Debian form in the main CVS repository. This package was initially debianized by Milan Zamazal . It is presently being maintained by Salvador Abreu . It was made from a snapshot of the GNU Prolog CVS archive on sourceforge.net, taken slightly before the package itself was made. Copyright: Copyright (C) 1999-2004 Daniel Diaz GNU Prolog 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, or any later version. GNU Prolog 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. On Debian systems, you can find the GNU General Public License in the file /usr/share/common-licenses/GPL. debian/dhelp.gprolog-doc0000644000000000000000000000026711350005224012415 0ustar programming GNU Prolog gprolog.html/index.html This is the HTML version of the GNU Prolog reference manual. debian/gprolog-doc.postinst0000644000000000000000000000003211350005224013172 0ustar #!/bin/sh -e #DEBHELPER# debian/menu0000644000000000000000000000134311350005224010046 0ustar ?package(gprolog):needs="text" section="Apps/Programming" \ title="GNU Prolog interactive shell" \ longtitle="Start a GNU Prolog top-level interpreter in a terminal" \ command="/usr/bin/gprolog-iso" \ description="\ GNU Prolog is a free Prolog compiler with constraint solving \ over finite domains. GNU Prolog accepts a Prolog+constraint \ program and produces a native binary (like gcc does from a \ C source). The obtained executable is then stand-alone. The \ size of this executable can be quite small, since GNU Prolog \ can avoid linking the code of most unused built-in predicates. \ The performance of GNU Prolog is very encouraging (comparable \ to commercial systems.) \ " \ icon="/usr/share/icons/gprolog.xpm" debian/gprolog.prerm0000644000000000000000000000025511350005224011700 0ustar #!/bin/sh -e #DEBHELPER# case "$1" in remove) update-alternatives --remove gprolog ${LIB}/bin/gprolog update-alternatives --remove prolog ${LIB}/bin/gprolog ;; esac debian/compat0000644000000000000000000000000211350005224010354 0ustar 5