.gitlab-ci.yml

variables:
  #year: "2025"
  #month: "09"
  #download_url: "https://common-lisp.net/project/cmucl/downloads/snapshots/$year/$month"
  #version: "$year-$month-x86"
  release: "21f"
  download_url: "https://common-lisp.net/project/cmucl/downloads/release/$release"
  version: "$release-x86"
  tar_ext: "xz"
  bootstrap: ""

workflow:
  rules:
    # Always run on schedules (for analyze and markdown-link-check stages)
    - if: $CI_PIPELINE_SOURCE == "schedule"
    # Run on merge requests
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    # Run on the default branch (where there's no MR)
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
    # Run on feature branches, but only if there's no open MR (to avoid
    # duplicate pipelines).
    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
      when: never
    - if: $CI_COMMIT_BRANCH
    # Run on tags
    - if: $CI_COMMIT_TAG

# Default install configuration to download the cmucl tarballs to use
# for building.
.install:
  stage: install
  artifacts:
    paths:
      - snapshot/
  script:
    - echo PATH = $PATH
    - ls -F /usr/local/bin
    # Make sure gitlab-runner is available because it's needed by the
    # VM to upload artifacts.
    - type -all gitlab-runner
    # Download binaries.  (Do we really need the extras tarball?)
    - $CURL -o cmucl-$version-$osname.tar.$tar_ext $download_url/cmucl-$version-$osname.tar.$tar_ext
    - $CURL -o cmucl-$version-$osname.extra.tar.$tar_ext $download_url/cmucl-$version-$osname.extra.tar.$tar_ext
    - mkdir snapshot
    - (cd snapshot; tar xf ../cmucl-$version-$osname.tar.$tar_ext; tar xf ../cmucl-$version-$osname.extra.tar.$tar_ext)

