code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
;;; Copyright © 2018, 2019, 2020 Tobias Geerinckx-Rice <me@tobias.gr>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix 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 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages mc)
  #:use-module (guix packages)
  #:use-module (guix licenses)
  #:use-module (guix download)
  #:use-module (guix build-system gnu)
  #:use-module (gnu packages)
  #:use-module (gnu packages aspell)
  #:use-module (gnu packages ncurses)
  #:use-module (gnu packages glib)
  #:use-module (gnu packages ssh)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages check)
  #:use-module (gnu packages perl)
  #:use-module (gnu packages compression))

(define-public mc
  (package
    (name "mc")
    (version "4.8.25")
    (source
     (origin
      (method url-fetch)
      (uri (string-append "https://ftp.midnight-commander.org/mc-"
                          version ".tar.xz"))
      (sha256
       (base32 "12jlnabnc91xsm35g99g2wnh96jmznvrhffd18rj7fqfy8brdhgz"))))
    (build-system gnu-build-system)
    (native-inputs `(("pkg-config" ,pkg-config)
                     ("perl" ,perl)))
    (inputs `(("aspell" ,aspell)
              ("ncurses" ,ncurses)
              ("libssh2" ,libssh2)
              ("glib" ,glib)
              ("check" ,check)
              ("unzip" ,unzip)))
    (arguments
     `(#:configure-flags
       '("--with-screen=ncurses" "--enable-aspell")
       #:phases
       (modify-phases %standard-phases
         (add-after 'patch-source-shebangs 'patch-FHS-file-names
           (lambda _
             ;; Patch files to refer to executables in the store or $PATH.
             (substitute* "misc/mcedit.menu.in"
               (("#! /bin/sh") (string-append "#!" (which "sh")))
               (("/bin/bash") (which "bash")))
             (substitute* "misc/ext.d/misc.sh.in"
               (("/bin/cat") "cat"))
             (substitute* (list "lib/utilunix.c"
                                "src/usermenu.c"
                                "src/vfs/fish/fish.c"
                                "tests/src/vfs/extfs/helpers-list/Makefile.in")
               (("/bin/sh") (which "sh")))
             (substitute* "src/filemanager/ext.c"
               (("/bin/rm") "rm")
               (("/bin/sh") (which "sh")))

             ;; There are other /bin/<shell>s hard-coded in this file, but they
             ;; are never tried after bash (mc's first choice) is found.
             (substitute* "lib/shell.c"
               (("/bin/bash") (which "bash")))
             #t))
         (add-before 'check 'fix-tests
           (lambda _
             ;; Don't expect a UID or GID of ‘0’ in the build environment.
             (with-directory-excursion "tests/src/vfs/extfs/helpers-list/data"
               (substitute* (list "rpm.custom.output"
                                  "rpm.glib.output")
                 (("      0        0") "<<uid>>  <<gid>>")))
             ;; XXX ERROR:mc_realpath.c:99:realpath_test: assertion failed
             ;; (resolved_path == data->expected_string): ("" == "/usr/bin")
             (substitute* "tests/lib/mc_realpath.c"
               (("/usr/bin") "/")
               (("usr/bin") "/"))
             #t)))))
    (home-page "https://www.midnight-commander.org")
    (synopsis "Graphical file manager")
    (description
     "GNU Midnight Commander is a command-line file manager laid out in a
common two-pane format.  In addition to standard file management tasks such as
copying and moving, Midnight Commander also supports viewing the contents of
RPM package files and other archives and managing files on other computers via
FTP or FISH.  It also includes a powerful text editor for opening text
files.")
    (license gpl3+)))

license: mit


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014, 2020 Eric Bavier <bavier@posteo.net>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix 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 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages mcrypt)
  #:use-module (guix packages)
  #:use-module ((guix licenses) #:select (gpl2+))
  #:use-module (guix download)
  #:use-module (guix build-system gnu)
  #:use-module (gnu packages)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages perl))

(define-public mcrypt
  (package
    (name "mcrypt")
    (version "2.6.8")
    (source
     (origin
      (method url-fetch)
      (uri (string-append "mirror://sourceforge/mcrypt/MCrypt/"
                          version "/" name "-" version ".tar.gz"))
      (sha256
       (base32
        "161031n1w9pb4yzz9i47szc12a4mwpcpvyxnvafsik2l9s2aliai"))
      (patches (search-patches
                 "mcrypt-CVE-2012-4409.patch"
                 "mcrypt-CVE-2012-4426.patch"
                 "mcrypt-CVE-2012-4527.patch"))))
    (build-system gnu-build-system)
    (inputs
     `(("zlib" ,zlib)
       ("libmcrypt" ,libmcrypt)
       ("libmhash" ,libmhash)))
    (home-page "http://mcrypt.sourceforge.net/")
    (synopsis "Replacement for the popular Unix crypt command")
    (description
     "MCrypt is a replacement for the old crypt() package and crypt(1)
command, with extensions.  It allows developers to use a wide range of
encryption functions, without making drastic changes to their code.  It allows
users to encrypt files or data streams without having to be cryptographers.
The companion to MCrypt is Libmcrypt, which contains the actual encryption
functions themselves, and provides a standardized mechanism for accessing
them.")
    (license gpl2+)))

(define-public libmcrypt
  (package
    (name "libmcrypt")
    (version "2.5.8")
    (source
     (origin
      (method url-fetch)
      (uri (string-append "mirror://sourceforge/mcrypt/Libmcrypt/" version
                          "/libmcrypt-" version ".tar.gz"))
      (sha256
       (base32
        "0gipgb939vy9m66d3k8il98rvvwczyaw2ixr8yn6icds9c3nrsz4"))))
    (build-system gnu-build-system)
    (home-page "http://mcrypt.sourceforge.net/")
    (synopsis "Encryption algorithm library")
    (description
     "Libmcrypt is a data encryption library.  The library is thread safe and
provides encryption and decryption functions.  This version of the library
supports many encryption algorithms and encryption modes.  Some algorithms
which are supported: SERPENT, RIJNDAEL, 3DES, GOST, SAFER+, CAST-256, RC2,
XTEA, 3WAY, TWOFISH, BLOWFISH, ARCFOUR, WAKE and more.")
    (license gpl2+)))

(define-public libmhash
  (package
    (name "libmhash")
    (version "0.9.9.9")
    (source
     (origin
      (method url-fetch)
      (uri (string-append "mirror://sourceforge/mhash/mhash/" version
                          "/mhash-" version ".tar.bz2"))
      (sha256
       (base32
        "1w7yiljan8gf1ibiypi6hm3r363imm3sxl1j8hapjdq3m591qljn"))
      (patches (search-patches "mhash-keygen-test-segfault.patch"
                               "libmhash-hmac-fix-uaf.patch"))))
    (build-system gnu-build-system)
    (native-inputs
     `(("perl" ,perl)))                 ;for tests
    (home-page "http://mhash.sourceforge.net/")
    (synopsis "Thread-safe hash library")
    (description
     "Mhash is a thread-safe hash library, implemented in C, and provides a
uniform interface to a large number of hash algorithms.  These algorithms can
be used to compute checksums, message digests, and other signatures.  The HMAC
support implements the basics for message authentication, following RFC 2104.

Algorithms currently supplied are:

CRC-32, CRC-32B, ALDER-32, MD-2, MD-4, MD-5, RIPEMD-128, RIPEMD-160,
RIPEMD-256, RIPEMD-320, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, HAVAL-128,
HAVAL-160, HAVAL-192, HAVAL-256, TIGER, TIGER-128, TIGER-160, GOST, WHIRLPOOL,
SNEFRU-128, SNEFRU-256.")
    (license gpl2+)))


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2017 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2017 Quiliro <quiliro@fsfla.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix 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 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages medical)
  #:use-module (guix build-system python)
  #:use-module (guix download)
  #:use-module (guix licenses)
  #:use-module (guix packages)
  #:use-module (gnu packages databases)
  #:use-module (gnu packages python-xyz)
  #:use-module (gnu packages qt))

(define-public openmolar-1
  (package
   (name "openmolar")
   (version "1.0.15-gd81f9e5")
   (source (origin
             (method url-fetch)
             (uri (string-append
                   "https://static.openmolar.com/om1/releases/openmolar-"
                   version ".tar.gz"))
             (sha256
              (base32
               "1cfdzfbi6wslw7k0dc6ad6xrgs75iwsl91cg73w4myswaqqkfk3z"))))
   (build-system python-build-system)
   (arguments
    `(#:use-setuptools? #f
      #:phases
      (modify-phases %standard-phases
        (add-after 'unpack 'patch-/usr
          (lambda* (#:key outputs #:allow-other-keys)
            (substitute* "setup.py"
              (("/usr") (assoc-ref outputs "out")))
            #t)))))
   (inputs
    `(("python-pyqt+qscintilla" ,python-pyqt+qscintilla)
      ("python-mysqlclient" ,python-mysqlclient)
      ("qscintilla" ,qscintilla)))
   (home-page "https://openmolar.com/om1")
   (synopsis "Dental practice management software")
   (description "Openmolar is a dental practice management suite.  Its
functionality includes appointments, patient records, treatment planning,
billing etc.  It is a full featured, reliable and thoroughly tested
application and has been translated into many languages.")
   (license gpl3+)))


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix 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 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages mercury)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix packages)
  #:use-module (guix utils)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix build-system gnu)
  #:use-module (gnu packages autotools)
  #:use-module (gnu packages bdw-gc)
  #:use-module (gnu packages readline)
  #:use-module (gnu packages texinfo)
  #:use-module (gnu packages flex)
  #:use-module (gnu packages shells)
  #:use-module (gnu packages bison)
  #:use-module (gnu packages pkg-config)
  #:use-module (ice-9 match)) ; match-lambda

;; NOTE: Mercury uses a tightly coupled fork of BDWGC and
;; libatomic-ops. When updating the package, please check the GitHub
;; repository to ensure that the submodule commit matches what is
;; provided.
(define (gc-fork package-name package-url
                 package-commit package-hash)
  (let ((commit package-commit))
    (package (inherit package-name)
             (source
              (origin
                (method git-fetch)
                (uri (git-reference
                      (url package-url)
                      (commit commit)))
                (sha256 (base32 package-hash)))))))

;; NOTE: Mercury /MUST/ bootstrap from a tarball release.
;; Once the bootstrapping compiler is established, this
;; minimal build can be used for further compiling Mercury
;; from a git checkout with additional grades enabled.
(define-public mercury-minimal
  (package
    (name "mercury-minimal")
    (version "20.06")
    (source (origin
              (method url-fetch)
              (uri (string-append
                    "https://dl.mercurylang.org/release/mercury-srcdist-"
                    version ".tar.gz"))
              (sha256
               (base32
                "1gkr9w8lsdzqykqwd3f1a1phsqv090648i14ilhv8jdg85frdimr"))))
    (build-system gnu-build-system)
    (arguments
     `(#:modules ((guix build gnu-build-system)
                  (guix build utils)
                  (ice-9 match))
       #:tests? #f ; Tests are run on the stage-2 compiler.
       ;; TODO: Find a way to bypass all static linkages.
       #:configure-flags (list "--enable-minimal-install")
       #:phases
       (modify-phases %standard-phases
         (add-after 'unpack 'replace-boehm-gc
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let ((out (assoc-ref outputs "out"))
                   (libgc (assoc-ref inputs "libgc"))
                   (libatomic-ops (assoc-ref inputs "libatomic-ops"))
                   (unpack (assoc-ref %standard-phases 'unpack))
                   (patch-source-shebangs
                    (assoc-ref %standard-phases 'patch-source-shebangs)))
               (map (match-lambda
                      ((src orig-name new-name)
                       (with-directory-excursion "."
                         (apply unpack (list #:source src)))
                       (delete-file-recursively new-name)
                       (invoke "mv" orig-name new-name)
                       (with-directory-excursion new-name
                         (apply patch-source-shebangs (list #:source src)))))
                    `((,libgc "source" "boehm_gc")))
               (map (match-lambda
                      ((src orig-name new-name)
                       (with-directory-excursion "."
                         (apply unpack (list #:source src)))
                       (delete-file-recursively new-name)
                       (invoke "mv" orig-name new-name)
                       (with-directory-excursion new-name
                         (apply patch-source-shebangs (list #:source src)))))
                    `((,libatomic-ops "source" "boehm_gc/libatomic_ops")))
               #t)))
         (add-after 'replace-boehm-gc 'patch-paths
           (lambda _
             (substitute*
                 (list "Makefile"
                       "Mmakefile"
                       "scripts/mercury_update_interface.in"
                       "scripts/mercury_config.in"
                       "scripts/mmake.in"
                       "scripts/Mmake.vars.in"
                       "scripts/mdb.in"
                       "scripts/rs6000_hack"
                       "scripts/fullarch"
                       "scripts/mmc.in"
                       "scripts/canonical_grade"
                       "scripts/mprof.in"
                       "scripts/gud.el"
                       "scripts/ml.in"
                       "scripts/canonical_grade.in"
                       "scripts/mdprof.in"
                       "scripts/vpath_find"
                       "scripts/mkfifo_using_mknod.in"
                       "scripts/prepare_install_dir.in"
                       "scripts/mprof_merge_runs"
                       "scripts/mtc"
                       "scripts/mgnuc.in"
                       "scripts/c2init.in"
                       "bindist/bindist.Makefile"
                       "boehm_gc/configure.ac"
                       "boehm_gc/Makefile.direct")
               (("/bin/sh") (which "sh"))
               (("/bin/pwd") (which "pwd"))
               (("/bin/rm") (which "rm")))
             #t)))))
    (native-inputs
     `(("texinfo" ,texinfo)
       ("flex" ,flex)
       ("tcsh", tcsh)
       ("bison" ,bison)
       ("readline" ,readline)
       ("libatomic-ops" ,(package-source
                          (gc-fork
                           libatomic-ops
                           "https://github.com/Mercury-Language/libatomic_ops.git"
                           "49b70d57f6922fd8be55a7dcb77955c8abfc9ae9"
                           "1flvwscsa6b2b8a38vhhcgl10bbkb5nnihw7s7iia60cinf7wcqm")))
       ("libgc" ,(package-source
                  (gc-fork
                   libgc-7
                   "https://github.com/Mercury-Language/bdwgc.git"
                   "43ac2ea45261ba0a715534e9da41b2504904c46a"
                   "0bmzmbs7id0ndyhy9xli6fhfad1shrim6vmy2k8m1nqr5wb31q76")))
       ("pkg-config" ,pkg-config)))
    (synopsis "Pure logic programming language (used only for
bootstrapping dependent Mercury)")
    (description "Mercury is a logic/functional programming language which
combines the clarity and expressiveness of declarative programming with advanced
static analysis and error detection features.  Its highly optimized execution
algorithm delivers efficiency far in excess of existing logic programming
systems, and close to conventional programming systems.  Mercury addresses
the problems of large-scale program development, allowing modularity,
separate compilation, and numerous optimization/time trade-offs.")
    (home-page "https://mercurylang.org")
    (license license:gpl2)))

;; NOTE: This package is quite large and will take an extensive
;; amount of time to compile, especially with bootcheck functionality
;; enabled. To ensure that we do not monopolize the CI & build servers,
;; please make sure that your changes are justified.
(define-public mercury
  (package (inherit mercury-minimal)
           (name "mercury")
           (version "20.06")
           (source
            (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/Mercury-Language/mercury")
                    (commit (string-append
                             "version-"
                             (string-join (string-split version #\.) "_")))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1pc51r7vlqmi689rkwdkk1ka2dyk36q11dqvl339cizng6mp72h6"))))
           (arguments
            (substitute-keyword-arguments
                (package-arguments mercury-minimal)
              ;; TODO: Find a way to bypass all static linkages.
              ((#:configure-flags flags ''())
               `(list ""))
              ((#:tests? _) #f) ; FIXME: Many test-cases failing.
              ((#:phases phases)
               `(modify-phases ,phases
                  (replace 'patch-paths
                    (lambda _
                      (substitute*
                          (list "prepare.sh"
                                "Makefile"
                                "Mmakefile"
                                "scripts/mercury_update_interface.in"
                                "scripts/mercury_config.in"
                                "scripts/mmake.in"
                                "scripts/Mmake.vars.in"
                                "scripts/mdb.in"
                                "scripts/rs6000_hack"
                                "scripts/fullarch"
                                "scripts/mmc.in"
                                "scripts/mprof.in"
                                "scripts/gud.el"
                                "scripts/ml.in"
                                "scripts/canonical_grade.in"
                                "scripts/mdprof.in"
                                "scripts/vpath_find"
                                "scripts/mkfifo_using_mknod.in"
                                "scripts/prepare_install_dir.in"
                                "scripts/mprof_merge_runs"
                                "scripts/mtc"
                                "scripts/mgnuc.in"
                                "scripts/c2init.in"
                                "tools/bootcheck"
                                "boehm_gc/configure.ac"
                                "boehm_gc/Makefile.direct")
                        (("/bin/sh") (which "sh"))
                        (("/bin/pwd") (which "pwd"))
                        (("/bin/rm") (which "rm"))
                        (("boehm_gc/.git") "boehm_gc"))
                      #t))
                  (replace 'bootstrap
                    (lambda _
                      (invoke "./prepare.sh")
                      #t))))))
           ;; TODO: Uncomment phase when tests are enabled.
           ;; (replace 'check
           ;;   (lambda _
           ;;     (invoke "./tools/bootcheck")
           ;;     #t))
           ;;
           ;; TODO: The mercury configuration system determines
           ;; grade support by looking for available toolchains.
           ;; Eventually we need to add inputs for Java, Erlang,
           ;; C#, etc. in order to enable these extra grades.
           (native-inputs
            `(("mercury-minimal" ,mercury-minimal)
              ("autoconf" ,autoconf)
              ("automake" ,automake)
              ,@(package-native-inputs mercury-minimal)))
           (synopsis "Pure logic programming language")))


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2017, 2018, 2019, 2020 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
;;; Copyright © 2017, 2018 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix 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 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages mes)
  #:use-module (gnu packages)
  #:use-module (gnu packages base)
  #:use-module (gnu packages bash)
  #:use-module (gnu packages bootstrap)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages cross-base)
  #:use-module (gnu packages gcc)
  #:use-module (gnu packages graphviz)
  #:use-module (gnu packages guile)
  #:use-module (gnu packages man)
  #:use-module (gnu packages package-management)
  #:use-module (gnu packages perl)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages texinfo)
  #:use-module (guix build-system gnu)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix licenses)
  #:use-module (guix packages)
  #:use-module (guix utils))

(define-public nyacc-0.86
  ;; Nyacc used for bootstrap.
  (package
    (name "nyacc")
    (version "0.86.0")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://savannah/nyacc/"
                                  name "-" version ".tar.gz"))
              (patches (search-patches "nyacc-binary-literals.patch"))
              (sha256
               (base32
                "0lkd9lyspvhxlfs0496gsllwinh62jk9wij6gpadvx9gwz6yavd9"))))
    (build-system gnu-build-system)
    (native-inputs
     `(("guile" ,guile-2.2)))
    (synopsis "LALR(1) Parser Generator in Guile")
    (description
     "NYACC is an LALR(1) parser generator implemented in Guile.
The syntax and nomenclature should be considered not stable.  It comes with
extensive examples, including parsers for the Javascript and C99 languages.")
    (home-page "https://savannah.nongnu.org/projects/nyacc")
    (license (list gpl3+ lgpl3+))))

(define-public nyacc
  (package
    (inherit nyacc-0.86)
    (version "0.99.0")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://savannah/nyacc/nyacc-"
                                  version ".tar.gz"))
              (sha256
               (base32
                "0hl5qxx19i4x1r0839sxm19ziqq65g4hy97yik81cc2yb9yvgyv3"))
              (modules '((guix build utils)))
              (snippet
               '(begin
                  (substitute* (find-files "." "^Makefile\\.in$")
                    (("^SITE_SCM_DIR =.*")
                     "SITE_SCM_DIR = \
@prefix@/share/guile/site/@GUILE_EFFECTIVE_VERSION@\n")
                    (("^SITE_SCM_GO_DIR =.*")
                     "SITE_SCM_GO_DIR = \
@prefix@/lib/guile/@GUILE_EFFECTIVE_VERSION@/site-ccache\n")
                    (("^INFODIR =.*")
                     "INFODIR = @prefix@/share/info\n")
                    (("^DOCDIR =.*")
                     "DOCDIR = @prefix@/share/doc/$(PACKAGE_TARNAME)\n"))
                  #t))))
    (native-inputs
     `(("pkg-config" ,pkg-config)))
    (inputs
     `(("guile" ,guile-2.2)))))

(define-public mes-0.19
  ;; Mes used for bootstrap.
  (package
    (name "mes")
    (version "0.19")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/mes/"
                                  "mes-" version ".tar.gz"))
              (sha256
               (base32
                "15h4yhaywdc0djpjlin2jz1kzahpqxfki0r0aav1qm9nxxmnp1l0"))))
    (build-system gnu-build-system)
    (supported-systems '("i686-linux" "x86_64-linux"))
    (propagated-inputs
     `(("mescc-tools" ,mescc-tools-0.5.2)
       ("nyacc" ,nyacc-0.86)))
    (native-inputs
     `(("guile" ,guile-2.2)
       ,@(let ((target-system (or (%current-target-system)
                                  (%current-system))))
           (cond
            ((string-prefix? "x86_64-linux" target-system)
             ;; Use cross-compiler rather than #:system "i686-linux" to get
             ;; MesCC 64 bit .go files installed ready for use with Guile.
             `(("i686-linux-binutils" ,(cross-binutils "i686-unknown-linux-gnu"))
               ("i686-linux-gcc" ,(cross-gcc "i686-unknown-linux-gnu"))))
            (else
             '())))
       ("graphviz" ,graphviz)
       ("help2man" ,help2man)
       ("perl" ,perl)                 ; build-aux/gitlog-to-changelog
       ("texinfo" ,texinfo)))
    (arguments
     `(#:strip-binaries? #f))  ; binutil's strip b0rkes MesCC/M1/hex2 binaries
    (synopsis "Scheme interpreter and C compiler for full source bootstrapping")
    (description
     "GNU Mes--Maxwell Equations of Software--brings the Reduced Binary Seed
bootstrap to Guix and aims to help create full source bootstrapping for
GNU/Linux distributions.  It consists of a mutual self-hosting Scheme
interpreter in C and a Nyacc-based C compiler in Scheme and is compatible with
Guile.")
    (home-page "https://www.gnu.org/software/mes/")
    (license gpl3+)))

(define-public mes
  (package
    (inherit mes-0.19)
    (version "0.22")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/mes/"
                                  "mes-" version ".tar.gz"))
              (sha256
               (base32
                "0p1jsrrmcbc0zrvbvnjbb6iyxr0in71km293q8qj6gnar6bw09av"))))
    (propagated-inputs
     `(("mescc-tools" ,mescc-tools)
       ("nyacc" ,nyacc)))
    (native-search-paths
     (list (search-path-specification
            (variable "C_INCLUDE_PATH")
            (files '("include")))
           (search-path-specification
            (variable "LIBRARY_PATH")
            (files '("lib")))
           (search-path-specification
            (variable "MES_PREFIX")
            (separator #f)
            (files '("")))))))

(define-public mes-rb5
  ;; This is the Reproducible-Builds summit 5's Mes, also built on Debian
  ;; GNU/Linux and NixOS to produce the same, bit-for-bit identical result.
  (package
    (inherit mes)
    (name "mes-rb5")
    (inputs '())
    (propagated-inputs '())
    (native-inputs
     `(("bash" ,bash)
       ("coreutils" ,coreutils)
       ("grep" ,grep)
       ("guile" ,guile-2.2)
       ("gzip" ,gzip)
       ("libc" ,glibc)
       ("locales" ,glibc-utf8-locales)
       ("make" ,gnu-make)
       ("mes" ,mes)
       ("mescc-tools" ,mescc-tools)
       ("nyacc" ,nyacc)
       ("sed" ,sed)
       ("tar" ,tar)))
    (supported-systems '("i686-linux"))
    (arguments
     `(#:implicit-inputs? #f
       #:strip-binaries? #f    ; binutil's strip b0rkes MesCC/M1/hex2 binaries
       #:modules ((guix build gnu-build-system)
                  (guix build utils)
                  (ice-9 popen)
                  (ice-9 rdelim))
       #:phases
       (modify-phases %standard-phases
         (add-before 'configure 'setenv
           (lambda _
             (setenv "AR" "mesar")
             (setenv "CC" "mescc")
             (setenv "GUILD" "true")
             (setenv "SCHEME" "mes")
             (setenv "LC_ALL" "en_US.UTF-8")
             #t))
         (replace 'configure
           (lambda _
             (let ((out (assoc-ref %outputs "out")))
               (invoke "sh" "configure.sh"
                       (string-append "--prefix=" out)
                       "--host=i686-unkown-linux-gnu"
                       "--with-courage"))))
         (replace 'build
           (lambda _
             (invoke "sh" "bootstrap.sh")))
         (replace 'check
           (lambda _
             (copy-file "bin/mes-mescc" "bin/mes-mescc-0.21")
             (system* "sed" "-i" "s/0\\.22/0\\.21/" "bin/mes-mescc-0.21")
             (let ((sha256sum
                    (read-delimited
                     " "
                     (open-pipe* OPEN_READ "sha256sum" "bin/mes-mescc-0.21"))))
               (unless
                   (equal?
                    sha256sum
                    "9e0bcb1633c58e7bc415f6ea27cee7951d6b0658e13cdc147e992b31a14625fb")
                 (throw 'error "mes checksum failure"))
               #t)))
         (replace 'install
           (lambda _
             (invoke "sh" "install.sh"))))))))

(define-public mescc-tools-0.5.2
  ;; Mescc-tools used for bootstrap.
  (let ((commit "bb062b0da7bf2724ca40f9002b121579898d4ef7")
        (revision "0")
        (version "0.5.2"))
    (package
      (name "mescc-tools")
      (version (git-version version revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://git.savannah.nongnu.org/r/mescc-tools.git")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "1nc6rnax66vmhqsjg0kgx23pihdcxmww6v325ywf59vsq1jqjvff"))))
      (build-system gnu-build-system)
      (supported-systems '("i686-linux" "x86_64-linux"))
      (arguments
       `(#:make-flags (list (string-append "PREFIX=" (assoc-ref %outputs "out")))
         #:test-target "test"
         #:phases (modify-phases %standard-phases
                    (delete 'configure))))
      (synopsis "Tools for the full source bootstrapping process")
      (description
       "Mescc-tools is a collection of tools for use in a full source
bootstrapping process.  It consists of the M1 macro assembler, the hex2
linker, the blood-elf symbol table generator, the kaem shell, exec_enable and
get_machine.")
    (home-page "https://savannah.nongnu.org/projects/mescc-tools")
    (license gpl3+))))

(define-public mescc-tools
  (package
    (inherit mescc-tools-0.5.2)
    (name "mescc-tools")
    (version "0.6.1")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://git.savannah.nongnu.org/r/mescc-tools.git")
                    (commit (string-append "Release_" version))))
              (file-name (string-append "mescc-tools-" version "-checkout"))
              (sha256
               (base32
                "1cgxcdza6ws725x84i31la7jxmlk5a3nsij5shz1zljg0i36kj99"))))
    (arguments
     (substitute-keyword-arguments (package-arguments mescc-tools-0.5.2)
       ((#:make-flags _)
        `(list (string-append "PREFIX=" (assoc-ref %outputs "out"))
               "CC=gcc"))))))

(define-public m2-planet
  (let ((commit "b87ddb0051b168ea45f8d49a610dcd069263336a")
        (revision "2"))
    (package
      (name "m2-planet")
      (version (string-append "1.4.0-" revision "." (string-take commit 7)))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/oriansj/m2-planet")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0yyc0fcbbxi9jqa1n76x0rwspdrwmc8g09jlmsw9c35nflrhmz8q"))))
      (native-inputs
       `(("mescc-tools" ,mescc-tools)))
      (build-system gnu-build-system)
      (arguments
       `(#:make-flags (list (string-append "PREFIX=" (assoc-ref %outputs "out")))
         #:tests? #f
         #:phases (modify-phases %standard-phases
                    (delete 'bootstrap)
                    (delete 'configure))))
      (synopsis "The PLAtform NEutral Transpiler")
      (description
       "M2-Planet, the PLAtform NEutral Transpiler, when combined with
mescc-tools, compiles a subset of the C language into working binaries with
introspective steps in between.  It is self-hosting and for bootstrapping it
also has an implementation in the M1 macro assembly language.  M2-Planet is
built as Phase-5 of the full source bootstrapping process and is capable of
building GNU Mes.")
      (home-page "https://github.com/oriansj/m2-planet")
      (license gpl3+))))