# Default build configuration to be added to each build stage for each
# OS.  This assumes we don't need anything special between OSes, and
# the option '-C ""' is good enough.  We also override the default
# build dirs by using the -b option so that we know where the results
# are, independent of OS.
.build:
  stage: build
  artifacts:
    paths:
      - dist/
      - build-2/*.log
      - build-3/*.log
      - build-4/
      - cmucl*
      # Needed by Linux analyzer stage
      - src/lisp/cmucl-version.h
      # Save this so we can see the generated errno
      - src/code/errno.lisp
  script:
    # Do cross compile first
    #- bin/create-target.sh xtarget x86_linux_clang
    #- bin/create-target.sh xcross x86_linux_clang
    #- bin/cross-build-world.sh -crl -B boot-2020-04-1 xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp
    # Regular build using the cross-compiled result or snapshot.  The
    # analyzer job requires gcc, so make sure we build with gcc here
    # instead of clang.
    #
    # Set CONFIG in appropriately each build.
    - bin/build.sh $bootstrap -b build -R -C $CONFIG -o snapshot/bin/lisp
    # When the result of `git describe` cannot be used as a version
    # string, an alternative can be provided with the -V flag
    # The following stages need this to run tests and such.
    - sh -x bin/git-version.sh
    - bin/make-dist.sh -I dist build-4
    # Also make some tarballs so it's easy to download the artifacts.
    - bin/make-dist.sh -S build-4

# Default configuration for running the ansi-tests.
.ansi-test:
  stage: ansi-test
  artifacts:
    paths:
      - ansi-test.out
  script:
    - bin/run-ansi-tests.sh -l dist/bin/lisp
    - cp ../ansi-test/test.out ansi-test.out

# Default configuration for running unit tests.
.unit-test:
  stage: test
  artifacts:
    paths:
      - test.log
  script:
    - echo LANG = $LANG
    - bin/run-unit-tests.sh -l dist/bin/lisp 2>&1 | tee test.log

# Default configuration to test creation of lisp executable and
# testing the exectuable works.
.exec-test:
  stage: test
  script:
    # Create an executable and test it by printing the version.
    - dist/bin/lisp -eval '(save-lisp "saved-lisp-executable" :executable t)'
    - ./saved-lisp-executable --version
    # Run the unit tests with the executable, just to make sure the
    # executable works as expected.
    - bin/run-unit-tests.sh -l ./saved-lisp-executable

# Default configuration for running the benchmarks.
.benchmark:
  stage: benchmark
  artifacts:
    paths:
      - benchmarks/cl-bench/results
  script:
    - cd benchmarks/cl-bench
    - mkdir tmp
    - CMUCL=../../snapshot/bin/lisp ./run-cmucl.sh
    - CMUCL=../../dist/bin/lisp ./run-cmucl.sh
    - ../../snapshot/bin/lisp -load report

# Rules shared by optional/manual jobs (static analyzer, markdown-link-check).
.optional-rules:
  rules:
    - if: $CI_PIPELINE_SOURCE == "schedule"
    - if: $RUN_CHECKS
    - when: manual
      allow_failure: true

# Per-platform base jobs: capture tags and the needs chain so individual
# jobs don't have to repeat them.
.linux:
  tags:
    - linux

.linux-needs-install:
  extends: .linux
  needs:
    - job: linux:install
      artifacts: true

.linux-needs-build:
  extends: .linux
  needs:
    # Needs artifacts from build (dist/)
    - job: linux:build
      artifacts: true

.osx:
  tags:
    - macos-virtualbox

.osx-needs-install:
  extends: .osx
  needs:
    - job: osx:install
      artifacts: true

.osx-needs-build:
  extends: .osx
  needs:
    # Needs artifacts from build (dist/)
    - job: osx:build
      artifacts: true

.ubuntu:
  tags:
    - ubuntu

.ubuntu-needs-install:
  extends: .ubuntu
  needs:
    - job: ubuntu:install
      artifacts: true

.ubuntu-needs-build:
  extends: .ubuntu
  needs:
    # Needs artifacts from build (dist/)
    - job: ubuntu:build
      artifacts: true

stages:
  - install
  - build
  - test
  - ansi-test
  - benchmark
  - analyze
  - markdown-link-check

cache:

#### Linux jobs ####
linux:install:
  extends: [.install, .linux]
  variables:
    osname: "linux"
    CURL: "curl"

linux:build:
  extends: [.build, .linux-needs-install]
  variables:
    # Fedora 41 must build with gcc because the clang build fails some
    # ansi-tests.  See [#469].
    CONFIG: "x86_linux"

linux:cross-build:
  extends: .linux-needs-install
  stage: build
  artifacts:
    paths:
      - xdist/
      - linux-2/*.log
      - linux-3/*.log
      - linux-4/*.log
      # The lisp directory is needed for the static analyzer job.
      - linux-4/lisp
  variables:
    # This must match the config used for the linux build!
    CONFIG: "x86_linux"
  script:
    - bin/create-target.sh xtarget $CONFIG
    - bin/create-target.sh xcross $CONFIG
    - bin/cross-build-world.sh -crl xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp
    - bin/build.sh -b xlinux $bootstrap -R -C $CONFIG -o "xtarget/lisp/lisp -lib xtarget/lisp"
    - bin/make-dist.sh -I xdist xlinux-4

linux:test:
  extends: [.unit-test, .linux-needs-build]

linux:exec-test:
  extends: [.exec-test, .linux-needs-build]

linux:cross-test:
  extends: .linux
  stage: test
  artifacts:
    paths:
      - ansi-test/test.out
      - cross-test.log
  needs:
    # Needs artifacts from build (dist/)
    - job: linux:cross-build
      artifacts: true
  script:
    - bin/run-unit-tests.sh -l xdist/bin/lisp 2>&1 | tee cross-test.log

linux:ansi-test:
  extends: [.ansi-test, .linux-needs-build]

linux:benchmark:
  extends: [.benchmark, .linux]
  needs:
    # Needs artifacts from install (snapshot/) and build (dist/)
    - job: linux:install
      artifacts: true
    - job: linux:build

#### OSX (Mac) jobs ####
osx:install:
  extends: [.install, .osx]
  variables:
    osname: "darwin"
    CURL: "/opt/local/bin/curl"

osx:build:
  extends: [.build, .osx-needs-install]
  variables:
    CONFIG: "x86_darwin"

osx:test:
  extends: [.unit-test, .osx-needs-build]

osx:exec-test:
  extends: [.exec-test, .osx-needs-build]

osx:ansi-test:
  extends: [.ansi-test, .osx-needs-build]

osx:benchmark:
  extends: [.benchmark, .osx]
  needs:
    # Needs artifacts from install (snapshot/) and build (dist/)
    - job: osx:install
      artifacts: true
    - job: osx:build

# Optional job that runs the static analyzer.  It needs the files from
# the linux-4 directory built in the linux:build job.
linux:static-analyzer:
  extends: [.optional-rules, .linux-needs-build]
  stage: analyze
  artifacts:
    when: always
    paths:
      - analyzer.log
  script:
    # Analysis can generate huge amounts of output.  For now just save
    # the results to the log file instead of also having it go to the
    # console.  If someday there's less or no output, we can consider
    # having the logs go to the console too.
    - make -C build-4/lisp clean
    - make -C build-4/lisp ANALYZER=-fanalyzer > analyzer.log 2>&1

#### OpenSUSE jobs ####
ubuntu:install:
  extends: [.install, .ubuntu]
  variables:
    osname: "linux"
    CURL: "curl"

ubuntu:build:
  extends: [.build, .ubuntu-needs-install]
  variables:
    # Build with gcc on Ubuntu 25.10.  It produces a lisp than passes
    # the ansi-tests.  Clang seems to fail the ansi-tests WRITE.1,
    # PRINT.1, and friends when cr_pow is used.
    CONFIG: "x86_linux"

ubuntu:test:
  extends: [.unit-test, .ubuntu-needs-build]

ubuntu:ansi-test:
  extends: [.ansi-test, .ubuntu-needs-build]

# Optional job that runs the markdown link checker.  This is optional
# because it's very slow, of course; you have to run it manually.
#
# From https://github.com/tcort/markdown-link-check
# Checks links on the wiki pages whenever any wiki markdown pages change. 
markdown-link-check:
  extends: [.optional-rules, .linux]
  stage: markdown-link-check

  # It's ok if this fails; we don't want to declare the entire
  # pipeline as having failed.
  allow_failure: true
  # This job doesn't depend on any others.
  needs: []
  script:
    # Check links in the main repo
    - find . -name \*.md -print0 | xargs -0 -n1 markdown-link-check
    # Clone the wiki pages and check the links there.  Lots of
    # failures here because of
    # https://gitlab.com/gitlab-org/gitlab/-/issues/17845.
    - git clone https://gitlab.common-lisp.net/cmucl/cmucl.wiki.git
    - find cmucl.wiki -name \*.md -print0 | xargs -0 -n1 markdown-link-check