revert the directory move

'argv_experimental_branch'.

.circleci/config.yml

@@ -1,182 +0,0 @@
-version: 2
-
-references:
-  container_config: &container_config
-    docker:
-      - image: "debian:stretch"
-        working_directory: /root/build
-
-  restore_repo: &restore_repo
-    restore_cache:
-      keys:
-        - source-repo-{{ .Branch }}-{{ .Revision }}
-        - source-repo-{{ .Branch }}
-        - source-repo
-
-  cmake_configure: &cmake_configure
-    run:
-      name: Creating Build Files
-      command: |
-        mkdir build
-        cd build
-
-        CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-        CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-
-        if [[ "$CC" =~ ^clang.*$ ]]; then
-            CXXFLAGS="$CXXFLAGS -stdlib=libc++"
-        fi
-
-        eval $CC --version
-
-        export CXXFLAGS
-        export CFLAGS
-        CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
-        eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON ..
-
-  compile: &compile
-    run:
-      name: Compiling Source code
-      command: |
-        cd build
-        ninja -k 20 all
-
-  run_tests: &run_tests
-    run:
-      name: Run unit tests
-      command: |
-        ./build/bin/unittests --gtest_shuffle
-
-  compile_steps: &compile_steps
-    steps:
-      - *restore_repo
-      - *cmake_configure
-      - *compile
-      - *run_tests
-jobs:
-  checkout_code:
-    <<: *container_config
-    steps:
-      - run:
-          name: Installing Git
-          command: 'apt-get update && apt-get -yq install git'
-      - *restore_repo
-      - checkout
-      - run:
-          name: Updating submodules
-          command: 'git submodule update --init --recursive'
-      - save_cache:
-          key: source-repo-{{ .Branch }}-{{ .Revision }}
-          paths:
-            - .
-
-  build_gcc_lowest_debug:
-    docker:
-      - image: asarium/fso_compile:gcc-lowest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_gcc_lowest_release:
-    docker:
-      - image: asarium/fso_compile:gcc-lowest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-  build_gcc_latest_debug:
-    docker:
-      - image: asarium/fso_compile:gcc-latest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_gcc_latest_release:
-    docker:
-      - image: asarium/fso_compile:gcc-latest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-  build_clang_latest_debug:
-    docker:
-      - image: asarium/fso_compile:clang-latest
-        working_directory: /root/build
-    environment:
-      CC: clang-8
-      CXX: clang++-8
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_clang_latest_release:
-    docker:
-      - image: asarium/fso_compile:clang-latest
-        working_directory: /root/build
-    environment:
-      CC: clang-8
-      CXX: clang++-8
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-  build_clang_lowest_debug:
-    docker:
-      - image: asarium/fso_compile:clang-lowest
-        working_directory: /root/build
-    environment:
-      CC: clang
-      CXX: clang++
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_clang_lowest_release:
-    docker:
-      - image: asarium/fso_compile:clang-lowest
-        working_directory: /root/build
-    environment:
-      CC: clang
-      CXX: clang++
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-workflows:
-  version: 2
-
-  build_test:
-    jobs:
-      - checkout_code
-      - build_gcc_lowest_debug:
-          requires:
-            - checkout_code
-      - build_gcc_lowest_release:
-          requires:
-            - checkout_code
-      - build_gcc_latest_debug:
-          requires:
-            - checkout_code
-      - build_gcc_latest_release:
-          requires:
-            - checkout_code
-      - build_clang_latest_debug:
-          requires:
-            - checkout_code
-      - build_clang_latest_release:
-          requires:
-            - checkout_code
-      - build_clang_lowest_debug:
-          requires:
-            - checkout_code
-      - build_clang_lowest_release:
-          requires:
-            - checkout_code

.clang-format

@@ -1,104 +0,0 @@
----
-Language:        Cpp
-Standard: Cpp11
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
-AlignOperands:   true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowAllArgumentsOnNextLine: false
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
-BraceWrapping:   
-  AfterClass:      false
-  AfterControlStatement: false
-  AfterEnum:       false
-  AfterFunction:   true
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  BeforeCatch:     false
-  BeforeElse:      false
-  IndentBraces:    false
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Custom
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     120
-CommentPragmas:  '^ IWYU pragma:'
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-IncludeBlocks: Regroup
-IncludeCategories:
-  - Regex:           '^(<.*\.(h|hh|hpp)>)$' # Includes of external libraries
-    Priority:        5
-  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
-    Priority:        6
-  - Regex:           '^"globalincs\/.*\.h"$' # globalincs always come first
-    Priority:        1
-  - Regex:           '^"[^/]*\.(h)"$' # Local includes
-    Priority:        2
-  - Regex:           '^".*\.(h)"$' # standard engine includes
-    Priority:        3
-  - Regex:           '.*' # Catch all in case something is unhandled above
-    Priority:        4
-IncludeIsMainRegex: '$'
-IndentCaseLabels: false
-IndentWidth:     4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBlockIndentWidth: 2
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-TabWidth:        4
-UseTab:          ForContinuationAndIndentation
-...
-

.clang-tidy

@@ -1,41 +0,0 @@
----
-Checks: "-*,\
-modernize-*,\
--modernize-avoid-c-arrays,\
--modernize-make-unique,\
--modernize-raw-string-literal,\
--modernize-use-trailing-return-type,\
--modernize-use-using,\
-performance-*,\
--performance-type-promotion-in-math-fn,\
-misc-*,\
--misc-macro-parentheses,\
--misc-misplaced-widening-cast,\
--misc-non-private-member-variables-in-classes,\
--misc-static-assert,\
--misc-unused-parameters,\
-readability-*,\
--readability-avoid-const-params-in-decls,\
--readability-else-after-return,\
--readability-function-size,\
--readability-identifier-naming,\
--readability-implicit-bool-conversion,\
--readability-inconsistent-declaration-parameter-name,\
--readability-isolate-declaration,\
--readability-magic-numbers,\
--readability-named-parameter,\
--readability-qualified-auto,\
--readability-uppercase-literal-suffix,\
-"
-WarningsAsErrors: ''
-HeaderFilterRegex: 'code/.*$|freespace2/.*$|qtfred/.*$|test/src/.*$|build/.*$'
-AnalyzeTemporaryDtors: false
-CheckOptions:
-  - key:          'misc-assert-side-effect.AssertMacros'
-    value:        'assert,Assert,Assertion'
-  - key:          'modernize-use-emplace.ContainersWithPushBack'
-    value:        'std::vector;std::deque;std::list;SCP_vector;SCP_deque;SCP_list'
-  - key:          'readability-braces-around-statements.ShortStatementLines'
-    value:        '4' # Avoid flagging simple if (...) return false; statements
-...
-

.dockerignore

@@ -1,2 +0,0 @@
-/build
-/.git

.drone.yml

@@ -1,21 +0,0 @@
-
-build:
-  image: teaci/msys$$arch
-  pull: true
-  shell: mingw$$arch
-  commands:
-    - git submodule update --init --recursive
-    - if [ $$arch = 32 ]; then target=i686; fi
-    - if [ $$arch = 64 ]; then target=x86_64; fi
-    - pacman -S --needed --noconfirm --noprogressbar mingw-w64-${target}-pkg-config mingw-w64-${target}-cmake
-    - mkdir build && cd build
-    - cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=$$CONFIGURATION -DFSO_USE_SPEECH=OFF -DFSO_USE_VOICEREC=OFF -DFSO_FATAL_WARNINGS=ON -DFSO_BUILD_FRED2=OFF ..
-    - make -j$(nproc) all
-
-matrix:
-  arch:
-    - 64
-    - 32
-  CONFIGURATION:
-    - Debug
-    - Release

.editorconfig

@@ -1,15 +0,0 @@
-root = true
-
-[*.{h,cpp}]
-indent_style = tab
-
-[*.sdr]
-indent_style = tab
-
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-[*.sh]
-indent_style = space
-indent_size = 4

.gitattributes

@@ -1,7 +0,0 @@
-# Default for everything
-# * text=auto
-
-# For the test data and built-in files to make them consistent on all platforms
-*.tbl text eol=lf
-*.tbm text eol=lf
-*.sdr text eol=lf

.github/CODEOWNERS

@@ -1,8 +0,0 @@
-
-cmake/ @asarium
-
-code/executor/ @asarium
-
-code/scpui/ @asarium
-
-code/scripting/ @asarium

.github/workflows/build-nightly.yaml

@@ -1,210 +0,0 @@
-name: Build Nightly package
-
-on:
-  push:
-    tags:
-      - 'nightly_*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
-            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
-            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
-            -G "Visual Studio 16 2019" -T "v142" ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2]
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly

.github/workflows/build-release.yaml

@@ -1,263 +0,0 @@
-name: Build Release package
-
-on:
-  push:
-    tags:
-      - 'release_*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  create_release:
-    name: Create GitHub release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false
-      - name: Store upload URL
-        run: |
-          echo -n "${{ steps.create_release.outputs.upload_url }}" > upload_url
-      - name: Persist upload URL
-        uses: actions/upload-artifact@v2
-        with:
-          name: upload_url
-          path: ${{ github.workspace }}/upload_url
-
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    needs: create_release
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download upload URL
-        uses: actions/download-artifact@v1
-        with:
-          name: upload_url
-          path: .
-      - name: Extract upload URL
-        id: extractUploadUrl
-        run: echo "::set-output name=upload_url::$(cat upload_url)"
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.package_path }}
-          asset_name: ${{ steps.generate_package.outputs.package_name }}
-          asset_content_type: ${{ steps.generate_package.outputs.package_mime }}
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2, AVX]
-    needs: create_release
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
-            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
-            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
-            -G "Visual Studio 16 2019" -T "v142" ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2, AVX]
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download upload URL
-        uses: actions/download-artifact@v1
-        with:
-          name: upload_url
-          path: .
-      - name: Extract upload URL
-        id: extractUploadUrl
-        run: echo "::set-output name=upload_url::$(cat upload_url)"
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.package_path }}
-          asset_name: ${{ steps.generate_package.outputs.package_name }}
-          asset_content_type: ${{ steps.generate_package.outputs.package_mime }}
-      - name: Upload debug symbols
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.debug_path }}
-          asset_name: ${{ steps.generate_package.outputs.debug_name }}
-          asset_content_type: ${{ steps.generate_package.outputs.debug_mime }}

.github/workflows/build-test.yaml

@@ -1,224 +0,0 @@
-name: Build Test package
-
-on:
-  push:
-    branches:
-      - 'test/*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
-            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
-            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
-            -G "Visual Studio 16 2019" -T "v142" ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2]
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test

.github/workflows/pr-workflow.yaml

@@ -1,153 +0,0 @@
-name: Check a pull request
-
-on: [pull_request]
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      fail-fast: false
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [gcc-5, gcc-10, clang-9]
-        cmake_options: [""]
-        include:
-          # Also include configurations that check if the code compiles without the graphics backends
-          - configuration: Debug
-            compiler: gcc-10
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          - configuration: Release
-            compiler: gcc-10
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-e977d36
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Run Clang Tidy
-        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang-')
-        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
-      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang-')
-        uses: asarium/clang-tidy-action@v1
-        with:
-          fixesFile: clang-fixes.yaml
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [MSVC]
-        arch: [Win32, x64]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - name: Prepare Environment
-        run: choco install ninja
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.compiler  == 'MSVC' && matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.compiler  == 'MSVC' && matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-                  -DFSO_BUILD_FRED2="OFF" -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
-          else
-              cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-                  -DMSVC_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "Visual Studio 16 2019" \
-                  -DFSO_BUILD_QTFRED=ON -T "v142" -A "$ARCHITECTURE" ..
-          fi
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake --build . --config "$CONFIGURATION"
-          else
-              cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          fi
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-             ./bin/unittests --gtest_shuffle
-          else
-              "./bin/$CONFIGURATION/unittests" --gtest_shuffle
-          fi

.github/workflows/standalone-image-workflow.yaml

@@ -1,48 +0,0 @@
-name: Publish Standalone docker image
-
-on:
-  push:
-    tags:
-    - '*'
-
-jobs:
-  build_images:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        include:
-        - configuration: FastDebug
-          latest_tag: latest_debug
-          nightly_tag: nightly_debug
-          release_tag: release_debug
-        - configuration: Release
-          latest_tag: latest
-          nightly_tag: nightly
-          release_tag: release
-      fail-fast: false
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-      name: Checkout
-      with:
-        submodules: true
-    - name: Docker login
-      run: echo ${{ secrets.DOCKER_ACCESSTOKEN }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
-    - name: Docker build
-      run: docker build --build-arg build_type=${{ matrix.configuration }} -f docker/standalone/Dockerfile -t ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} .
-
-    - name: Push latest tag
-      run: |
-        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }}
-
-    - name: Push nightly tag
-      if: contains(github.ref, 'refs/tags/nightly_')
-      run: |
-        docker tag ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.nightly_tag }}
-        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.nightly_tag }}
-
-    - name: Push release tag
-      if: contains(github.ref, 'refs/tags/release_')
-      run: |
-        docker tag ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.release_tag }}
-        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.release_tag }}

.gitignore

@@ -1,260 +0,0 @@
-#OS junk files
-[Tt]humbs.db
-*.DS_Store
-
-#Visual Studio files
-*.[Oo]bj
-*.user
-*.aps
-*.pch
-*.vspscc
-*.vssscc
-*_i.c
-*_p.c
-*.ncb
-*.suo
-*.tlb
-*.tlh
-*.bak
-*.[Cc]ache
-*.ilk
-*.log
-*.lib
-*.sbr
-*.sdf
-*.opensdf
-*.unsuccessfulbuild
-ipch/
-[Oo]bj/
-Ankh.NoLoad
-*.VC.db
-*.VC.VC.opendb
-
-#MonoDevelop
-*.pidb
-*.userprefs
-
-#Tooling
-_ReSharper*/
-*.resharper
-[Tt]est[Rr]esult*
-*.sass-cache
-
-#Project files
-[Bb]uild/
-
-#Subversion files
-.svn
-
-# Office Temp Files
-~$*
-
-# vim Temp Files
-*~
-
-#NuGet
-packages/
-*.nupkg
-
-#ncrunch
-*ncrunch*
-*crunch*.local.xml
-
-# visual studio database projects
-*.dbmdl
-
-#Test files
-*.testsettings
-
-#===========
-
-#########################
-# .gitignore file for Xcode4 and Xcode5 Source projects
-#
-# Apple bugs, waiting for Apple to fix/respond:
-#
-#    15564624 - what does the xccheckout file in Xcode5 do? Where's the documentation?
-#
-# Version 2.1
-# For latest version, see: http://stackoverflow.com/questions/49478/git-ignore-file-for-xcode-projects
-#
-# 2013 updates:
-# - fixed the broken "save personal Schemes"
-# - added line-by-line explanations for EVERYTHING (some were missing)
-#
-# NB: if you are storing "built" products, this WILL NOT WORK,
-# and you should use a different .gitignore (or none at all)
-# This file is for SOURCE projects, where there are many extra
-# files that we want to exclude
-#
-#########################
-
-#####
-# OS X temporary files that should never be committed
-#
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-.DS_Store
-
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-.Trashes
-
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-*.swp
-
-# *.lock - this is used and abused by many editors for many different things.
-#    For the main ones I use (e.g. Eclipse), it should be excluded
-#    from source-control, but YMMV
-
-*.lock
-
-#
-# profile - REMOVED temporarily (on double-checking, this seems incorrect; I can't find it in OS X docs?)
-#profile
-
-
-####
-# Xcode temporary files that should never be committed
-#
-# NB: NIB/XIB files still exist even on Storyboard projects, so we want this...
-
-*~.nib
-
-
-####
-# Xcode build files -
-#
-# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "DerivedData"
-
-DerivedData/
-
-# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "build"
-
-build/
-
-
-#####
-# Xcode private settings (window sizes, bookmarks, breakpoints, custom executables, smart groups)
-#
-# This is complicated:
-#
-# SOMETIMES you need to put this file in version control.
-# Apple designed it poorly - if you use "custom executables", they are
-#  saved in this file.
-# 99% of projects do NOT use those, so they do NOT want to version control this file.
-#  ..but if you're in the 1%, comment out the line "*.pbxuser"
-
-# .pbxuser: http://lists.apple.com/archives/xcode-users/2004/Jan/msg00193.html
-
-*.pbxuser
-
-# .mode1v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
-
-*.mode1v3
-
-# .mode2v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
-
-*.mode2v3
-
-# .perspectivev3: http://stackoverflow.com/questions/5223297/xcode-projects-what-is-a-perspectivev3-file
-
-*.perspectivev3
-
-#    NB: also, whitelist the default ones, some projects need to use these
-!default.pbxuser
-!default.mode1v3
-!default.mode2v3
-!default.perspectivev3
-
-
-####
-# Xcode 4 - semi-personal settings
-#
-#
-# OPTION 1: ---------------------------------
-#     throw away ALL personal settings (including custom schemes!
-#     - unless they are "shared")
-#
-# NB: this is exclusive with OPTION 2 below
-xcuserdata
-
-# OPTION 2: ---------------------------------
-#     get rid of ALL personal settings, but KEEP SOME OF THEM
-#     - NB: you must manually uncomment the bits you want to keep
-#
-# NB: this *requires* git v1.8.2 or above; you may need to upgrade to latest OS X,
-#    or manually install git over the top of the OS X version
-# NB: this is exclusive with OPTION 1 above
-#
-#xcuserdata/**/*
-
-#     (requires option 2 above): Personal Schemes
-#
-#!xcuserdata/**/xcschemes/*
-
-####
-# XCode 4 workspaces - more detailed
-#
-# Workspaces are important! They are a core feature of Xcode - don't exclude them :)
-#
-# Workspace layout is quite spammy. For reference:
-#
-# /(root)/
-#   /(project-name).xcodeproj/
-#     project.pbxproj
-#     /project.xcworkspace/
-#       contents.xcworkspacedata
-#       /xcuserdata/
-#         /(your name)/xcuserdatad/
-#           UserInterfaceState.xcuserstate
-#     /xcsshareddata/
-#       /xcschemes/
-#         (shared scheme name).xcscheme
-#     /xcuserdata/
-#       /(your name)/xcuserdatad/
-#         (private scheme).xcscheme
-#         xcschememanagement.plist
-#
-#
-
-####
-# Xcode 4 - Deprecated classes
-#
-# Allegedly, if you manually "deprecate" your classes, they get moved here.
-#
-# We're using source-control, so this is a "feature" that we do not want!
-
-*.moved-aside
-
-# .xccheckout
-#
-# Per http://stackoverflow.com/questions/18340453/should-xccheckout-files-in-xcode5-be-ignored-under-vcs
-#
-
-*.xccheckout
-
-####
-# Visual Studio Code
-.vscode
-
-####
-# Documentation
-#
-documentation/doxygen/*
-!documentation/doxygen/.gitkeep
-
-
-.idea/*
-projects/*
-/.vs
-CMakeSettings.json
-
-# Weird files created by Linux
-.fuse_hidden*
-
-# This gets ignored by one of the rules above for some reason...
-!/code/scripting/lua/LuaConvert.h
-!/code/debugconsole/
-!/docker/build

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "cmake/external/rpavlik-cmake-modules"]
-	path = cmake/external/rpavlik-cmake-modules
-	url = https://github.com/asarium/cmake-modules.git
-[submodule "lib/libRocket"]
-	path = lib/libRocket
-	url = https://github.com/asarium/libRocket.git

.travis.yml

@@ -1,175 +0,0 @@
-language: bash
-sudo: required
-dist: xenial
-cache:
-  directories:
-    - $HOME/cmake-3.8
-    - $HOME/.ccache
-    - $HOME/curl_cache
-addons:
-  apt:
-    packages: &global_deps
-      - ninja-build
-      - libopenal-dev
-      - libreadline6-dev
-      - libpng12-dev
-      - libjpeg62-dev
-      - liblua5.1-0-dev
-      - libjansson-dev
-      - libsdl2-dev
-      - libfreetype6-dev
-      - qt57base
-  coverity_scan:
-    project:
-      name: "scp-fs2open/fs2open.github.com"
-    notification_email: [email protected]
-    build_command:   "ci/travis/script.sh"
-    # must match TRAVIS_BRANCH check below
-    branch_pattern: coverity_scan
-env:
-  global:
-    # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
-    #   via the "travis encrypt" command using the project repo's public key
-    #   also note that fork's don't get access to secure keys
-    #   you have to test using a branch in the main repo
-    - secure: "C3wF967ZeliwwP1vC12EMIBOaC568n26Z/cPnwzn317ve59DWH3YSfPZVgvt08GzmaXITGGsJvPB+qxfGoKvQzYE4O1B73q81RpUe5pB3IhF+ThQ91VfQZIRJR5xEGJaLINUlHTTZGX5jxlkVO9wAcauVj/s3b8sQ3dvUZauPvk="
-    # These declarations set INDIEGAMES_USER and INDIEGAMES_PASSWORD for uploading nightly builds to the indiegames server
-    - secure: "lUuRu8XIi8MKNf1ebOfyC4iVEpPyASojJIDWXRo2bNqEF4ILAljXdkVeXeN6H5yKCHD52cxCNTtyePIG/o3p3QEuGSVud9bDS3D7LaQicLETGGrsw3l07U49gF2OKHXGopg0MzBbZUU9QmhoFTAe8t6PV9NDuEayYCheqvTqjZg="
-    - secure: "E/DHLYcPK/hBUqxBYYlUqp5sjgvIqY5A0qRHyQ4bmjsB+WB/Xx71bGCSiF7hk6lTxar1ZI1i5RAXXh9AIvNVaYAIdEOlCP+q3gvwCYuc5naZEKmkxlUCf0oEL4O9Fye93A/3VkFHuBdC1TGPYYf69m4W5r4367wWO9dPRIdWpJA="
-    # These declarations set DATACORDER_USER and DATACORDER_PASSWORD
-    - secure: "dpBH/dDN3bmU/NFlh+2v9isNx9wX0ocoRy+W+kBXRH32sosUGp26REhMqgVRpBNP5oxPBU8ic5bEogxAYWCB+0xUygBbkxAwyMPgoA34s0OXdTCY/ofw14ni8qqV2Ffy7fQJbP/jkMURyiMHx3kBTxNv3YjxKJqLnOuOMlQLpT8="
-    - secure: "tLMRBD1Ufp5iKNwlqPDVbbuczgusaXNoBJyAnPATpJq2YwlkW4j3PqP9rW5vd85+52xam2EOP20w9PoBR5J6FLdiXRu4Lf7yCEhSHFAgowVqQj8QcJpPlyXr90bM4emFGrGqpdxVwxyQ5AFhKwLuEZKsI14GYLN+UMEwpNCMing="
-deploy:
-  - provider: releases
-    api_key:
-      secure: "q619+eQTe7lv8UVphK4OIzU8Jw84KBbVkuprN2sWIubRcV3IbZr2+WahJoUMt+nyhiy3YjDYtstO2ZgkxupwnZgwGUBVIiD1c4SPuyy+HTjNMOtiVsEUHT2hf+xPAemWpTlK5HcwhMmHAOh6rt6dEj57QOg0gcmGiwD/tCbEriA="
-    skip_cleanup: true
-    file_glob: true
-    file: "/tmp/builds/*"
-    on:
-      condition: '"$RELEASE_BUILD" == true'
-      tags: true
-
-  - provider: script
-    script: bash ci/travis/ftp_deploy.sh
-    on:
-      condition: '"$NIGHTLY_BUILD" == true'
-      tags: true
-
-  - provider: script
-    skip_cleanup: true
-    script: bash ci/travis/ftp_deploy.sh
-    on:
-      condition: $TEST_BUILD = true
-      all_branches: true
-
-matrix:
-  include:
-    # note that gcc Debug MUST be 1st for Coverity
-    - os: linux
-      env: CONFIGURATION="Debug" CC=gcc-5 CXX=g++-5
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
-          packages:
-            - *global_deps
-            - g++-5
-    - os: linux
-      env: CONFIGURATION="Debug" CC=gcc-9 CXX=g++-9
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
-          packages:
-            - g++-9
-            - *global_deps
-    - os: linux
-      env: CONFIGURATION="Debug" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
-          packages:
-            - *global_deps
-            - g++-9
-      script:
-        - ./ci/travis/script.sh
-        - ./ci/travis/clang_tidy.sh
-    - os: osx
-      env: CONFIGURATION="Debug"
-
-    - os: windows
-      env: CONFIGURATION="Debug" CMAKE_TOOLSET=v141 CMAKE_GENERATOR="Visual Studio 15 2017"
-    - os: windows
-      env: CONFIGURATION="Debug" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
-
-    - os: linux
-      env: CONFIGURATION="Release" CC=gcc-5 CXX=g++-5
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
-          packages:
-            - *global_deps
-            - g++-5
-    - os: linux
-      env: CONFIGURATION="Release" CC=gcc-9 CXX=g++-9
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
-          packages:
-            - g++-9
-            - *global_deps
-    - os: linux
-      env: CONFIGURATION="Release" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
-          packages:
-            - *global_deps
-            - g++-9
-      script:
-        - ./ci/travis/script.sh
-        - ./ci/travis/clang_tidy.sh
-    - os: osx
-      env: CONFIGURATION="Release"
-
-    - os: windows
-      env: CONFIGURATION="Release" CMAKE_TOOLSET=v141 CMAKE_GENERATOR="Visual Studio 15 2017"
-    - os: windows
-      env: CONFIGURATION="Release" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
-  # There is a GCC compiler bug with MinGW that causes compilation failures on Windows at the moment
-  allow_failures:
-    - os: windows
-      env: CONFIGURATION="Debug" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
-    - os: windows
-      env: CONFIGURATION="Release" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
-  fast_finish: true
-
-before_install:
-  # ugly hack; if running a coverity scan abort all except the 1st build
-  # see note re gcc compiler above needing to be 1st
-  # also note that branch_pattern & the TRAVIS_BRANCH check must match
-  # unfortunately COVERITY_SCAN_BRANCH isn't defined until later in the
-  # build process
-  - if ([[ "${TRAVIS_JOB_NUMBER##*.}" != "1" ]] && [[ "${TRAVIS_BRANCH}" == "coverity_scan" ]]); then false ; fi
-  - source "./ci/travis/check_release.sh"
-  - "./ci/travis/before_install.sh"
-install:
-  - if [ "$TRAVIS_OS_NAME" = "windows" ]; then export PATH="/c/Program Files/CMake/bin":$PATH; fi
-  - "./ci/travis/install.sh"
-  - export PATH=$HOME/cmake-3.6/bin:$PATH
-before_script:
-  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then QT_ENV_SCRIPT=$(find /opt -name 'qt*-env.sh'); source $QT_ENV_SCRIPT; fi
-  - "./ci/travis/before_script.sh"
-script:
-  - if [ "$BUILD_DEPLOYMENT" = true ] ; then ./ci/travis/release.sh ; else ./ci/travis/script.sh ; fi

About.md

@@ -1,41 +0,0 @@
-## FreeSpace
-FreeSpace: The Great War (Released 1998) and FreeSpace 2 (1999) are mission-based space combat simulators, like X-Wing/TIE Fighter and Wing Commander. Among the greatest games of the genre, they were also effectively the last.
-
-The FreeSpace series follows humanity and their Vasudan allies as they fight to withstand the xenocidal, enigmatic Shivans, a species of unknown origin, vast technological capability, and seemingly limitless malice.
-
-## FreeSpace Open
-Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-
-## Hard-Light Productions
-HLP is a fan community built on love and open-source code. We're dedicated to bringing modders together and giving them a place to share their own hard work and draw inspiration from the work of others. Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-Find us at:
- - Our [website](http://www.hard-light.net/) and [forums](http://www.hard-light.net/forums/)
- - [Discord](https://discord.gg/YNVP3WR)
- - [Facebook](https://www.facebook.com/groups/Hardlightproductions/)
- - [Youtube](https://www.youtube.com/channel/UCxKkd609hDtY6yNetR1iT4w)
- - [Reddit](https://www.reddit.com/r/freespace/)
- - [Twitter](https://twitter.com/hardlightpro)
- - [IRC](irc://irc.esper.net/hard-light)
-
-
-## How to get the game
-FreeSpace Open requires a retail installation of FreeSpace 2, which is available at the following stores: 
- - [GOG.com](https://www.gog.com/game/freespace_2)
- - [Steam](https://store.steampowered.com/app/273620/Freespace_2/)  
-After installing retail FS2, use [Knossos](https://fsnebula.org/knossos/) to upgrade to the most recent release of FSO. Knossos is an advanced mod manager and launcher for FSO.
-
-## Improvements
-The new open source game engine has several distingushing features including:
- - Linux and Mac OS X support
- - OpenGL support
- - OpenAL audio support
- - Easy mod installation
- - OGG support
- - Hardware transform, clipping, and lighting
-
-## The FreeSpace Upgrade Project
-While the SCP improves the code of the game engine to enable new and exciting features, the FreeSpace Upgrade Project (FSU) creates material that takes advantage of the improved game engine.  
-The FSU improves the ships, effects, and background elements of FreeSpace 2. Every now and then these improvements are released as a pack called MediaVPs. These assorted improvements enhance the graphics of the game.  
-While the best way to experience the FSU is by playing the game with it, you can watch this [comparison video](https://www.youtube.com/watch?v=RM1YC_gK-qo) between 1999 and 2019 to have an idea of how much more beautiful FSU makes the game.
-
-^(Much of this content was pulled from existing sources, such as InsaneBaron's "What Is Hard Light Productions" [thread](https://www.hard-light.net/forums/index.php?topic=86650.0), the Wiki's [Getting Started article](https://wiki.hard-light.net/index.php/Getting_started) and more.) 

Authors.md

@@ -1,8 +0,0 @@
-Original source (Freespace 2) by Volition, Inc.; see "`credits.tbl`"
-
-Modifications by the FreeSpace 2 Source Code Project [(FSO SCP)](https://www.hard-light.net/forums/index.php?board=50.0)   
-[Project Contributors](https://github.com/scp-fs2open/fs2open.github.com/graphs/contributors)
-
-Special thanks to:
-Volition for making FS2 such a great game
-Dave Baranec for giving us the code and keeping us sanity checked

CMakeLists.txt

@@ -1,223 +0,0 @@
-
-CMAKE_MINIMUM_REQUIRED(VERSION 3.4)
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-# Make sure the source and binary directory are not the sample
-if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
-	message(FATAL_ERROR "Binary and source directory can not be the same! Choose another build directory.")
-endif()
-
-include(cmake/util.cmake)
-include(cmake/embed_file.cmake)
-
-# Set a few policies
-set_policy(CMP0051 NEW)
-set_policy(CMP0053 NEW)
-set_policy(CMP0054 NEW)
-
-SET(FSO_PROJECT_DESCRIPTION "Open source project based on the original FreeSpace 2 source code.")
-
-SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Executable output path")
-SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Library output path")
-
-# CMAKE_INSTALL_PREFIX is defined but also overwritten by the PROJECT command so we need to set it later
-IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
-	SET(RESET_INSTALL_PREFIX TRUE)
-ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
-
-# Reset this variable
-SET(TARGET_COPY_FILES "" CACHE INTERNAL "" FORCE)
-SET(TARGET_COPY_DIRS "" CACHE INTERNAL "" FORCE)
-
-### Define options and editable variables in the section below:
-# This is only needed for single configuration generators so don't annoy others
-if(NOT CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
-	set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Default build configuration used." FORCE)
-	message(WARNING "CMAKE_BUILD_TYPE was not specified, defaulting to Release configuration.")
-endif(NOT CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
-
-# Override standard CMake configurations
-set(CMAKE_CONFIGURATION_TYPES Debug Release FastDebug CACHE STRING "Available configurations" FORCE)
-
-PROJECT(FS2_Open)
-
-find_program(CCACHE_PROGRAM ccache)
-# Currently only GCC support ccache properly without generating additional warnings
-if(CCACHE_PROGRAM AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	if(NOT CMAKE_C_COMPILER_LAUNCHER)
-		message(STATUS "Using ccache for C compilation: ${CCACHE_PROGRAM}")
-		SET(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
-	endif()
-	if(NOT CMAKE_CXX_COMPILER_LAUNCHER)
-		message(STATUS "Using ccache for C++ compilation: ${CCACHE_PROGRAM}")
-		SET(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
-	endif()
-endif()
-
-IF(CMAKE_CROSSCOMPILING)
-	SET(IMPORT_EXE_DIR "IMPORT_EXE_DIR-NOTFOUND" CACHE FILEPATH "Required for a cross compiling build, point to binary directory of a cmake build for the real OS")
-	INCLUDE(${IMPORT_EXE_DIR}/ImportExecutables.cmake)
-ENDIF(CMAKE_CROSSCOMPILING)
-
-# Check if the external modules exists
-IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules/launcher-templates")
-	message(FATAL_ERROR "External submodules could not be found. Please make sure you have updated your submodules.")
-endif()
-
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/finder")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/cotire")
-
-IF(RESET_INSTALL_PREFIX)
-	IF(NOT $ENV{FS2PATH} STREQUAL "")
-		IF(NOT IS_DIRECTORY $ENV{FS2PATH})
-			MESSAGE(WARNING "The path '$ENV{FS2PATH}' of the environment variable FS2PATH does not point to a directory! Install prefix wasn't set.")
-		ELSE(NOT IS_DIRECTORY $ENV{FS2PATH})
-			SET(CMAKE_INSTALL_PREFIX "$ENV{FS2PATH}" CACHE FILEPATH "Install path" FORCE)
-			FILE(TO_CMAKE_PATH ${CMAKE_INSTALL_PREFIX} CMAKE_INSTALL_PREFIX)
-		ENDIF(NOT IS_DIRECTORY $ENV{FS2PATH})
-	ELSE(NOT $ENV{FS2PATH} STREQUAL "")
-		MESSAGE(STATUS "NO FS2PATH environment variable found, you can define this to point to your freespace install but it is not required.")
-	ENDIF(NOT $ENV{FS2PATH} STREQUAL "")
-ENDIF(RESET_INSTALL_PREFIX)
-
-IF (WIN32)
-	OPTION(FSO_USE_SPEECH "Use Windows specific text-to-speach libraries" ON)
-
-	OPTION(FSO_USE_VOICEREC "Enable voice recognition support" ON)
-
-	OPTION(FSO_BUILD_FRED2 "Build FRED2 binary" ON)
-elseif(UNIX)
-	option(FSO_BUILD_APPIMAGE "Build an AppImage package" OFF)
-ENDIF(WIN32)
-
-OPTION(FSO_BUILD_TOOLS "Build tools related to FSO" OFF)
-
-OPTION(FSO_BUILD_TESTS "Build unit tests" OFF)
-
-OPTION(FSO_DEVELOPMENT_MODE "Generate binaries in development mode, only use if you know what you're doing!" OFF)
-
-OPTION(FSO_BUILD_QTFRED "Build qtFRED2 binary" OFF)
-
-IF(WIN32 OR APPLE)
-	# On windows and mac the default should be to always build the included libraries
-	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT ON)
-ELSE()
-	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT OFF)
-ENDIF()
-
-OPTION(FSO_BUILD_INCLUDED_LIBS "Build and use the included libraries istead of using the system headers and libraries" ${FSO_BUILD_INCLUDED_LIBS_DEFAULT})
-
-OPTION(FSO_USE_LUAJIT "Use LuaJIT for Lua scripting, needs a working internet connection!" OFF)
-
-OPTION(FSO_USE_OPENALSOFT "Download and build OpenAL Soft instead of using the system libraries" OFF)
-
-OPTION(FSO_FATAL_WARNINGS "Determines if warnings in the build are considered fatal errors, primarily used for CI" OFF)
-
-SET(FSO_FREESPACE_PATH "${CMAKE_INSTALL_PREFIX}" CACHE FILEPATH "The path of the FreeSpace directory you want to use. Please note that you will have to change CMAKE_INSTALL_PREFIX if you change this at some point.")
-
-SET(FSO_RUN_ARGUMENTS "" CACHE STRING "Additional arguments passed to a generated executable when run with the generated build files.")
-
-option(FSO_INSTALL_DEBUG_FILES "Install some debug files (currently only PDB files on windows)" OFF)
-
-option(ENABLE_COTIRE "Enable cotire for faster compilation. Enabled by default." ON)
-
-option(FSO_RELEASE_LOGGING "Enable logging output for release builds" OFF)
-
-OPTION(FSO_BUILD_WITH_FFMPEG "Enable the usage of FFmpeg for sound and custscenes" ON)
-
-OPTION(FSO_BUILD_WITH_OPENGL "Enable compilation of the OpenGL renderer" ON)
-
-OPTION(FSO_BUILD_WITH_VULKAN "Enable compilation of the Vulkan renderer" ON)
-
-MARK_AS_ADVANCED(FORCE FSO_CMAKE_DEBUG)
-MARK_AS_ADVANCED(FORCE FSO_BUILD_INCLUDED_LIBS)
-MARK_AS_ADVANCED(FORCE FSO_USE_OPENALSOFT)
-MARK_AS_ADVANCED(FORCE FSO_USE_LUAJIT)
-MARK_AS_ADVANCED(FORCE FSO_DEVELOPMENT_MODE)
-MARK_AS_ADVANCED(FORCE FSO_FATAL_WARNINGS)
-mark_as_advanced(FORCE FSO_INSTALL_DEBUG_FILES)
-mark_as_advanced(FORCE ENABLE_COTIRE)
-mark_as_advanced(FORCE FSO_RELEASE_LOGGING)
-mark_as_advanced(FORCE FSO_BUILD_WITH_FFMPEG)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL)
-mark_as_advanced(FORCE FSO_BUILD_WITH_VULKAN)
-
-# Include cotire file from https://github.com/sakra/cotire/
-include(cotire)
-
-INCLUDE(globals)
-INCLUDE(toolchain)
-INCLUDE(platforms)
-include(version)
-
-INCLUDE(headers)
-
-SET(GENERATED_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated_source)
-
-include(generateHeaders)
-
-if(FSO_BUILD_APPIMAGE)
-	include(appimage)
-endif()
-
-include(clang-tidy)
-
-# This includes source code for some tools, either used in the build or also for something else
-ADD_SUBDIRECTORY(tools)
-
-ADD_SUBDIRECTORY(lib)
-
-ADD_SUBDIRECTORY(parsers)
-
-ADD_SUBDIRECTORY(code)
-
-ADD_SUBDIRECTORY(freespace2)
-
-IF(FSO_BUILD_FRED2)
-	ADD_SUBDIRECTORY(fred2)
-ENDIF(FSO_BUILD_FRED2)
-
-IF(FSO_BUILD_QTFRED)
-	ADD_SUBDIRECTORY(qtfred)
-ENDIF()
-
-if(FSO_BUILD_TESTS)
-	add_subdirectory(test)
-endif()
-
-if ("${CMAKE_VERSION}" VERSION_GREATER "3.5")
-	# Default to using Freespace2 as startup project if CMake supports it.
-	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT Freespace2)
-endif()
-
-IF(MSVC_USE_RUNTIME_DLL)
-	SET(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION "${BINARY_DESTINATION}")
-
-	IF(FSO_BUILD_FRED2)
-		SET(CMAKE_INSTALL_MFC_LIBRARIES ON)
-	ENDIF(FSO_BUILD_FRED2)
-
-	INCLUDE(InstallRequiredSystemLibraries)
-ENDIF(MSVC_USE_RUNTIME_DLL)
-
-include(package)
-
-include(doxygen)
-
-# Print used options to log
-IF (WIN32)
-	message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
-	message(STATUS "Using voice recogition: ${FSO_USE_VOICEREC}")
-	message(STATUS "Building FRED2: ${FSO_BUILD_FRED2}")
-elseif(UNIX)
-	message(STATUS "Building AppImage: ${FSO_BUILD_APPIMAGE}")
-ENDIF()
-message(STATUS "Building FSO tools: ${FSO_BUILD_TOOLS}")
-message(STATUS "Building qtFRED: ${FSO_BUILD_QTFRED}")
-message(STATUS "Fatal warnings: ${FSO_FATAL_WARNINGS}")
-message(STATUS "Release logging: ${FSO_RELEASE_LOGGING}")
-message(STATUS "With FFmpeg: ${FSO_BUILD_WITH_FFMPEG}")
-message(STATUS "With OpenGL: ${FSO_BUILD_WITH_OPENGL}")
-message(STATUS "With Vulkan: ${FSO_BUILD_WITH_VULKAN}")

Copying.md

@@ -1,22 +0,0 @@
-Volition Copyright (applies to original FreeSpace2 source code
-developed and released by Volition):
-
->Copyright (C) Volition, Inc. 1999.  All rights reserved.
->
->All source code herein is the property of Volition, Inc. You may not
-sell or otherwise commercially exploit the source or things you
-created based on the source.
-
-
-Modifications by members of the FreeSpace Source Code Project are
-released under whatever terms the individual authors choose, but the
-above notice continues to apply to all fs2_open code.
-
-All modifications made on or after November 1, 2020, shall be released under 
-the terms within [Unlicense](Unlicense.md). Modifications made before said date are released 
-under the previous terms with the exception of modifications made by members 
-of the FreeSpace Source Code Project that opt-in to the terms of Unlicense. Additionally, 
-a list of contributors who have opted in to the Unlicense terms can be found 
-in [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing).
-
-See [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing) for more information.

Readme.md

@@ -1,11 +0,0 @@
-FreeSpace2 *S*ource *C*ode *P*roject
-==
-[![Travis-CI Build Status](https://travis-ci.org/scp-fs2open/fs2open.github.com.svg?branch=master)](https://travis-ci.org/scp-fs2open/fs2open.github.com)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/scp-fs2open/fs2open.github.com?branch=master&svg=true)](https://ci.appveyor.com/project/SirKnightly/fs2open-github-com/branch/master)
-[![Coverity](https://img.shields.io/coverity/scan/870.svg)](https://scan.coverity.com/projects/870)
-
-Building
---
-Before you do anything, make sure you have updated your git submodules, either by running `git submodule update --init --recursive` or by cloning the repository with the `--recursive` flag.<br/>
-
-The main instructions for building can be found at our github wiki, on the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) page.

Unlicense.md

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to [**Unlicense**](https://unlicense.org).

UpdatingDocumentation.md

@@ -1,18 +0,0 @@
-#Updating Documentation
-####The goal of this file is simply to offer a comprehensive checklist of things we must check when updating the documentation.
-
-1. Changelog: 
- - Is [Changelog.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Changelog.md) up-to-date with the latest release?
- - Is it in the proper [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format? 
-2. Build instructions:  
- - If a programmer who never built FSO before read the build instruction at [Readme.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Readme.md), would they manage to build FSO? 
- - Is the information in the file up-to-date regarding other matters (such as versions of tools mentioned, links to other guides, etc.)?
- - Is the information in the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) article, and its sub-articles, still up-to-date?
-3. Forums: 
- - Does the [Forum](https://www.hard-light.net/forums/index.php?board=50.0) contain enough clear information to help a new developer find their way into the up-to-date instructions?
- - Is there anything that might mislead a new developer to stumble onto old tools, dead links and/or old versions of the project?
-4. General documentation files: 
- - Is the information in the following files up-to-date? 
-   - [About.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/About.md) (Should contain general information about FS, FS2, HLP, FSO and FSU)
-   - [Authors.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Authors.md) (Should contain information about the original developers, a way to see FSO's contributors, and special thanks to Volition and Dave Baranec)
-   - [Copying.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Copying.md) (Should contain Volition's Copyright terms and a way to check FSO's Licensing info)

appveyor.yml

@@ -1,62 +0,0 @@
-version: 1.0.0.{build}
-image: Visual Studio 2015
-configuration:
-  - Debug
-  - Release
-clone_depth: 10
-environment:
-  matrix:
-    - BuildID: 0
-      CMAKE_GENERATOR: Visual Studio 14 2015
-      PlatformToolset: v140
-      QT_DIR: C:\Qt\5.9\msvc2015
-    - BuildID: 1
-      CMAKE_GENERATOR: Visual Studio 14 2015 Win64
-      PlatformToolset: v140
-      QT_DIR: C:\Qt\5.9\msvc2015_64
-before_build:
-  - git submodule update --init --recursive
-build_script:
-  - ps: . $Env:APPVEYOR_BUILD_FOLDER/ci/appveyor/build.ps1
-test_script:
-  - ps: . $Env:APPVEYOR_BUILD_FOLDER/ci/appveyor/test.ps1
-
-deploy:
-    - provider: GitHub
-      auth_token:
-          secure: h55Scpy+3vmo1Yb7WlSIGA4d9DRnsbzUYc2LYsQdByQHZHbqrqjBpicH0D2FFLEO
-      on:
-          ReleaseBuild: true        # deploy on release push only
-
-    - provider: FTP
-      protocol: sftp
-      host: scp.indiegames.us
-      username:
-        secure: SFivQZfatqWHXK1ijYK3GQ==
-      password:
-        secure: q6Zk/412o1ri+NEya1dl1Q==
-      folder: public_html/builds/nightly/$(VersionName)
-      on:
-          NightlyBuild: true        # deploy on nightly push only
-
-    - provider: FTP
-      protocol: sftp
-      host: porphyrion.feralhosting.com
-      username:
-        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
-      password:
-        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
-      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$(VersionName)
-      on:
-          NightlyBuild: true        # deploy on nightly push only
-
-    - provider: FTP
-      protocol: sftp
-      host: porphyrion.feralhosting.com
-      username:
-        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
-      password:
-        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
-      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$(VersionName)
-      on:
-          TestBuild: true        # deploy on test build push only

ci/appveyor/build.ps1

@@ -1,164 +0,0 @@
-
-class BuildConfig {
-	[string]$Generator
-	[string]$PackageType
-	[string]$Toolset
-	[string]$SimdType
-	[string]$QtDir
-	[Bool]$SourcePackage
-}
-
-$NightlyConfigurations = @(
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015 Win64";
-#		PackageType="Win64";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015_64";
-#		SourcePackage=$false;
-#	},
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015";
-#		PackageType="Win32";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015";
-#		SourcePackage=$false;
-#	}
-)
-$ReleaseConfigurations = @(
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015";
-#		PackageType="Win32";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015";
-#		SourcePackage=$true;
-#	}
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015";
-#		PackageType="Win32-AVX";
-#		Toolset="v140";
-#		SimdType="AVX";
-#		QtDir="C:\Qt\5.9\msvc2015";
-#		SourcePackage=$false;
-#	}
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015 Win64";
-#		PackageType="Win64";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015_64";
-#		SourcePackage=$false;
-#	}
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015 Win64";
-#		PackageType="Win64-AVX";
-#		Toolset="v140";
-#		SimdType="AVX";
-#		QtDir="C:\Qt\5.9\msvc2015_64";
-#		SourcePackage=$false;
-#	}
-)
-
-$BuildConfigurations = $null
-
-# Default values
-$ReleaseBuild = $false
-$NightlyBuild = $false
-$TestBuild = $false
-
-# Set to true to test either the release or the nightly part of this script
-$ReleaseTest = $false
-$NightlyTest = $false
-$TestBuildTest = $false
-
-if ($ReleaseTest -Or ([System.Convert]::ToBoolean($env:APPVEYOR_REPO_TAG) -And ("$env:APPVEYOR_REPO_TAG_NAME" -match "^release_(.*)"))) {
-    # Tag matches
-    $ReleaseBuild = $true
-    $PackageName = "fs2_open_$($matches[1])"
-	$BuildConfigurations = $ReleaseConfigurations
-}
-
-if ($NightlyTest -Or ([System.Convert]::ToBoolean($env:APPVEYOR_REPO_TAG) -And ("$env:APPVEYOR_REPO_TAG_NAME" -match "^nightly_(.*)"))) {
-    # Tag matches
-    $NightlyBuild = $true
-    $PackageName = "nightly_$($matches[1])"
-	Set-AppveyorBuildVariable 'VersionName' "$($matches[1])"
-	$BuildConfigurations = $NightlyConfigurations
-}
-
-if ($TestBuildTest -Or ([System.Convert]::ToInt32($env:APPVEYOR_PULL_REQUEST_NUMBER) -le 0 -And ("$env:APPVEYOR_REPO_BRANCH" -match "^test\/(.*)"))) {
-    # Tag matches
-    $TestBuild = $true
-    $PackageName = "test_$($matches[1])"
-	Set-AppveyorBuildVariable 'VersionName' "$($matches[1])"
-	$BuildConfigurations = $NightlyConfigurations
-
-    # Override the revision string so that the builds are named correctly
-	[System.IO.File]::WriteAllLines("$env:APPVEYOR_BUILD_FOLDER/version_override.cmake", "set(FSO_VERSION_REVISION_STR $env:VersionName)")
-}
-
-# Multiply by 2 so that we can add 0 or 1 for debug or release Configs
-$buildID = [convert]::ToInt32($env:BuildID) * 2
-if ($Env:Configuration -eq "Release") {
-    $buildID = $buildID + 1
-}
-
-$DeployBuild = $false
-if ($ReleaseBuild -Or $NightlyBuild -Or $TestBuild) {
-    $DeployBuild = $true
-}
-
-Set-AppveyorBuildVariable 'ReleaseBuild' "$ReleaseBuild"
-Set-AppveyorBuildVariable 'NightlyBuild' "$NightlyBuild"
-Set-AppveyorBuildVariable 'TestBuild' "$TestBuild"
-
-New-Item build -type directory
-Set-Location -Path build
-
-if ($DeployBuild) {
-	# Release build
-	if ($buildID -ge $BuildConfigurations.Length) {
-		# Not needed
-        exit 0
-	}
-
-	$buildConfig = $BuildConfigurations[$buildID]
-
-	if ($buildConfig.SourcePackage -eq $True) {
-		7z a -xr'!.git' "$($PackageName)-source-Win.zip" "$env:APPVEYOR_BUILD_FOLDER"
-		Push-AppveyorArtifact "$($PackageName)-source-Win.zip"
-	}
-	
-	cmake -DCMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER/../install" -DFSO_USE_SPEECH="ON" `
-		-DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$($buildConfig.SimdType)" `
-		-DQT5_INSTALL_ROOT="$($buildConfig.QtDir)" -DFSO_BUILD_QTFRED=ON `
-		-DFSO_INSTALL_DEBUG_FILES="ON" `
-		-G "$($buildConfig.Generator)" -T "$($buildConfig.Toolset)" ..
-
-	$Configs = @("Release", "FastDebug")
-	foreach ($config in $Configs) {
-		cmake --build . --config "$config" --target INSTALL -- /verbosity:minimal
-		if (! ($?)) {
-			Add-AppveyorMessage "A release build failed!"
-			exit 1
-    	}
-	}
-
-    7z a -xr'!*.pdb' "$($PackageName)-builds-$($buildConfig.PackageType).zip" "$env:APPVEYOR_BUILD_FOLDER/../install/*"
-    Push-AppveyorArtifact "$($PackageName)-builds-$($buildConfig.PackageType).zip"
-
-	7z a "$($PackageName)-debug-$($buildConfig.PackageType).7z" "$env:APPVEYOR_BUILD_FOLDER/../install/*.pdb"
-	Push-AppveyorArtifact "$($PackageName)-debug-$($buildConfig.PackageType).7z"
-} else {
-	cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="ON" -DFSO_BUILD_TESTS="ON" -DMSVC_SIMD_INSTRUCTIONS=SSE2 `
-	-DFSO_BUILD_QTFRED=ON -DQT5_INSTALL_ROOT="$env:QT_DIR" -DFSO_BUILD_FRED2="ON" `
-	-G "$Env:CMAKE_GENERATOR" -T "$Env:PlatformToolset" ..
-
-    cmake --build . --config "$Env:CONFIGURATION" -- /verbosity:minimal
-
-    if (! ($?)) {
-        exit 1
-    }
-}

ci/appveyor/test.ps1

@@ -1,13 +0,0 @@
-
-if ([System.Convert]::ToBoolean($env:ReleaseBuild) -Or [System.Convert]::ToBoolean($env:NightlyBuild) -Or [System.Convert]::ToBoolean($env:TestBuild)) {
-    # Skip tests for deployment
-    exit 0
-} else {    
-    write "Running unit tests..."
-    # Run unit tests
-    &"$pwd\bin\$Env:CONFIGURATION\unittests.exe" --gtest_shuffle 2>&1
-
-    if (! ($?)) {
-        exit 1
-    }
-}

ci/bintray.template.json

@@ -1,19 +0,0 @@
-{
-    "package": {
-        "subject": "scp-fs2open",
-        "repo": "FSO",
-        "name": "nightly"
-    },
-
-    "version": {
-        "name": "$VERSION_NAME"
-    },
-
-    "files": [
-        {
-            "includePattern": "/tmp/builds/(.*)",
-            "uploadPattern": "$1"
-        }
-    ],
-    "publish": true
-}

ci/linux/clang-tidy-diff.py

@@ -1,268 +0,0 @@
-#!/usr/bin/env python3
-#
-#===- clang-tidy-diff.py - ClangTidy Diff Checker ------------*- python -*--===#
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===------------------------------------------------------------------------===#
-
-r"""
-ClangTidy Diff Checker
-======================
-
-This script reads input from a unified diff, runs clang-tidy on all changed
-files and outputs clang-tidy warnings in changed lines only. This is useful to
-detect clang-tidy regressions in the lines touched by a specific patch.
-Example usage for git/svn users:
-
-  git diff -U0 HEAD^ | clang-tidy-diff.py -p1
-  svn diff --diff-cmd=diff -x-U0 | \
-      clang-tidy-diff.py -fix -checks=-*,modernize-use-override
-
-"""
-
-import argparse
-import glob
-import json
-import multiprocessing
-import os
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-import threading
-import traceback
-
-try:
-    import yaml
-except ImportError:
-    yaml = None
-
-is_py2 = sys.version[0] == '2'
-
-if is_py2:
-    import Queue as queue
-else:
-    import queue as queue
-
-
-def run_tidy(task_queue, lock, timeout):
-    watchdog = None
-    while True:
-        command = task_queue.get()
-        try:
-            proc = subprocess.Popen(command,
-                                    stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE)
-
-            if timeout is not None:
-                watchdog = threading.Timer(timeout, proc.kill)
-                watchdog.start()
-
-            stdout, stderr = proc.communicate()
-
-            with lock:
-                sys.stdout.write(stdout.decode('utf-8'))
-                sys.stdout.flush()
-                if stderr:
-                    sys.stderr.write(stderr.decode('utf-8'))
-                    sys.stderr.flush()
-        except Exception as e:
-            with lock:
-                sys.stderr.write('Failed: ' + str(e) + ': '.join(command) + '\n')
-        finally:
-            with lock:
-                if (not timeout is None) and (not watchdog is None):
-                    if not watchdog.is_alive():
-                        sys.stderr.write('Terminated by timeout: ' +
-                                         ' '.join(command) + '\n')
-                    watchdog.cancel()
-            task_queue.task_done()
-
-
-def start_workers(max_tasks, tidy_caller, task_queue, lock, timeout):
-    for _ in range(max_tasks):
-        t = threading.Thread(target=tidy_caller, args=(task_queue, lock, timeout))
-        t.daemon = True
-        t.start()
-
-def merge_replacement_files(tmpdir, mergefile):
-    """Merge all replacement files in a directory into a single file"""
-    # The fixes suggested by clang-tidy >= 4.0.0 are given under
-    # the top level key 'Diagnostics' in the output yaml files
-    mergekey = "Diagnostics"
-    merged = []
-    for replacefile in glob.iglob(os.path.join(tmpdir, '*.yaml')):
-        content = yaml.safe_load(open(replacefile, 'r'))
-        if not content:
-            continue # Skip empty files.
-        merged.extend(content.get(mergekey, []))
-
-    if merged:
-        # MainSourceFile: The key is required by the definition inside
-        # include/clang/Tooling/ReplacementsYaml.h, but the value
-        # is actually never used inside clang-apply-replacements,
-        # so we set it to '' here.
-        output = { 'MainSourceFile': '', mergekey: merged }
-        with open(mergefile, 'w') as out:
-            yaml.safe_dump(output, out)
-    else:
-        # Empty the file:
-        open(mergefile, 'w').close()
-
-
-def main():
-    parser = argparse.ArgumentParser(description=
-                                     'Run clang-tidy against changed files, and '
-                                     'output diagnostics only for modified '
-                                     'lines.')
-    parser.add_argument('-clang-tidy-binary', metavar='PATH',
-                        default='clang-tidy',
-                        help='path to clang-tidy binary')
-    parser.add_argument('-p', metavar='NUM', default=0,
-                        help='strip the smallest prefix containing P slashes')
-    parser.add_argument('-regex', metavar='PATTERN', default=None,
-                        help='custom pattern selecting file paths to check '
-                             '(case sensitive, overrides -iregex)')
-    parser.add_argument('-iregex', metavar='PATTERN', default=
-    r'.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)',
-                        help='custom pattern selecting file paths to check '
-                             '(case insensitive, overridden by -regex)')
-    parser.add_argument('-j', type=int, default=1,
-                        help='number of tidy instances to be run in parallel.')
-    parser.add_argument('-timeout', type=int, default=None,
-                        help='timeout per each file in seconds.')
-    parser.add_argument('-fix', action='store_true', default=False,
-                        help='apply suggested fixes')
-    parser.add_argument('-checks',
-                        help='checks filter, when not specified, use clang-tidy '
-                             'default',
-                        default='')
-    parser.add_argument('-path', dest='build_path',
-                        help='Path used to read a compile command database.')
-    if yaml:
-        parser.add_argument('-export-fixes', metavar='FILE', dest='export_fixes',
-                            help='Create a yaml file to store suggested fixes in, '
-                                 'which can be applied with clang-apply-replacements.')
-    parser.add_argument('-extra-arg', dest='extra_arg',
-                        action='append', default=[],
-                        help='Additional argument to append to the compiler '
-                             'command line.')
-    parser.add_argument('-extra-arg-before', dest='extra_arg_before',
-                        action='append', default=[],
-                        help='Additional argument to prepend to the compiler '
-                             'command line.')
-    parser.add_argument('-quiet', action='store_true', default=False,
-                        help='Run clang-tidy in quiet mode')
-    clang_tidy_args = []
-    argv = sys.argv[1:]
-    if '--' in argv:
-        clang_tidy_args.extend(argv[argv.index('--'):])
-        argv = argv[:argv.index('--')]
-
-    args = parser.parse_args(argv)
-
-    # Extract changed lines for each file.
-    filename = None
-    lines_by_file = {}
-    for line in sys.stdin:
-        match = re.search('^\+\+\+\ \"?(.*?/){%s}([^ \t\n\"]*)' % args.p, line)
-        if match:
-            filename = match.group(2)
-        if filename is None:
-            continue
-
-        if args.regex is not None:
-            if not re.match('^%s$' % args.regex, filename):
-                continue
-        else:
-            if not re.match('^%s$' % args.iregex, filename, re.IGNORECASE):
-                continue
-
-        match = re.search('^@@.*\+(\d+)(,(\d+))?', line)
-        if match:
-            start_line = int(match.group(1))
-            line_count = 1
-            if match.group(3):
-                line_count = int(match.group(3))
-            if line_count == 0:
-                continue
-            end_line = start_line + line_count - 1
-            lines_by_file.setdefault(filename, []).append([start_line, end_line])
-
-    if not any(lines_by_file):
-        print("No relevant changes found.")
-        sys.exit(0)
-
-    max_task_count = args.j
-    if max_task_count == 0:
-        max_task_count = multiprocessing.cpu_count()
-    max_task_count = min(len(lines_by_file), max_task_count)
-
-    tmpdir = None
-    if yaml and args.export_fixes:
-        tmpdir = tempfile.mkdtemp()
-
-    # Tasks for clang-tidy.
-    task_queue = queue.Queue(max_task_count)
-    # A lock for console output.
-    lock = threading.Lock()
-
-    # Run a pool of clang-tidy workers.
-    start_workers(max_task_count, run_tidy, task_queue, lock, args.timeout)
-
-    # Form the common args list.
-    common_clang_tidy_args = []
-    if args.fix:
-        common_clang_tidy_args.append('-fix')
-    if args.checks != '':
-        common_clang_tidy_args.append('-checks=' + args.checks)
-    if args.quiet:
-        common_clang_tidy_args.append('-quiet')
-    if args.build_path is not None:
-        common_clang_tidy_args.append('-p=%s' % args.build_path)
-    for arg in args.extra_arg:
-        common_clang_tidy_args.append('-extra-arg=%s' % arg)
-    for arg in args.extra_arg_before:
-        common_clang_tidy_args.append('-extra-arg-before=%s' % arg)
-
-    for name in lines_by_file:
-        line_filter_json = json.dumps(
-            [{"name": name, "lines": lines_by_file[name]}],
-            separators=(',', ':'))
-
-        # Run clang-tidy on files containing changes.
-        command = [args.clang_tidy_binary]
-        command.append('-line-filter=' + line_filter_json)
-        if yaml and args.export_fixes:
-            # Get a temporary file. We immediately close the handle so clang-tidy can
-            # overwrite it.
-            (handle, tmp_name) = tempfile.mkstemp(suffix='.yaml', dir=tmpdir)
-            os.close(handle)
-            command.append('-export-fixes=' + tmp_name)
-        command.extend(common_clang_tidy_args)
-        command.append(name)
-        command.extend(clang_tidy_args)
-
-        task_queue.put(command)
-
-    # Wait for all threads to be done.
-    task_queue.join()
-
-    if yaml and args.export_fixes:
-        print('Writing fixes to ' + args.export_fixes + ' ...')
-        try:
-            merge_replacement_files(tmpdir, args.export_fixes)
-        except:
-            sys.stderr.write('Error exporting fixes.\n')
-            traceback.print_exc()
-
-    if tmpdir:
-        shutil.rmtree(tmpdir)
-
-
-if __name__ == '__main__':
-    main()

ci/linux/clang_tidy.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-COMMIT_RANGE=$1..$2
-
-if ! git rev-list $COMMIT_RANGE 2>&1 >/dev/null; then
-    echo "\$COMMIT_RANGE ($COMMIT_RANGE) is not valid for this build (probably caused by a rebase)."
-    exit 0
-fi
-
-# In order to get a proper diff without irrelevant changes, we need to determine where we branched off from the base
-# branch
-BASE_COMMIT=$(git merge-base $1 $2)
-
-echo "Running clang-tidy on changed files"
-git diff -U0 --no-color "$BASE_COMMIT..$2" | \
-    $HERE/clang-tidy-diff.py -path "$(pwd)/build" -p1 \
-    -regex '(code(?!\/graphics\/shaders\/compiled)|freespace2|qtfred|test|build|tools)\/.*\.(cpp|h)' \
-    -clang-tidy-binary /usr/bin/clang-tidy-9 -j$(nproc) -export-fixes "$(pwd)/clang-fixes.yaml"

ci/linux/configure_cmake.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-
-if [ "$COMPILER" = "gcc-5" ]; then
-    export CC=gcc-5
-    export CXX=g++-5
-fi
-if [ "$COMPILER" = "gcc-10" ]; then
-    export CC=gcc-10
-    export CXX=g++-10
-fi
-if [ "$COMPILER" = "clang-9" ]; then
-    # Work around bug in clang that uses the wrong installation directory: https://bugs.llvm.org/show_bug.cgi?id=47460
-    export CC=$(readlink -f $(which clang-9))
-    export CXX=$(readlink -f $(which clang++-9))
-fi
-
-LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH
-CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-
-CMAKE_OPTIONS="$JOB_CMAKE_OPTIONS"
-if [[ "$COMPILER" =~ ^clang.*$ ]]; then
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=ON"
-fi
-
-mkdir build
-cd build
-
-export CXXFLAGS
-export CFLAGS
-export LD_LIBRARY_PATH
-
-cmake -G Ninja -DFSO_FATAL_WARNINGS=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON $CMAKE_OPTIONS \
-    -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_BUILD_APPIMAGE=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION \
-    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON \
-    -DSHADERS_ENABLE_COMPILATION=ON ..

ci/linux/create_dist_pack.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-OS="$1"
-
-source $HERE/dist_functions.sh
-
-if [ "$OS" = "Linux" ]; then
-    tar -cvzf "$(get_package_name)-builds-Linux.tar.gz" *
-
-    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-Linux.tar.gz"
-    echo "::set-output name=package_name::$(get_package_name)-builds-Linux.tar.gz"
-    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Linux.tar.gz")"
-elif [ "$OS" = "Windows" ]; then
-    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ARCH-$SIMD.zip" "*"
-
-    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip"
-    echo "::set-output name=package_name::$(get_package_name)-builds-$ARCH-$SIMD.zip"
-    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip")"
-
-    7z a "$(get_package_name)-debug-$ARCH-$SIMD.7z" "*.pdb"
-
-    echo "::set-output name=debug_path::$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z"
-    echo "::set-output name=debug_name::$(get_package_name)-debug-$ARCH-$SIMD.7z"
-    echo "::set-output name=debug_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z")"
-else
-    echo "Invalid OS: $OS"
-fi

ci/linux/dist_functions.sh

@@ -1,70 +0,0 @@
-function get_package_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "nightly_*" --exact-match)"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "release_*" --exact-match | sed 's/release_/fs2_open_/i')"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "test_${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function get_version_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "nightly_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^nightly_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "release_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^release_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function upload_files_to_sftp() {
-  # We need empty glob patterns to "disappear" in the for loop below since this will be run for different configurations
-  # where it may be possible that some of the file patterns will not be present
-  shopt -s nullglob
-
-  echo "cd $2/" > sftp_batch
-  echo "mkdir $(get_version_name)" >> sftp_batch
-  # Create directory but do not cause an error if it already exists
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1 || true
-
-  echo "cd $2/$(get_version_name)/" > sftp_batch
-  for file in *.tar.gz *.7z *.zip; do
-    echo "put $file" >> sftp_batch
-  done
-
-  echo "bye" >> sftp_batch
-
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1
-
-  rm sftp_batch
-}
-

ci/linux/generate_appimage.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-INSTALL_FOLDER=$1
-
-# Install Freespace2 targets
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Unspecified -P cmake_install.cmake
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Freespace2 -P cmake_install.cmake
-
-# We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-FILENAME="$(find $INSTALL_FOLDER/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
-appimagetool -n $INSTALL_FOLDER "$INSTALL_FOLDER/$FILENAME"
-chmod +x "$INSTALL_FOLDER/$FILENAME"
-
-ls -al $INSTALL_FOLDER

ci/linux/run_tests.sh

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-export LD_LIBRARY_PATH=$(pwd)/bin/lib:$LD_LIBRARY_PATH
-
-if [ "$CONFIGURATION" = "Debug" ]; then
-    valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
-        --suppressions="$HERE/valgrind.supp" ./bin/unittests --gtest_shuffle
-else
-    ./bin/unittests --gtest_shuffle
-fi

ci/linux/upload_dist_package.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-UPLOAD_TYPE=$1
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-source $HERE/dist_functions.sh
-
-if [ "$UPLOAD_TYPE" = "nightly" ]; then
-    SSHPASS=$INDIEGAMES_SSHPASS upload_files_to_sftp "$INDIEGAMES_USER@scp.indiegames.us" "public_html/builds/nightly"
-
-    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly"
-elif [ "$UPLOAD_TYPE" = "test" ]; then
-    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/test"
-else
-    echo "Unknown upload type $UPLOAD_TYPE"
-    exit 1
-fi

ci/linux/valgrind.supp

@@ -1,163 +0,0 @@
-{
-   liblsan Invalid read
-   Memcheck:Addr8
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:*
-   obj:*
-   obj:*
-}
-{
-    Travis memleak
-    Memcheck:Leak
-    match-leak-kinds: definite
-    fun:malloc
-    fun:_dl_signal_error
-    fun:_dl_open
-    fun:dlopen_doit
-    fun:_dl_catch_error
-    fun:_dlerror_run
-    fun:dlopen@@GLIBC_2.2.5
-    obj:/usr/lib/x86_64-linux-gnu/libmirclient.so.7
-    fun:call_init.part.0
-    fun:call_init
-    fun:_dl_init
-    fun:dl_open_worker
-    fun:_dl_catch_error
-}
-{
-   CLang Lua unitialized value error
-   Memcheck:Cond
-   ...
-   fun:luaH_get
-   fun:lua_rawget
-   fun:_ZN12_GLOBAL__N_117ade_index_handlerEP9lua_State
-}
-{
-   False-positive uninitialized variable warning
-   Memcheck:Cond
-   fun:_Z23cf_check_location_flagsjj
-   fun:_Z29cf_create_default_path_stringPcjiPKcbj
-   ...
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing4Test3RunEv
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_dl_signal_error
-   fun:_dl_open
-   fun:dlopen_doit
-   fun:_dl_catch_error
-   fun:_dlerror_run
-   fun:dlopen@@GLIBC_2.2.5
-   obj:*
-   obj:*
-   fun:call_init.part.0
-   fun:call_init
-   fun:_dl_init
-   fun:dl_open_worker
-}
-{
-   dlopen leak
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_dl_exception_create
-   fun:_dl_signal_error
-   fun:_dl_map_object
-   fun:dl_open_worker
-   fun:_dl_catch_exception
-   fun:_dl_open
-   fun:dlopen_doit
-   fun:_dl_catch_exception
-   fun:_dl_catch_error
-   fun:_dlerror_run
-   fun:dlopen@@GLIBC_2.2.5
-}

ci/travis/before_deploy.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env sh
-
-set -ex
-
-if [ "$NIGHTLY_BUILD" = true ]; then
-    echo "Generating bintray config..."
-    sed -e "s/\$VERSION_NAME/$VERSION_NAME/" ci/bintray.template.json > ci/bintray.json
-fi

ci/travis/before_install.sh

@@ -1,20 +0,0 @@
-#!/usr/bin/env sh
-
-set -ex
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    export DEBIAN_FRONTEND=noninteractive
-
-    sudo add-apt-repository -y "ppa:msulikowski/valgrind" # For fixing a bug with valgrind 3.11 which does not recognize the rdrand instruction
-
-    wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
-    sudo add-apt-repository -y 'deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
-
-    sudo apt-get -yq update
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    # Nothing to do here
-    :
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    # Nothing to do here
-    :
-fi

ci/travis/before_script.sh

@@ -1,50 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    mkdir -p /tmp/builds
-    if [ "$RELEASE_BUILD" = true ]; then
-        # Package the source code in release builds
-        PARENT_DIR="$(basename "$PWD")"
-        (cd .. && tar -czvf /tmp/builds/$PACKAGE_NAME-source-Unix.tar.gz --exclude-vcs "$PARENT_DIR")
-    fi
-fi
-
-mkdir -p build
-cd build
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-    CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-
-    export CXXFLAGS
-    export CFLAGS
-    CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
-    if [ "$BUILD_DEPLOYMENT" = true ]; then
-        for config in $BUILD_CONFIGS
-        do
-            mkdir -p $config
-            cd $config
-            eval $CMAKE -DFSO_INSTALL_DEBUG_FILES=ON -DCMAKE_BUILD_TYPE=$config -DCMAKE_INSTALL_PREFIX="/tmp/release/$config" \
-                -DFSO_BUILD_APPIMAGE=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_QTFRED=OFF ../..
-            cd ..
-        done
-    else
-        eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON ..
-    fi
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    if [ "$BUILD_DEPLOYMENT" = true ]; then
-        cmake -G "Xcode" -DFSO_FATAL_WARNINGS=ON -DFSO_INSTALL_DEBUG_FILES=ON -DCMAKE_INSTALL_PREFIX="/tmp/release" ..
-    else
-        cmake -G "Xcode" $CMAKE_OPTIONS ..
-    fi
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    if [ "$CMAKE_GENERATOR" = "Ninja" ]; then
-        cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-            -DFSO_BUILD_FRED2="OFF" -G "$CMAKE_GENERATOR" ..
-    else
-        cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-            -DMSVC_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "$CMAKE_GENERATOR" -T "$CMAKE_TOOLSET" ..
-    fi
-fi

ci/travis/check_release.sh

@@ -1,74 +0,0 @@
-#!/usr/bin/env sh
-
-RELEASE_BUILD=false
-NIGHTLY_BUILD=false
-TEST_BUILD=false
-
-BUILD_DEPLOYMENT=false
-BUILD_CONFIGS="Release FastDebug"
-VERSION_NAME=""
-PACKAGE_NAME=""
-
-RELEASE_PATTERN="^release_(.*)$"
-NIGHTLY_PATTERN="^nightly_(.*)$"
-TEST_BUILD_PATTERN="^test\/(.*)$"
-
-# These are for testing
-NIGHTLY_TEST=false
-RELEASE_TEST=false
-TEST_BUILD_TEST=false
-
-if [ "$RELEASE_TEST" = true ] || [[ "$TRAVIS_TAG" =~ $RELEASE_PATTERN ]]; then
-    echo "This is a release tag!";
-    RELEASE_BUILD=true;
-	PACKAGE_NAME="fs2_open_${BASH_REMATCH[1]}";
-fi
-if [ "$NIGHTLY_TEST" = true ] || [[ "$TRAVIS_TAG" =~ $NIGHTLY_PATTERN ]]; then
-    echo "This is a nightly tag!";
-    NIGHTLY_BUILD=true;
-    VERSION_NAME="${BASH_REMATCH[1]}";
-	PACKAGE_NAME="nightly_${BASH_REMATCH[1]}";
-fi
-if [ "$TEST_BUILD_TEST" = true ] || [[ "$TRAVIS_PULL_REQUEST" == "false" && "$TRAVIS_BRANCH" =~ $TEST_BUILD_PATTERN ]]; then
-    echo "This is a test build branch!";
-    TEST_BUILD=true;
-    if [ "$TEST_BUILD_TEST" = true ]; then
-        VERSION_NAME="test";
-        PACKAGE_NAME="test_test";
-    else
-        VERSION_NAME="${BASH_REMATCH[1]}";
-        PACKAGE_NAME="test_${BASH_REMATCH[1]}";
-    fi
-
-    # Override the revision string so that the builds are named correctly
-    echo "set(FSO_VERSION_REVISION_STR $VERSION_NAME)" > "$TRAVIS_BUILD_DIR/version_override.cmake"
-fi
-
-if ([ "$RELEASE_BUILD" = true ] || [ "$NIGHTLY_BUILD" = true ] || [ "$TEST_BUILD" = true ]); then
-    BUILD_DEPLOYMENT=true;
-fi
-
-if [ "$BUILD_DEPLOYMENT" = true ]; then
-    if ([ "$TRAVIS_OS_NAME" = "linux" ] && (! [[ "$CC" =~ ^gcc-5.*$ ]])); then
-        echo "Skipping non-release compiler";
-        exit 0;
-    fi
-
-    if ([[ "$CONFIGURATION" == "Debug" ]]); then
-        echo "Skipping non-release configuration";
-        exit 0;
-    fi
-
-    if [ "$TRAVIS_OS_NAME" = "windows" ]; then
-        echo "Skipping non-release platform"
-        exit 0
-    fi
-fi
-
-export RELEASE_BUILD
-export NIGHTLY_BUILD
-export TEST_BUILD
-export BUILD_DEPLOYMENT
-export BUILD_CONFIGS
-export VERSION_NAME
-export PACKAGE_NAME

ci/travis/ftp_deploy.sh

@@ -1,89 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -u
-
-if [[ ! "$(curl -V)" == *"sftp"* ]]; then
-    # Before
-    echo "Before:"
-    curl -V
-
-    if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-
-        if [ -f ~/curl_cache/curl*.deb ]; then
-            cd ~/curl_cache
-            sudo dpkg -i libcurl3*.deb
-            sudo dpkg -i curl*.deb
-        else
-            # Since the Travis CI people are not capable of enabling SSH/SCP support for their libcurl we need to build that manually...
-            # These commands are based on the tutorial from here: http://zeroset.mnim.org/2013/03/14/sftp-support-for-curl-in-ubuntu-12-10-quantal-quetzal-and-later/
-            mkdir /tmp/curl
-            cd /tmp/curl
-            sudo apt-get update
-            sudo apt-get install build-essential debhelper libssh2-1-dev libgnutls-dev libidn11-dev libkrb5-dev libldap2-dev libnss3-dev librtmp-dev libtool openssh-server quilt
-            apt-get source curl
-            sudo apt-get build-dep curl
-
-            cd curl-*
-            export DEB_BUILD_OPTIONS="nocheck"
-            sudo dpkg-buildpackage -uc -us -j"$(grep -c ^processor /proc/cpuinfo)"
-
-            cd ..
-            dpkg -l | grep curl
-            ls -al
-
-            if [ ! -d ~/curl_cache ]; then
-                mkdir ~/curl_cache
-            fi
-
-            cp libcurl3*.deb curl*.deb ~/curl_cache
-
-            sudo dpkg -i libcurl3*.deb
-            sudo dpkg -i curl*.deb
-        fi
-    elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-        brew install libssh2
-        
-        if [ -d ~/curl_cache/curl ]; then
-            cd ~/curl_cache/curl
-            sudo make install
-        else
-            mkdir /tmp/curl
-            cd /tmp/curl
-
-            curl -LO "https://curl.haxx.se/download/curl-7.64.0.tar.bz2"
-            tar -xjf curl-7.64.0.tar.bz2
-
-            cd curl-7.64.0
-            ./configure --disable-debug --disable-dependency-tracking --disable-silent-rules --with-libssh2 --with-darwinssl --without-ca-bundle --without-ca-path
-            make -j"$(sysctl hw.logicalcpu | cut -d " " -f 2)"
-
-            if [ ! -d ~/curl_cache ]; then
-                mkdir ~/curl_cache
-            fi
-
-            cp -a . ~/curl_cache/curl
-            sudo make install
-        fi
-        export PATH=/usr/local/bin:$PATH
-    fi
-
-    # After
-    echo "After:"
-    curl -V
-fi
-
-cd /tmp/builds
-
-for file in *; do
-    if [ "$TEST_BUILD" = true ]; then
-        # Upload to datacorder
-        curl -k "sftp://porphyrion.feralhosting.com/www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$VERSION_NAME/" --user "$DATACORDER_USER:$DATACORDER_PASSWORD" -T "$file" --ftp-create-dirs
-    else
-        # Upload to indiegames
-        curl -k "sftp://scp.indiegames.us/~/public_html/builds/nightly/$VERSION_NAME/" --user "$INDIEGAMES_USER:$INDIEGAMES_PASSWORD" -T "$file" --ftp-create-dirs
-
-        # Upload to datacorder
-        curl -k "sftp://porphyrion.feralhosting.com/~/www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$VERSION_NAME/" --user "$DATACORDER_USER:$DATACORDER_PASSWORD" -T "$file" --ftp-create-dirs
-    fi
-done

ci/travis/install.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-FILENAME=
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    export DEBIAN_FRONTEND=noninteractive
-
-    if [ ! -d "$HOME/cmake-3.8/bin" ]; then
-        # If the cache does not currently contain CMake then download and install it
-    	mkdir -p $HOME/cmake-3.8/
-
-    	wget -O /tmp/cmake.tar.gz --no-check-certificate https://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.tar.gz
-    	tar -xzf /tmp/cmake.tar.gz -C $HOME/cmake-3.8/ --strip-components=1
-    fi
-    export PATH=$HOME/cmake-3.8/bin:$PATH
-    
-    cd $HOME
-    
-    if [ "${BUILD_DEPLOYMENT}" = true ]; then
-        wget -O appimagetool -c "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" # (64-bit)
-        chmod a+x ./appimagetool
-
-        wget -O linuxdeployqt -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" # (64-bit)
-        chmod a+x ./linuxdeployqt
-    fi
-
-    sudo apt-get -yq install valgrind
-
-    if [[ "$CC" = "clang-9" ]]; then
-      sudo apt-get -yq install clang-9 clang-tidy-9
-    fi
-
-    if [[ "$CC" = "clang-4.0" ]]; then
-      # Fix a header bug present in ubuntu...
-      sudo ln -s /usr/include/libcxxabi/__cxxabi_config.h /usr/include/c++/v1/__cxxabi_config.h
-    fi
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    gem install xcpretty
-    
-    brew update
-    brew outdated cmake || brew upgrade cmake
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    choco install mingw ninja
-fi
-
-cmake --version

ci/travis/release.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env sh
-
-set -ex
-mkdir -p /tmp/builds
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-	cd build
-    for config in $BUILD_CONFIGS
-    do
-        cd "$config"
-
-        # Compile all targets
-        ninja all
-
-        # Install Freespace2 targets
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/fso -DCOMPONENT=Unspecified -P cmake_install.cmake
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/fso -DCOMPONENT=Freespace2 -P cmake_install.cmake
-
-        # We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-        FILENAME="$(find /tmp/release/$config/fso/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
-        $HOME/appimagetool -n /tmp/release/$config/fso "/tmp/release/$config/fso/$FILENAME"
-
-: <<'END'
-        # Install qtFRED targets
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/qtfred/usr -DCOMPONENT=Unspecified -P cmake_install.cmake
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/qtfred/usr -DCOMPONENT=qtFRED -P cmake_install.cmake
-
-        PREV="$(pwd)"
-        cd /tmp/release/$config/qtfred
-
-        unset QTDIR; unset QT_PLUGIN_PATH; unset LD_LIBRARY_PATH
-        $HOME/linuxdeployqt usr/qtfred.desktop -bundle-non-qt-libs
-        # Move our AppRun script to the right location
-        mv usr/AppRun AppRun
-
-        echo "Embed newer libstdc++ for distros that don't come with it (ubuntu 14.04)";
-        mkdir -p usr/optional/; mkdir -p usr/optional/libstdc++/;
-        cp /usr/lib/x86_64-linux-gnu/libstdc++.so.6 ./usr/optional/libstdc++/;
-
-        $HOME/appimagetool -n . "$(find /tmp/release/$config/qtfred/usr/bin -name 'qtfred_*' -type f -printf "%f\n").AppImage"
-
-        cd "$PREV"
-END
-
-        cd ..
-    done
-
-    cp `find /tmp/release -name '*.AppImage' -print` /tmp/release
-    (cd /tmp/release && tar -cvzf /tmp/builds/$PACKAGE_NAME-builds-Linux.tar.gz *.AppImage)
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    cd build
-    
-    for config in $BUILD_CONFIGS
-    do
-        cmake --build . --config "$config" --target install | tee build.log \
-            | xcpretty
-        XCODE_RET=${PIPESTATUS[0]}
-        if [ "$XCODE_RET" -ne "0" ]; then
-            tar -cvzf build.log.tar.gz build.log
-            curl --upload-file build.log.tar.gz "https://transfer.sh/build.log.tar.gz"
-            exit $XCODE_RET
-        fi
-    done
-
-    ls -al /tmp/release
-    
-    (cd /tmp/release && tar -cvzf /tmp/builds/$PACKAGE_NAME-builds-MacOSX.tar.gz *)
-fi

ci/travis/script.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env sh
-
-set -e
-
-cd build
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    ninja -k 20 all
-
-    if [ "$CONFIGURATION" = "Debug" ]; then
-        valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
-            --suppressions="$TRAVIS_BUILD_DIR/ci/travis/valgrind.supp" ./bin/unittests --gtest_shuffle
-    else
-        ./bin/unittests --gtest_shuffle
-    fi
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    cmake --build . --config "$CONFIGURATION" | tee build.log | xcpretty
-    XCODE_RET=${PIPESTATUS[0]}
-    if [ "$XCODE_RET" -ne "0" ]; then
-        tar -cvzf build.log.tar.gz build.log
-        curl --upload-file build.log.tar.gz "https://keep.sh"
-        exit $XCODE_RET
-    fi
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    if [ "$CMAKE_GENERATOR" = "Ninja" ]; then
-        cmake --build . --config "$CONFIGURATION"
-    else
-        cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-    fi
-fi

cmake/AppImage.desktop.in

@@ -1,6 +0,0 @@
-[Desktop Entry]
-Type=Application
-Name=FreeSpace Open
-Exec=$<TARGET_FILE_NAME:Freespace2>
-Icon=app_icon
-Categories=Game;

cmake/AppRun.in

@@ -1,4 +0,0 @@
-#!/bin/sh
-HERE=$(dirname $(readlink -f "${0}"))
-export LD_LIBRARY_PATH="${HERE}"/lib:"$LD_LIBRARY_PATH"
-exec "${HERE}"/bin/$<TARGET_FILE_NAME:Freespace2> $@

cmake/Cxx11.cmake

@@ -1,15 +0,0 @@
-
-include(WriteCompilerDetectionHeader)
-
-set(CMAKE_CXX_STANDARD_REQUIRED 11)
-set(CMAKE_CXX_STANDARD 11)
-
-get_property(CMAKE_CXX_KNOWN_FEATURES GLOBAL PROPERTY CMAKE_CXX_KNOWN_FEATURES)
-
-write_compiler_detection_header(
-  FILE "${GENERATED_SOURCE_DIR}/scp_compiler_detection.h"
-  PREFIX SCP
-  COMPILERS AppleClang Clang GNU MSVC
-  FEATURES ${CMAKE_CXX_KNOWN_FEATURES}
-  VERSION 3.2
-)

cmake/appimage.cmake

@@ -1,21 +0,0 @@
-
-SET(BINARY_DESTINATION "bin")
-SET(LIBRAY_DESTINATION "lib")
-
-configure_file("${CMAKE_CURRENT_LIST_DIR}/AppRun.in" "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen" @ONLY)
-file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/AppRun-$<CONFIG>"
-    INPUT "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen")
-
-install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/AppRun-$<CONFIG>" DESTINATION "." RENAME "AppRun"
-        COMPONENT "Freespace2")
-
-
-configure_file("${CMAKE_CURRENT_LIST_DIR}/AppImage.desktop.in" "${CMAKE_CURRENT_BINARY_DIR}/AppImage.desktop.gen" @ONLY)
-file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/AppImage-$<CONFIG>.desktop"
-    INPUT "${CMAKE_CURRENT_BINARY_DIR}/AppImage.desktop.gen")
-
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/AppImage-$<CONFIG>.desktop" DESTINATION "." RENAME "fso.desktop"
-        COMPONENT "Freespace2")
-
-install(FILES "${CMAKE_SOURCE_DIR}/freespace2/resources/app_icon.png" DESTINATION "."
-        COMPONENT "Freespace2")

cmake/clang-tidy.cmake

@@ -1,37 +0,0 @@
-option(ENABLE_CLANG_TIDY "Enable source code checking using clang-tidy" OFF)
-
-find_program(
-    CLANG_TIDY_EXE
-    NAMES "clang-tidy"
-    DOC "Path to clang-tidy executable"
-)
-
-function(enable_clang_tidy target)
-    # Not enabled in this configuration
-endfunction()
-
-if(NOT ENABLE_CLANG_TIDY)
-    return()
-endif()
-
-if(NOT EXISTS "${CLANG_TIDY_EXE}")
-    message(SEND_ERROR "clang-tidy: Could not find clang-tidy executable (value of variable is \"${CLANG_TIDY_EXE}\".")
-    return()
-endif()
-
-if(CMAKE_VERSION VERSION_LESS "3.6.0")
-    message(SEND_ERROR "Clang-tidy support requires CMake 3.6")
-    return()
-endif()
-
-message(STATUS "clang-tidy: Using \"${CLANG_TIDY_EXE}\"")
-
-function(enable_clang_tidy target)
-    SET(TIDY_OPTIONS "${CLANG_TIDY_EXE}")
-    if(FSO_FATAL_WARNINGS)
-        set(TIDY_OPTIONS "${TIDY_OPTIONS};-warnings-as-errors=*")
-    endif()
-
-    set_target_properties(${target} PROPERTIES CXX_CLANG_TIDY "${TIDY_OPTIONS}")
-endfunction()
-

cmake/cpufeatures.cpp

@@ -1,59 +0,0 @@
-// Code snippet from http://stackoverflow.com/a/7495023
-#ifdef _WIN32
-#include <intrin.h>
-//  Windows
-#define cpuid    __cpuid
-
-#else
-
-//  GCC Inline Assembly
-void cpuid(int CPUInfo[4],int InfoType){
-    __asm__ __volatile__ (
-        "cpuid":
-        "=a" (CPUInfo[0]),
-        "=b" (CPUInfo[1]),
-        "=c" (CPUInfo[2]),
-        "=d" (CPUInfo[3]) :
-        "a" (InfoType)
-    );
-}
-
-#endif
-
-#include <iostream>
-
-int main( int argc, char* argv[] )
-{
-	int SSE     = false;
-	int SSE2    = false;
-	int AVX     = false;
-	int AVX2    = false;
-
-	int info[4];
-	cpuid(info, 0);
-	int nIds = info[0];
-
-	//  Detect Instruction Set
-	if (nIds >= 1){
-		cpuid(info,0x00000001);
-		SSE   = (info[3] & ((int)1 << 25)) != 0;
-		SSE2  = (info[3] & ((int)1 << 26)) != 0;
-
-		AVX   = (info[2] & ((int)1 << 28)) != 0;
-	}
-	if (nIds >= 7){
-		cpuid(info,0x00000007);
-		AVX2  = (info[1] & ((int)1 <<  5)) != 0;
-	}
-
-	if (AVX2)
-		std::cout << "AVX2";
-	else if(AVX)
-		std::cout << "AVX";
-	else if(SSE2)
-		std::cout << "SSE2";
-	else if(SSE)
-		std::cout << "SSE";
-
-	return 0;
-}

cmake/cross_compile/mingw64.cmake

@@ -1,26 +0,0 @@
-
-# Sample toolchain file for building for Windows from a Linux system.
-#
-# Typical usage:
-#    *) install cross compiler: `sudo apt-get install mingw-w64 g++-mingw-w64`
-#    *) cd build
-#    *) cmake -DCMAKE_TOOLCHAIN_FILE=~/Toolchain-Ubuntu-mingw64.cmake ..
-
-set(CMAKE_SYSTEM_NAME Windows)
-set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
-
-# cross compilers to use for C and C++
-set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
-set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
-set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
-
-# target environment on the build host system
-#   set 1st to dir with the cross compiler's C/C++ headers/libs
-set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
-
-# modify default behavior of FIND_XXX() commands to
-# search for headers/libs in the target environment and
-# don't search for programs in the build host environment
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

cmake/debug-vars.cmake

@@ -1,154 +0,0 @@
-# ------------------------- Begin Generic CMake Variable Logging ------------------
-
-# /*	C++ comment style not allowed	*/
-
-
-# if you are building in-source, this is the same as CMAKE_SOURCE_DIR, otherwise
-# this is the top level directory of your build tree
-MESSAGE( STATUS "CMAKE_BINARY_DIR:         " ${CMAKE_BINARY_DIR} )
-
-# if you are building in-source, this is the same as CMAKE_CURRENT_SOURCE_DIR, otherwise this
-# is the directory where the compiled or generated files from the current CMakeLists.txt will go to
-MESSAGE( STATUS "CMAKE_CURRENT_BINARY_DIR: " ${CMAKE_CURRENT_BINARY_DIR} )
-
-# this is the directory, from which cmake was started, i.e. the top level source directory
-MESSAGE( STATUS "CMAKE_SOURCE_DIR:         " ${CMAKE_SOURCE_DIR} )
-
-# this is the directory where the currently processed CMakeLists.txt is located in
-MESSAGE( STATUS "CMAKE_CURRENT_SOURCE_DIR: " ${CMAKE_CURRENT_SOURCE_DIR} )
-
-# contains the full path to the top level directory of your build tree
-MESSAGE( STATUS "PROJECT_BINARY_DIR: " ${PROJECT_BINARY_DIR} )
-
-MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} )
-
-# contains the full path to the root of your project source directory,
-# i.e. to the nearest directory where CMakeLists.txt contains the PROJECT() command
-MESSAGE( STATUS "PROJECT_SOURCE_DIR: " ${PROJECT_SOURCE_DIR} )
-
-# set this variable to specify a common place where CMake should put all executable files
-# (instead of CMAKE_CURRENT_BINARY_DIR)
-MESSAGE( STATUS "EXECUTABLE_OUTPUT_PATH: " ${EXECUTABLE_OUTPUT_PATH} )
-
-# set this variable to specify a common place where CMake should put all libraries
-# (instead of CMAKE_CURRENT_BINARY_DIR)
-MESSAGE( STATUS "LIBRARY_OUTPUT_PATH:     " ${LIBRARY_OUTPUT_PATH} )
-
-# tell CMake to search first in directories listed in CMAKE_MODULE_PATH
-# when you use FIND_PACKAGE() or INCLUDE()
-MESSAGE( STATUS "CMAKE_MODULE_PATH: " ${CMAKE_MODULE_PATH} )
-
-# this is the complete path of the cmake which runs currently (e.g. /usr/local/bin/cmake)
-MESSAGE( STATUS "CMAKE_COMMAND: " ${CMAKE_COMMAND} )
-
-# this is the CMake installation directory
-MESSAGE( STATUS "CMAKE_ROOT: " ${CMAKE_ROOT} )
-
-# this is the filename including the complete path of the file where this variable is used.
-MESSAGE( STATUS "CMAKE_CURRENT_LIST_FILE: " ${CMAKE_CURRENT_LIST_FILE} )
-
-# this is linenumber where the variable is used
-MESSAGE( STATUS "CMAKE_CURRENT_LIST_LINE: " ${CMAKE_CURRENT_LIST_LINE} )
-
-# this is used when searching for include files e.g. using the FIND_PATH() command.
-MESSAGE( STATUS "CMAKE_INCLUDE_PATH: " ${CMAKE_INCLUDE_PATH} )
-
-# this is used when searching for libraries e.g. using the FIND_LIBRARY() command.
-MESSAGE( STATUS "CMAKE_LIBRARY_PATH: " ${CMAKE_LIBRARY_PATH} )
-
-# the complete system name, e.g. "Linux-2.4.22", "FreeBSD-5.4-RELEASE" or "Windows 5.1"
-MESSAGE( STATUS "CMAKE_SYSTEM: " ${CMAKE_SYSTEM} )
-
-# the short system name, e.g. "Linux", "FreeBSD" or "Windows"
-MESSAGE( STATUS "CMAKE_SYSTEM_NAME: " ${CMAKE_SYSTEM_NAME} )
-
-# only the version part of CMAKE_SYSTEM
-MESSAGE( STATUS "CMAKE_SYSTEM_VERSION: " ${CMAKE_SYSTEM_VERSION} )
-
-# the processor name (e.g. "Intel(R) Pentium(R) M processor 2.00GHz")
-MESSAGE( STATUS "CMAKE_SYSTEM_PROCESSOR: " ${CMAKE_SYSTEM_PROCESSOR} )
-
-# is TRUE on all UNIX-like OS's, including Apple OS X and CygWin
-MESSAGE( STATUS "UNIX: " ${UNIX} )
-
-# is TRUE on Windows, including CygWin
-MESSAGE( STATUS "WIN32: " ${WIN32} )
-
-# is TRUE on Apple OS X
-MESSAGE( STATUS "APPLE: " ${APPLE} )
-
-# is TRUE when using the MinGW compiler in Windows
-MESSAGE( STATUS "MINGW: " ${MINGW} )
-
-# is TRUE on Windows when using the CygWin version of cmake
-MESSAGE( STATUS "CYGWIN: " ${CYGWIN} )
-
-# is TRUE on Windows when using a Borland compiler
-MESSAGE( STATUS "BORLAND: " ${BORLAND} )
-
-# Microsoft compiler
-MESSAGE( STATUS "MSVC: " ${MSVC} )
-MESSAGE( STATUS "MSVC_IDE: " ${MSVC_IDE} )
-MESSAGE( STATUS "MSVC60: " ${MSVC60} )
-MESSAGE( STATUS "MSVC70: " ${MSVC70} )
-MESSAGE( STATUS "MSVC71: " ${MSVC71} )
-MESSAGE( STATUS "MSVC80: " ${MSVC80} )
-MESSAGE( STATUS "CMAKE_COMPILER_2005: " ${CMAKE_COMPILER_2005} )
-
-
-# set this to true if you don't want to rebuild the object files if the rules have changed,
-# but not the actual source files or headers (e.g. if you changed the some compiler switches)
-MESSAGE( STATUS "CMAKE_SKIP_RULE_DEPENDENCY: " ${CMAKE_SKIP_RULE_DEPENDENCY} )
-
-# since CMake 2.1 the install rule depends on all, i.e. everything will be built before installing.
-# If you don't like this, set this one to true.
-MESSAGE( STATUS "CMAKE_SKIP_INSTALL_ALL_DEPENDENCY: " ${CMAKE_SKIP_INSTALL_ALL_DEPENDENCY} )
-
-# If set, runtime paths are not added when using shared libraries. Default it is set to OFF
-MESSAGE( STATUS "CMAKE_SKIP_RPATH: " ${CMAKE_SKIP_RPATH} )
-
-# set this to true if you are using makefiles and want to see the full compile and link
-# commands instead of only the shortened ones
-MESSAGE( STATUS "CMAKE_VERBOSE_MAKEFILE: " ${CMAKE_VERBOSE_MAKEFILE} )
-
-# this will cause CMake to not put in the rules that re-run CMake. This might be useful if
-# you want to use the generated build files on another machine.
-MESSAGE( STATUS "CMAKE_SUPPRESS_REGENERATION: " ${CMAKE_SUPPRESS_REGENERATION} )
-
-
-# A simple way to get switches to the compiler is to use ADD_DEFINITIONS().
-# But there are also two variables exactly for this purpose:
-
-# the compiler flags for compiling C sources
-MESSAGE( STATUS "CMAKE_C_FLAGS: " ${CMAKE_C_FLAGS} )
-
-# the compiler flags for compiling C++ sources
-MESSAGE( STATUS "CMAKE_CXX_FLAGS: " ${CMAKE_CXX_FLAGS} )
-
-
-# Choose the type of build.  Example: SET(CMAKE_BUILD_TYPE Debug)
-MESSAGE( STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE} )
-
-# if this is set to ON, then all libraries are built as shared libraries by default.
-MESSAGE( STATUS "BUILD_SHARED_LIBS: " ${BUILD_SHARED_LIBS} )
-
-# the compiler used for C files
-MESSAGE( STATUS "CMAKE_C_COMPILER: " ${CMAKE_C_COMPILER} )
-
-# the compiler used for C++ files
-MESSAGE( STATUS "CMAKE_CXX_COMPILER: " ${CMAKE_CXX_COMPILER} )
-
-# if the compiler is a variant of gcc, this should be set to 1
-MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCC: " ${CMAKE_COMPILER_IS_GNUCC} )
-
-# if the compiler is a variant of g++, this should be set to 1
-MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCXX : " ${CMAKE_COMPILER_IS_GNUCXX} )
-
-# the tools for creating libraries
-MESSAGE( STATUS "CMAKE_AR: " ${CMAKE_AR} )
-MESSAGE( STATUS "CMAKE_RANLIB: " ${CMAKE_RANLIB} )
-
-#
-#MESSAGE( STATUS ": " ${} )
-
-# ------------------------- End of Generic CMake Variable Logging ------------------

cmake/doxygen.cmake

@@ -1,37 +0,0 @@
-
-# add a target to generate API documentation with Doxygen
-find_package(Doxygen)
-if(DOXYGEN_FOUND)
-	SET(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/documentation/doxygen")
-	FILE(MAKE_DIRECTORY "${OUTPUT_DIR}")
-	
-	FILE(TO_NATIVE_PATH ${OUTPUT_DIR} OUTPUT_DIR)
-	SET(OUTPUT_DIR \"${OUTPUT_DIR}\")
-	
-	SET(INPUTS "${CMAKE_CURRENT_SOURCE_DIR}/code" "${CMAKE_CURRENT_SOURCE_DIR}/freespace2" "${CMAKE_CURRENT_SOURCE_DIR}/fred2" "${CMAKE_CURRENT_SOURCE_DIR}/wxfred2")
-	
-	SET(INPUT_DIRS)
-	FOREACH(DIR IN LISTS INPUTS)
-		FILE(TO_NATIVE_PATH ${DIR} native_dir)
-		
-		LIST(APPEND INPUT_DIRS \"${native_dir}\")
-	ENDFOREACH(DIR)
-	STRING(REPLACE ";" " " INPUT_DIRS "${INPUT_DIRS}")
-	
-	CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/fs2open.Doxyfile.in
-					${CMAKE_CURRENT_BINARY_DIR}/fs2open.Doxyfile
-					@ONLY)
-	
-	add_custom_target(doxygen
-		${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/fs2open.Doxyfile
-		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-		COMMENT "Generating API documentation with Doxygen" VERBATIM
-	)
-	
-	set_target_properties(doxygen
-		PROPERTIES
-			FOLDER "Documentation"
-			EXCLUDE_FROM_ALL ON
-			EXCLUDE_FROM_DEFAULT_BUILD ON
-	)
-endif(DOXYGEN_FOUND)

cmake/embed_file.cmake

@@ -1,114 +0,0 @@
-
-set(_EMBEDD_FILE_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
-
-function(target_embed_files _target)
-    set(options)
-    set(oneValueArgs RELATIVE_TO PATH_TYPE_PREFIX)
-    set(multiValueArgs FILES)
-    cmake_parse_arguments(EMBED "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    if (NOT DEFINED EMBED_RELATIVE_TO)
-        set(EMBED_RELATIVE_TO "${CMAKE_CURRENT_SOURCE_DIR}")
-    endif()
-    if (NOT IS_ABSOLUTE "${EMBED_RELATIVE_TO}")
-        get_filename_component(EMBED_RELATIVE_TO "${EMBED_RELATIVE_TO}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-    endif()
-
-    foreach (file ${EMBED_FILES})
-        get_filename_component(_absoluteFile "${file}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-
-        file(RELATIVE_PATH _pathType "${EMBED_RELATIVE_TO}" "${_absoluteFile}")
-        get_filename_component(_pathType ${_pathType} DIRECTORY)
-        if (DEFINED EMBED_PATH_TYPE_PREFIX)
-            if (_pathType)
-                set(_pathType "${EMBED_PATH_TYPE_PREFIX}/${_pathType}")
-            else()
-                # Avoid trailing / when we are in the same directory
-                set(_pathType "${EMBED_PATH_TYPE_PREFIX}")
-            endif()
-        endif()
-
-        if (NOT _pathType)
-            # If it is still empty then we need to work around yet another annoying CMake behavior where it ignores
-            # "empty" property strings
-            set(_pathType ".")
-        endif()
-
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES "${_absoluteFile}")
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES_BASE_DIR "${EMBED_RELATIVE_TO}")
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES_PATH_TYPE "${_pathType}")
-    endforeach()
-endfunction()
-
-function(handle_embedded_files _target)
-    get_target_property(_filesToEmbed ${_target} EMBEDDED_FILES)
-    get_target_property(_baseDirs ${_target} EMBEDDED_FILES_BASE_DIR)
-    get_target_property(_pathTypes ${_target} EMBEDDED_FILES_PATH_TYPE)
-
-    SET(DEF_OUT_FILES)
-
-    set(INCLUDE_LIST)
-    set(ARRAY_ELEMENTS)
-
-    list(LENGTH _filesToEmbed _numFiles)
-
-    FOREACH(i RANGE ${_numFiles})
-        # Why must CMake always do the unexpected thing? The foreach variant includes the last index as opposed to every
-        # other sensible language which does not include it...
-        if (i GREATER_EQUAL _numFiles)
-            break()
-        endif()
-
-        list(GET _filesToEmbed ${i} _filePath)
-        list(GET _baseDirs ${i} _baseDir)
-        list(GET _pathTypes ${i} _pathType)
-
-        if (_pathType STREQUAL ".")
-            # Handle the workaround we had to do for empty path types
-            set(_pathType "")
-        endif()
-
-        file(RELATIVE_PATH _relativeFilePath "${_baseDir}" "${_filePath}")
-        SET(_outputBasePath "${CMAKE_CURRENT_BINARY_DIR}/embedded_files/${_relativeFilePath}")
-
-        # For some reason this is needed...
-        get_filename_component(_outputDirectory ${_outputBasePath} DIRECTORY)
-        file(MAKE_DIRECTORY ${_outputDirectory})
-
-        # Retrieve the path type name from the relative path
-        file(TO_NATIVE_PATH "${_pathType}" _pathType)
-        if (MINGW)
-            # There is a bug in CMake where it thinks MinGW uses forward slashes for paths but we need backslashes for Windows builds
-            string(REPLACE "/" "\\" _pathType "${_pathType}")
-        endif()
-        # Properly escape back slashes in strings
-        string(REPLACE "\\" "\\\\" _pathType "${_pathType}")
-
-        get_filename_component(FILE_NAME "${_relativeFilePath}" NAME)
-
-        string(MAKE_C_IDENTIFIER "${_relativeFilePath}" FIELD_NAME)
-
-        set(HEADER_FILE "${_outputBasePath}.h")
-        set(SOURCE_FILE "${_outputBasePath}.cpp")
-
-        set(ALL_OUTPUTS "${HEADER_FILE}" "${SOURCE_FILE}")
-        set(FIELD_NAME "Embedded_${FIELD_NAME}")
-
-        set(INCLUDE_LIST "${INCLUDE_LIST}\n#include \"${HEADER_FILE}\"")
-        set(ARRAY_ELEMENTS "${ARRAY_ELEMENTS}\n\t{ \"${_pathType}\", \"${FILE_NAME}\" , ${FIELD_NAME} , ${FIELD_NAME}_size },")
-
-        add_custom_command(
-            OUTPUT ${ALL_OUTPUTS}
-            COMMAND embedfile "${_filePath}" "${_outputBasePath}" "${FIELD_NAME}"
-            MAIN_DEPENDENCY "${_filePath}"
-            COMMENT "Generating string file for ${_filePath}"
-        )
-
-        list(APPEND DEF_OUT_FILES ${ALL_OUTPUTS})
-    ENDFOREACH()
-
-    configure_file("${_EMBEDD_FILE_BASE_DIR}/embedded_files.inc.in" "${CMAKE_CURRENT_BINARY_DIR}/embedded_files/embedded_files.inc")
-    target_include_directories(${_target} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/embedded_files")
-    target_sources(${_target} PRIVATE ${DEF_OUT_FILES})
-    source_group("Generated Files\\Embedded Files" FILES ${DEF_OUT_FILES})
-endfunction()

cmake/embedded_files.inc.in

@@ -1,7 +0,0 @@
-
-@INCLUDE_LIST@
-
-def_file Default_files[] =
-{
-@ARRAY_ELEMENTS@
-};

cmake/finder/FindSpeech.cmake

@@ -1,16 +0,0 @@
-
-include(CheckIncludeFile)
-
-add_library(speech INTERFACE)
-
-if (WIN32)
-	CHECK_INCLUDE_FILE_CXX("sapi.h" HAVE_SAPI_H)
-	
-	if (NOT HAVE_SAPI_H)
-		message(SEND_ERROR "sapi.h could not be found on your platform. Please disable speech support.")
-	endif()
-else()
-	message(SEND_ERROR "Text to Speech is not supported on this platform!")
-endif()
-
-target_compile_definitions(speech INTERFACE -DFS2_SPEECH)

cmake/fred_rc.h.in

@@ -1,9 +0,0 @@
-
-
-#ifndef __FREDRC_H
-#define __FREDRC_H
-
-#define ABOUT_LINE_1 "FRED2_OPEN - FreeSpace Editor, Version @FSO_PRODUCT_VERSION_STRING@ OpenGL"
-#define MAINFRAME_CONTENTS "FRED2_OPEN @FSO_PRODUCT_VERSION_STRING@ - FreeSpace2 Mission Editor\nUntitled\nFRED2\nFreeSpace2 Missions (*.fs2)\n.fs2\nFreeSpace2Mission\nFreeSpace2 Mission"
-
-#endif // __FREDRC_H

cmake/generateHeaders.cmake

@@ -1,7 +0,0 @@
-
-
-include(Cxx11)
-include(platformChecks)
-
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/project.h.in ${GENERATED_SOURCE_DIR}/project.h)
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/fred_rc.h.in ${GENERATED_SOURCE_DIR}/fred_rc.h)

cmake/globals.cmake

@@ -1,9 +0,0 @@
-
-SET(BINARY_DESTINATION ".")
-SET(LIBRAY_DESTINATION "${BINARY_DESTINATION}")
-
-if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(IS_64BIT TRUE)
-else()
-    set(IS_64BIT FALSE)
-endif()

cmake/headers.cmake

@@ -1,8 +0,0 @@
-
-SET(CODE_HEADERS ${CMAKE_SOURCE_DIR}/code)
-
-SET(FREESPACE_HEADERS ${CMAKE_SOURCE_DIR}/freespace2)
-
-SET(FRED_HEADERS ${CMAKE_SOURCE_DIR}/fred2)
-
-SET(WXFRED_HEADERS ${CMAKE_SOURCE_DIR}/wxfred2)

cmake/package.cmake

@@ -1,14 +0,0 @@
-
-SET(CPACK_PACKAGE_VERSION_MAJOR ${FSO_VERSION_MAJOR})
-SET(CPACK_PACKAGE_VERSION_MINOR ${FSO_VERSION_MINOR})
-SET(CPACK_PACKAGE_VERSION_PATCH ${FSO_VERSION_BUILD})
-
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${FSO_PROJECT_DESCRIPTION})
-
-IF(WIN32)
-	SET(CPACK_NSIS_MUI_ICON ${FSO_INSTALLER_ICON})
-	
-	set(CPACK_NSIS_MENU_LINKS "http://www.hard-light.net/" "FreeSpace Community")
-ENDIF(WIN32)
-
-include(CPack)

cmake/platform-darwin.cmake

@@ -1,34 +0,0 @@
-
-MESSAGE(STATUS "Doing Mac OSX specific things...")
-target_compile_definitions(platform INTERFACE APPLE_APP)
-SET(EXE_GUI_TYPE MACOSX_BUNDLE)
-
-FIND_LIBRARY(COCOA_LIBRARY Cocoa)
-
-if (NOT COCOA_LIBRARY)
-    message(FATAL_ERROR "Couldn't find Cocoa!")
-endif()
-
-target_link_libraries(platform INTERFACE ${COCOA_LIBRARY})
-
-SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.9")
-
-SET(CMAKE_SKIP_RPATH FALSE)
-SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-SET(CMAKE_INSTALL_RPATH @loader_path/../Frameworks/)
-
-# Set the path where library dependencies are copied to
-SET(LIBRAY_DESTINATION "../Frameworks")
-
-set(PLATFORM_MAC TRUE CACHE INTERNAL "" FORCE)
-
-# Generate and don't strip debug symbols
-# These settings don't seem to generate debug symbols for code and Freespace2
-# so those settings are set manually in code and Freespace2's CMakeLists.txt files
-set(CMAKE_XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS "YES")
-set(CMAKE_XCODE_ATTRIBUTE_COPY_PHASE_STRIP "NO")
-set(CMAKE_XCODE_ATTRIBUTE_STRIP_INSTALLED_PRODUCT "NO")
-set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "NO")
-
-# Generate .dSYM file
-set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT "dwarf-with-dsym")

cmake/platform-freebsd.cmake

@@ -1,10 +0,0 @@
-
-target_compile_definitions(platform INTERFACE SCP_BSD)
-
-find_library(EXECINFO_LIB execinfo)
-
-if (NOT EXECINFO_LIB)
-    message(FATAL_ERROR "Couldn't find libexecinfo! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${EXECINFO_LIB}")
-endif()

cmake/platform-solaris.cmake

@@ -1,18 +0,0 @@
-
-target_compile_definitions(platform INTERFACE SCP_SOLARIS)
-
-find_library(SOCKET_LIB socket)
-
-if (NOT SOCKET_LIB)
-    message(FATAL_ERROR "Couldn't find libsocket! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${SOCKET_LIB}")
-endif()
-
-find_library(NSL_LIB nsl)
-
-if (NOT NSL_LIB)
-    message(FATAL_ERROR "Couldn't find libnsl! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${NSL_LIB}")
-endif()

cmake/platform-unix.cmake

@@ -1,13 +0,0 @@
-
-INCLUDE(util)
-
-MESSAGE(STATUS "Configuring UNIX specific things and stuff...")
-
-target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL _REENTRANT)
-
-# Set RPATH
-set(CMAKE_SKIP_BUILD_RPATH TRUE)
-set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-set(CMAKE_INSTALL_RPATH "\$ORIGIN")
-
-set(PLATFORM_UNIX TRUE CACHE INTERNAL "" FORCE)

cmake/platform-win32.cmake

@@ -1,27 +0,0 @@
-
-MESSAGE(STATUS "Configuring Windows specific things and stuff...")
-
-SET(WIN32_LIBS
-	comctl32
-	msacm32
-	odbc32
-	odbccp32
-	vfw32
-	winmm
-	ws2_32
-	psapi
-)
-
-IF (MINGW)
-	SET(WIN32_LIBS ${WIN32_LIBS} mingw32)
-ENDIF (MINGW)
-
-target_link_libraries(platform INTERFACE ${WIN32_LIBS})
-
-target_compile_definitions(platform INTERFACE WIN32 USE_OPENAL _WINDOWS)
-
-# Specify minimum Windows version for the headers (currently this is Vista)
-target_compile_definitions(platform INTERFACE NTDDI_VERSION=0x06000000 _WIN32_WINNT=0x0600)
-
-SET(EXE_GUI_TYPE WIN32)
-set(PLATFORM_WINDOWS TRUE CACHE INTERNAL "" FORCE)

cmake/platformChecks.cmake

@@ -1,47 +0,0 @@
-
-include(CheckFunctionExists)
-include(CheckIncludeFiles)
-include(CheckIncludeFile)
-include(CheckIncludeFileCXX)
-include(CheckLibraryExists)
-include(CheckPrototypeDefinition)
-include(CheckStructHasMember)
-include(CheckSymbolExists)
-include(CheckCXXSymbolExists)
-include(CheckTypeSize)
-
-CHECK_INCLUDE_FILE("execinfo.h" SCP_HAVE_EXECINFO_H)
-CHECK_INCLUDE_FILE_CXX("cxxabi.h" SCP_HAVE_CXXAPI_H)
-
-CHECK_TYPE_SIZE("max_align_t" MAX_ALIGN_T)
-
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    set(CMAKE_REQUIRED_FLAGS "-std=c++11") # required for g++ <= 5
-endif()
-
-set(CMAKE_EXTRA_INCLUDE_FILES "cstddef")
-CHECK_TYPE_SIZE("std::max_align_t" STD_MAX_ALIGN_T LANGUAGE CXX)
-set(CMAKE_EXTRA_INCLUDE_FILES "type_traits")
-CHECK_TYPE_SIZE("std::is_trivially_copyable<int>" STD_IS_TRIVIALLY_COPYABLE LANGUAGE CXX)
-set(CMAKE_EXTRA_INCLUDE_FILES)
-
-CHECK_TYPE_SIZE("char32_t" CHAR32_T LANGUAGE CXX)
-CHECK_TYPE_SIZE("U'b'" UNICODE_CHAR_LITERAL LANGUAGE CXX)
-
-set(CMAKE_REQUIRED_FLAGS)
-
-
-CHECK_FUNCTION_EXISTS(strcasecmp SCP_HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strncasecmp SCP_HAVE_STRNCASECMP)
-
-CHECK_FUNCTION_EXISTS(_stricmp SCP_HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strnicmp SCP_HAVE__STRNICMP)
-
-CHECK_FUNCTION_EXISTS(strlwr SCP_HAVE_STRLWR)
-
-CHECK_INCLUDE_FILE("strings.h" SCP_HAVE_STRINGS_H)
-
-check_symbol_exists(snprintf "stdio.h" SCP_HAVE_SNPRINTF)
-
-set(PLATFORM_CHECK_HEADER "${GENERATED_SOURCE_DIR}/platformChecks.h")
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/platformChecks.h.in "${PLATFORM_CHECK_HEADER}")

cmake/platformChecks.h.in

@@ -1,30 +0,0 @@
-
-#ifndef __PLATFORM_CHECKS_H__
-#define __PLATFORM_CHECKS_H__
-#pragma once
-
-#cmakedefine SCP_HAVE_EXECINFO_H
-#cmakedefine SCP_HAVE_CXXAPI_H
-#cmakedefine SCP_HAVE_MAX_ALIGN_T
-#cmakedefine SCP_HAVE_STD_MAX_ALIGN_T
-
-#cmakedefine01 HAVE_STD_IS_TRIVIALLY_COPYABLE
-
-#cmakedefine01 IS_64BIT
-
-#cmakedefine01 SCP_HAVE_STRCASECMP
-#cmakedefine01 SCP_HAVE_STRNCASECMP
-#cmakedefine01 SCP_HAVE__STRICMP
-#cmakedefine01 SCP_HAVE__STRNICMP
-
-#cmakedefine01 SCP_HAVE_STRLWR
-
-#cmakedefine01 SCP_HAVE_STRINGS_H
-
-#cmakedefine01 HAVE_CHAR32_T
-#cmakedefine01 HAVE_UNICODE_CHAR_LITERAL
-
-#cmakedefine01 SCP_HAVE_SNPRINTF
-#cmakedefine01 SCP_HAVE__SNPRINTF
-
-#endif // __PLATFORM_CHECKS_H__

cmake/platforms.cmake

@@ -1,29 +0,0 @@
-
-add_library(platform INTERFACE)
-
-IF(FSO_CMAKE_DEBUG)
-	INCLUDE(debug-vars)
-ENDIF(FSO_CMAKE_DEBUG)
-
-set(PLATFORM_WINDOWS FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_UNIX FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_LINUX FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_MAC FALSE CACHE INTERNAL "" FORCE)
-
-IF(WIN32)
-	INCLUDE(platform-win32)
-ELSEIF(UNIX)
-	INCLUDE(platform-unix)
-
-	IF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
-		INCLUDE(platform-freebsd)
-	ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-		INCLUDE(platform-solaris)
-	ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-		include(platform-darwin)
-	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-		set(PLATFORM_LINUX TRUE CACHE INTERNAL "" FORCE)
-	ENDIF()
-ELSE(WIN32)
-	MESSAGE(STATUS "This platform is not supported, good luck!")
-ENDIF(WIN32)

cmake/project.h.in

@@ -1,17 +0,0 @@
-
-
-#ifndef __PROJECT_H
-#define __PROJECT_H
-
-#define FS_VERSION_MAJOR @FSO_VERSION_MAJOR@
-#define FS_VERSION_MINOR @FSO_VERSION_MINOR@
-#define FS_VERSION_BUILD @FSO_VERSION_BUILD@
-#define FS_VERSION_REVIS @FSO_VERSION_REVISION@
-#define FS_VERSION_REVIS_STR "@FSO_VERSION_REVISION_STR@"
-
-#define FS_VERSION_HAS_REVIS @FSO_VERSION_HAS_REVISION@
-
-#define FS_VERSION_FULL "@FSO_FULL_VERSION_STRING@"
-#define FS_PRODUCT_VERSION "@FSO_PRODUCT_VERSION_STRING@"
-
-#endif // __PROJECT_H

cmake/toolchain-apple-clang.cmake

@@ -1,18 +0,0 @@
-
-MESSAGE(STATUS "Doing configuration specific to Apple Clang...")
-
-# TODO: Actually add Mac specific flags here...
-
-# Suppress specific warning
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -funroll-loops -fsigned-char -Wno-unknown-pragmas")
-
-# Omit "conversion from string literal to 'char *' is deprecated" warnings.
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-write-strings")
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated -Wno-char-subscripts")
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
-
-set(CMAKE_CXX_FLAGS_RELEASE "-Wno-unused-variable")
-
-set(CMAKE_CXX_FLAGS_DEBUG "-Wextra -Wshadow -Wno-unused-parameter")

cmake/toolchain-clang.cmake

@@ -1,131 +0,0 @@
-# Clang
-include(EnableExtraCompilerWarnings)
-include(CheckCXXCompilerFlag)
-
-MESSAGE(STATUS "Doing configuration specific to clang...")
-
-option(CLANG_ENABLE_LEAK_CHECK "Enable -fsanitize=leak" OFF)
-option(CLANG_ENABLE_ADDRESS_SANITIZER "Enable -fsanitize=address" OFF)
-
-option(CLANG_USE_LIBCXX "Use libc++" OFF)
-
-# These are the default values
-set(C_BASE_FLAGS "-march=native -pipe")
-set(CXX_BASE_FLAGS "-march=native -pipe")
-
-# For C and C++, the values can be overwritten independently
-if(DEFINED ENV{CXXFLAGS})
-	set(CXX_BASE_FLAGS $ENV{CXXFLAGS})
-endif()
-if(DEFINED ENV{CFLAGS})
-	set(C_BASE_FLAGS $ENV{CFLAGS})
-endif()
-
-if (CLANG_USE_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -stdlib=libc++")
-	target_link_libraries(compiler INTERFACE "c++" "c++abi")
-endif()
-
-# Initialize with an empty string to make sure we always get a clean start
-set(COMPILER_FLAGS "")
-
-# This is a slight hack since our flag setup is a bit more complicated
-_enable_extra_compiler_warnings_flags()
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -funroll-loops -fsigned-char -Wno-unknown-pragmas")
-
-# Omit "argument unused during compilation" when clang is used with ccache.
-if(${CMAKE_CXX_COMPILER} MATCHES "ccache")
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Qunused-arguments")
-endif()
-
-if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
-	# Force color diagnostics for Ninja generator
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdiagnostics-color")
-endif()
-
-# Start with an empty list
-set(SANITIZE_FLAGS)
-
-if(CLANG_ENABLE_ADDRESS_SANITIZER)
-	set(CMAKE_REQUIRED_FLAGS "-fsanitize=address")
-	CHECK_C_COMPILER_FLAG("-fsanitize=address" SUPPORTS_SANITIZE_ADDRESS)
-
-	if (SUPPORTS_SANITIZE_ADDRESS)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "address")
-	endif()
-endif()
-if (CLANG_ENABLE_LEAK_CHECK)
-	check_linker_flag("-fsanitize=leak" SUPPORTS_FSANITIZE_LEAK)
-
-	if (SUPPORTS_FSANITIZE_LEAK)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "leak")
-	endif()
-endif()
-
-string(REPLACE ";" "," SANITIZE_FLAGS "${SANITIZE_FLAGS}")
-if (NOT "${SANITIZE_FLAGS}" STREQUAL "")
-	set(SANITIZE_FLAGS "-fsanitize=${SANITIZE_FLAGS}")
-endif()
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${SANITIZE_FLAGS}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wformat-security")
-
-# Dear Clang, please tell us if a function does not return a value since that part of the standard is stupid!
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wreturn-type")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-char-subscripts")
-
-check_cxx_compiler_flag(-Wshift-negative-value SUPPORTS_SHIFT_NEGATIVE_VALUE)
-if(SUPPORTS_SHIFT_NEGATIVE_VALUE)
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-shift-negative-value")
-endif()
-
-set(COMPILER_FLAGS_RELEASE "-O2 -Wno-unused-variable -Wno-unused-parameter")
-
-set(COMPILER_FLAGS_DEBUG "-O0 -g -Wshadow")
-
-# Always use the base flags and add our compiler flags at the bacl
-set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
-set(CMAKE_C_FLAGS "${C_BASE_FLAGS} ${COMPILER_FLAGS}")
-
-set(CMAKE_CXX_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
-set(CMAKE_C_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
-
-set(CMAKE_CXX_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
-set(CMAKE_C_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
-
-
-set(CMAKE_EXE_LINKER_FLAGS "")
-
-if (CLANG_USE_LIBCXX)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
-endif()
-
-if (SANITIZE_FLAGS)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZE_FLAGS}")
-endif()
-
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "")
-set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-g -rdynamic")
-
-if (FSO_FATAL_WARNINGS)
-	# Make warnings fatal if the right variable is set
-	target_compile_options(compiler INTERFACE "-Werror")
-endif()
-
-# Always define this to make sure that the fixed width format macros are available
-target_compile_definitions(compiler INTERFACE __STDC_FORMAT_MACROS)
-
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
-	# GNU ar: Create thin archive files.
-	# Requires binutils-2.19 or later.
-	set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-endif()
-
-target_link_libraries(compiler INTERFACE m)

cmake/toolchain-gcc.cmake

@@ -1,173 +0,0 @@
-
-include(EnableExtraCompilerWarnings)
-include(CheckCCompilerFlag)
-include(util)
-
-MESSAGE(STATUS "Doing configuration specific to gcc...")
-
-option(GCC_ENABLE_LEAK_CHECK "Enable -fsanitize=leak" OFF)
-option(GCC_ENABLE_ADDRESS_SANITIZER "Enable -fsanitize=address" OFF)
-option(GCC_ENABLE_SANITIZE_UNDEFINED "Enable -fsanitize=undefined" OFF)
-option(GCC_USE_GOLD "Use the gold linker instead of the standard linker" OFF)
-option(GCC_GENERATE_GDB_INDEX "Adds linker option to generate the gdb index for debug builds" OFF)
-
-# These are the default values
-set(C_BASE_FLAGS "-march=native -pipe")
-set(CXX_BASE_FLAGS "-march=native -pipe")
-
-# For C and C++, the values can be overwritten independently
-if(DEFINED ENV{CFLAGS})
-	set(C_BASE_FLAGS $ENV{CFLAGS})
-endif()
-if(DEFINED ENV{CXXFLAGS})
-	set(CXX_BASE_FLAGS $ENV{CXXFLAGS})
-endif()
-
-# Initialize with an empty string to make sure we always get a clean start
-set(COMPILER_FLAGS "")
-set(LINKER_FLAGS "")
-
-if (GCC_USE_GOLD)
-	OPTION(GCC_INCREMENTAL_LINKING "Use incremental linking" OFF)
-	set(LINKER_FLAGS "${LINKER_FLAGS} -fuse-ld=gold")
-
-	if (GCC_INCREMENTAL_LINKING)
-		set(LINKER_FLAGS "${LINKER_FLAGS} -fno-use-linker-plugin -Wl,-z,norelro -Wl,--incremental")
-	endif()
-endif()
-
-# This is a slight hack since our flag setup is a bit more complicated
-_enable_extra_compiler_warnings_flags()
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -funroll-loops -fsigned-char -Wno-unknown-pragmas")
-
-if (NOT GCC_INCREMENTAL_LINKING)
-	# Place each function and data in its own section so the linker can
-	# perform dead code elimination
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdata-sections -ffunction-sections")
-endif()
-
-if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
-	# Force color diagnostics for Ninja generator
-	CHECK_C_COMPILER_FLAG(-fdiagnostics-color SUPPORTS_DIAGNOSTIC_COLOR)
-
-	if(SUPPORTS_DIAGNOSTIC_COLOR)
-		set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdiagnostics-color")
-	endif()
-endif()
-
-# Start with an empty list
-set(SANITIZE_FLAGS)
-
-if(GCC_ENABLE_ADDRESS_SANITIZER)
-	set(CMAKE_REQUIRED_FLAGS "-fsanitize=address")
-	CHECK_C_COMPILER_FLAG("-fsanitize=address" SUPPORTS_SANITIZE_ADDRESS)
-
-	if (SUPPORTS_SANITIZE_ADDRESS)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "address")
-	endif()
-endif()
-if (GCC_ENABLE_LEAK_CHECK)
-	check_linker_flag("-fsanitize=leak" SUPPORTS_FSANITIZE_LEAK)
-
-	if (SUPPORTS_FSANITIZE_LEAK)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "leak")
-	endif()
-endif()
-if (GCC_ENABLE_SANITIZE_UNDEFINED)
-	check_linker_flag("-fsanitize=undefined" SUPPORTS_SANITIZE_UNDEFINED)
-
-	if (SUPPORTS_SANITIZE_UNDEFINED)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "undefined")
-	endif()
-endif()
-
-string(REPLACE ";" "," SANITIZE_FLAGS "${SANITIZE_FLAGS}")
-if (NOT "${SANITIZE_FLAGS}" STREQUAL "")
-	set(SANITIZE_FLAGS "-fsanitize=${SANITIZE_FLAGS}")
-endif()
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${SANITIZE_FLAGS}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wformat-security")
-
-# Dear GCC, please tell us if a function does not return a value since that part of the standard is stupid!
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wreturn-type")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-deprecated -Wno-char-subscripts")
-
-# These two warnings cause a lot of false-positives in the FSO code base
-check_cxx_compiler_flag(-Wstringop-truncation SUPPORTS_STRINGOP_TRUNCATION)
-if(SUPPORTS_STRINGOP_TRUNCATION)
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-stringop-truncation")
-endif()
-
-check_cxx_compiler_flag(-Wstringop-overflow SUPPORTS_STRINGOP_OVERFLOW)
-if(SUPPORTS_STRINGOP_TRUNCATION)
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-stringop-overflow")
-endif()
-
-set(COMPILER_FLAGS_RELEASE "-O2 -Wno-unused-variable -Wno-unused-but-set-variable -Wno-array-bounds -Wno-empty-body -Wno-clobbered  -Wno-unused-parameter")
-
-set(COMPILER_FLAGS_DEBUG "-O0 -g -Wshadow")
-
-# Always use the base flags and add our compiler flags at the back
-set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
-set(CMAKE_C_FLAGS "${C_BASE_FLAGS} ${COMPILER_FLAGS}")
-
-set(CMAKE_CXX_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
-set(CMAKE_C_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
-
-set(CMAKE_CXX_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
-set(CMAKE_C_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
-
-set(CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}")
-
-IF (MINGW)
-	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static -static-libgcc -static-libstdc++ -Wl,--enable-auto-import")
-	target_compile_definitions(compiler INTERFACE __USE_MINGW_ANSI_STDIO=1)
-ENDIF(MINGW)
-
-if (SANITIZE_FLAGS)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZE_FLAGS}")
-endif()
-
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "")
-set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-g")
-
-if (GCC_GENERATE_GDB_INDEX)
-	# For pure debug binaries, generate a gdb index for better debugging
-	SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -Wl,--gdb-index")
-endif()
-
-IF(NOT MINGW)
-	SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -rdynamic")
-	# Allow the linker to perform dead code elimination; this is considered
-	# experimental for COFF and PE formats and thus disabled for Windows builds
-	# (https://sourceware.org/binutils/docs/ld/Options.html)
-	if (NOT GCC_INCREMENTAL_LINKING AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-		SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
-	endif()
-ENDIF(NOT MINGW)
-
-IF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-zignore")
-ENDIF()
-
-if (FSO_FATAL_WARNINGS)
-	# Make warnings fatal if the right variable is set
-	target_compile_options(compiler INTERFACE "-Werror")
-endif()
-
-# Always define this to make sure that the fixed width format macros are available
-target_compile_definitions(compiler INTERFACE __STDC_FORMAT_MACROS=1)
-
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
-	# GNU ar: Create thin archive files.
-	# Requires binutils-2.19 or later.
-	set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-endif()

cmake/toolchain-msvc.cmake

@@ -1,145 +0,0 @@
-
-include(EnableExtraCompilerWarnings)
-include(CheckCXXCompilerFlag)
-include(util)
-
-MESSAGE(STATUS "Doing configuration specific to visual studio...")
-
-set_property(GLOBAL PROPERTY DEBUG_CONFIGURATIONS Debug)
-
-option(MSVC_USE_RUNTIME_DLL "Use the dynamically linked version of the runtime" OFF)
-option(MSVC_RELEASE_DEBUGGING "Set options that allow to debug release builds" OFF)
-
-MARK_AS_ADVANCED(FORCE MSVC_USE_RUNTIME_DLL)
-MARK_AS_ADVANCED(FORCE MSVC_RELEASE_DEBUGGING)
-
-# These are the warnings we disable
-set(WARNING_FLAGS
-	/wd4100 # unreferenced formal parameters
-	/wd4127 # constant conditional (assert)
-	/wd4201 # nonstandard extension used: nameless struct/union (happens a lot in Windows include headers)
-	/wd4290 # C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
-	/wd4390 # empty control statement (triggered by nprintf and mprintf's inside of one-line if's, etc)
-	/wd4410 # illegal size for operand... ie... 	fxch st(1)
-	/wd4511 # copy constructor could not be generated (happens a lot in Windows include headers)
-	/wd4512 # assignment operator could not be generated (happens a lot in Windows include headers)
-	/wd4514 # unreferenced inline function removed
-	/wd4611 # _setjmp warning.  Since we use setjmp alot, and we don't really use constructors or destructors, this warning doesn't really apply to us.
-	/wd4663 # C++ language change (template specification)
-	/wd4710 # is inline function not expanded (who cares?)
-	/wd4711 # tells us an inline function was expanded (who cares?)
-	/wd4786 # is identifier truncated to 255 characters (happens all the time in Microsoft #includes) -- Goober5000"
-	/wd4996 # deprecated strcpy, strcat, sprintf, etc. (from MSVC 2005) - taylor
-	/wd4311 # Disables warnings about casting pointer types to ints. The funny thing is these warnings can't be resolved, just disabled... - m!m
-	/wd4302 # Same as above - m!m
-	/wd4366 # The result of the unary '&' operator may be unaligned - m!m
-	/wd4592 # "symbol will be dynamically initialized" is being generated by a compiler bug, see https://stackoverflow.com/a/34027257 for an explanation - m!m
-	$<$<CONFIG:Release>:/wd4101> # In release mode there are unreferenced variables because debug needs them
-	/wd4995 # "'vsprintf': name was marked as #pragma deprecated" is being caused by our custom definition of vsprintf. I have no idea what causes this or how to fix it - m!m
-	/wd4723 # "potential divide by 0" is caused by some code that definitely will not divide by zero - m!m
-	/wd4121 # "alignment of a member was sensitive to packing" happens in a Windows header - m!m
-)
-
-target_compile_options(compiler INTERFACE ${WARNING_FLAGS})
-
-# Base
-set(CMAKE_C_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
-set(CMAKE_CXX_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
-
-set(CMAKE_EXE_LINKER_FLAGS "/MANIFEST /DYNAMICBASE:NO /SAFESEH:NO /ERRORREPORT:PROMPT /NOLOGO")
-set(CMAKE_STATIC_LINKER_FLAGS "")
-
-# Release
-set(CMAKE_C_FLAGS_RELEASE "/GL /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
-set(CMAKE_CXX_FLAGS_RELEASE "/GL /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
-# /DEBUG:FULL so that we get PDBs which is needed for debugging crashdumps
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/OPT:REF /LTCG /INCREMENTAL:NO /DEBUG:FULL")
-set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "/LTCG")
-
-globally_enable_extra_compiler_warnings()
-
-if (MSVC_RELEASE_DEBUGGING)
-	CHECK_CXX_COMPILER_FLAG("/Zo" MSVC_COMPILER_SUPPORTS_ARCH_ZO)
-
-	if (MSVC_COMPILER_SUPPORTS_ARCH_ZO)
-		set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zo")
-		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zo")
-	endif()
-endif()
-
-IF(MSVC_USE_RUNTIME_DLL)
-	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MD")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
-ELSE(MSVC_USE_RUNTIME_DLL)
-	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
-ENDIF(MSVC_USE_RUNTIME_DLL)
-
-# Debug
-set(CMAKE_C_FLAGS_DEBUG "/W4 /Gy /Zi /Od /RTC1 /Gd /Oy-")
-set(CMAKE_CXX_FLAGS_DEBUG "/W4 /Gy /Zi /Od /RTC1 /Gd /Oy-")
-set(CMAKE_EXE_LINKER_FLAGS_DEBUG "/DEBUG /INCREMENTAL:NO /MAPINFO:EXPORTS /NODEFAULTLIB:libcmt.lib")
-
-IF(MSVC_USE_RUNTIME_DLL)
-	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MDd")
-	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
-ELSE(MSVC_USE_RUNTIME_DLL)
-	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
-	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
-ENDIF(MSVC_USE_RUNTIME_DLL)
-
-INCLUDE(MSVCMultipleProcessCompile)
-
-# Visual Studio supports compiling for multiple vector instruction sets
-SET(POSSIBLE_INSTUCTION_SETS "" SSE SSE2 AVX AVX2)
-
-if (NOT DEFINED MSVC_SIMD_INSTRUCTIONS)
-	detect_simd_instructions(MSVC_DETECTED_SIMD_INSTRUCTIONS)
-
-	SET(MSVC_SIMD_INSTRUCTIONS "${MSVC_DETECTED_SIMD_INSTRUCTIONS}" CACHE FILEPATH "The SIMD instructions which will be used, possible values are ${POSSIBLE_INSTUCTION_SETS}")
-	MARK_AS_ADVANCED(FORCE MSVC_SIMD_INSTRUCTIONS)
-endif()
-set(FSO_INSTRUCTION_SET ${MSVC_SIMD_INSTRUCTIONS})
-
-LIST(FIND POSSIBLE_INSTUCTION_SETS "${MSVC_SIMD_INSTRUCTIONS}" SET_INDEX)
-
-if (SET_INDEX LESS 0)
-	MESSAGE(STATUS "An invalid instruction set was specified, defaulting to no special compiler options.")
-else()
-	IF (NOT SET_INDEX EQUAL 0)
-		SET(FOUND)
-
-		FOREACH(list_index RANGE ${SET_INDEX} 1)
-			list(GET POSSIBLE_INSTUCTION_SETS ${list_index} _simd_set)
-			CHECK_CXX_COMPILER_FLAG("/arch:${_simd_set}" COMPILER_SUPPORTS_ARCH_${_simd_set})
-
-			IF(COMPILER_SUPPORTS_ARCH_${_simd_set})
-				set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:${_simd_set}")
-				set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:${_simd_set}")
-
-				SET(FOUND TRUE)
-				BREAK()
-			ENDIF()
-		ENDFOREACH(list_index)
-
-		IF(NOT FOUND)
-			# Don't set anything, it will likely not work
-			MESSAGE(STATUS "Your compiler does not support any optimization flags, defaulting to none")
-		ENDIF(NOT FOUND)
-	ELSE()
-		CHECK_CXX_COMPILER_FLAG("/arch:IA32" COMPILER_SUPPORTS_ARCH_IA32)
-
-		IF(COMPILER_SUPPORTS_ARCH_IA32)
-			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:IA32")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:IA32")
-		ENDIF(COMPILER_SUPPORTS_ARCH_IA32)
-	ENDIF()
-endif()
-
-target_compile_definitions(compiler INTERFACE _CRT_SECURE_NO_DEPRECATE _CRT_SECURE_NO_WARNINGS _SECURE_SCL=0 NOMINMAX
-		"$<$<CONFIG:FastDebug>:_ITERATOR_DEBUG_LEVEL=0>" _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
-
-if (FSO_FATAL_WARNINGS)
-	# Make warnings fatal if the right variable is set
-	target_compile_options(compiler INTERFACE "/WX")
-endif()

cmake/toolchain.cmake

@@ -1,36 +0,0 @@
-
-# File to execute compiler specific commands
-
-add_library(compiler INTERFACE)
-
-target_compile_definitions(compiler INTERFACE "$<$<CONFIG:Release>:NDEBUG>;$<$<CONFIG:Debug>:_DEBUG>;$<$<CONFIG:FastDebug>:_DEBUG>")
-
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	include(toolchain-gcc)
-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-	include(toolchain-msvc)
-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-	include(toolchain-clang)
-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
-	include(toolchain-apple-clang)
-ELSE("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	MESSAGE(STATUS "No special handling for this compiler present, good luck!")
-ENDIF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-
-find_package(Threads REQUIRED)
-target_link_libraries(compiler INTERFACE Threads::Threads)
-
-# Copy release settings to FastDebug
-set(CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_RELEASE}")
-set(CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_RELEASE}")
-set(CMAKE_EXE_LINKER_FLAGS_FASTDEBUG "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
-set(CMAKE_STATIC_LINKER_FLAGS_FASTDEBUG "${CMAKE_STATIC_LINKER_FLAGS_RELEASE}")
-
-if (MSVC)
-	# Adjust runtime library
-	string(REPLACE "/MD" "/MDd" CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_FASTDEBUG}")
-	string(REPLACE "/MT" "/MTd" CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_FASTDEBUG}")
-	
-	string(REPLACE "/MD" "/MDd" CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_FASTDEBUG}")
-	string(REPLACE "/MT" "/MTd" CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_FASTDEBUG}")
-endif()

cmake/util.cmake

@@ -1,273 +0,0 @@
-
-include(CheckCCompilerFlag)
-
-FUNCTION(MAKE_CACHE_INTERNAL VARIABLE)
-	SET(${VARIABLE} ${${VARIABLE}} CACHE INTERNAL "Internal cache variable")
-ENDFUNCTION(MAKE_CACHE_INTERNAL)
-
-FUNCTION(ADD_IMPORTED_LIB NAME INCLUDES LIBS)
-	ADD_LIBRARY(${NAME} INTERFACE)
-
-	target_link_libraries(${NAME} INTERFACE "${LIBS}")
-
-	target_include_directories(${NAME} SYSTEM INTERFACE "${INCLUDES}")
-ENDFUNCTION(ADD_IMPORTED_LIB)
-
-MACRO(PKG_CONFIG_LIB_RESOLVE NAME OUTVAR)
-	SET(${OUTVAR} "")
-	foreach(lib ${${NAME}_LIBRARIES})
-		find_library(${lib}_LIBRARY
-					NAMES ${lib}
-					HINTS ${${NAME}_LIBDIR} ${${NAME}_LIBRARY_DIRS}
-		)
-
-		if (NOT ${${lib}_LIBRARY} MATCHES ".*NOTFOUND.*")
-			SET(${OUTVAR} ${${OUTVAR}} ${${lib}_LIBRARY})
-		endif (NOT ${${lib}_LIBRARY} MATCHES ".*NOTFOUND.*")
-	endforeach(lib)
-ENDMACRO(PKG_CONFIG_LIB_RESOLVE)
-
-# Copy from http://cmake.3232098.n2.nabble.com/RFC-cmake-analog-to-AC-SEARCH-LIBS-td7585423.html
-INCLUDE (CheckFunctionExists)
-INCLUDE (CheckLibraryExists)
-
-MACRO (CMAKE_SEARCH_LIBS v_func v_lib func)
-    CHECK_FUNCTION_EXISTS (${func} ${v_func})
-    IF (NOT ${v_func})
-        FOREACH (lib ${ARGN})
-            CHECK_LIBRARY_EXISTS (${lib} ${func} "" "HAVE_${func}_IN_${lib}")
-            IF (${HAVE_${func}_IN_${lib}})
-                SET (${v_func} TRUE)
-                SET (${v_lib} "${lib}" CACHE INTERNAL "Library providing ${func}")
-                BREAK()
-            ENDIF (${HAVE_${func}_IN_${lib}})
-        ENDFOREACH (lib)
-    ENDIF (NOT ${v_func})
-ENDMACRO (CMAKE_SEARCH_LIBS)
-# End copy
-
-FUNCTION(EP_CHECK_FILE_EXISTS FILE OUTVAR TARGET NAME COMMAND WORKING_DIR)
-	string (REPLACE ";" " " COMMAND_STR "${COMMAND}")
-	IF(WIN32)
-		# Do something special for windows...
-		SET(COMMAND "cmd /C \"${COMMAND_STR}\"")
-	ELSE(WIN32)
-		SET(COMMAND "${COMMAND_STR}")
-	ENDIF(WIN32)
-
-	FILE(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${NAME}" "
-IF(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${FILE}\")
-	MESSAGE(\"'${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${FILE}' already exists, nothing to be done.\")
-ELSE(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${FILE}\")
-	execute_process(COMMAND ${COMMAND} WORKING_DIRECTORY \"${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${WORKING_DIR}\")
-ENDIF(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${FILE}\")
-")
-
-	SET(${OUTVAR} "${CMAKE_COMMAND}" -P ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${NAME} PARENT_SCOPE)
-ENDFUNCTION(EP_CHECK_FILE_EXISTS)
-
-MACRO(COPY_FILE_TO_TARGET _target _file)
-	if(UNIX)
-		ADD_CUSTOM_COMMAND(
-			TARGET ${_target} POST_BUILD
-			COMMAND cp -a "${_file}"  "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
-			COMMENT "copying '${_file}'..."
-		)
-	else()
-		ADD_CUSTOM_COMMAND(
-			TARGET ${_target} POST_BUILD
-			COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_file}"  "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
-			COMMENT "copying '${_file}'..."
-		)
-	endif()
-endmacro(COPY_FILE_TO_TARGET)
-
-MACRO(COPY_FILES_TO_TARGET _target)
-	if(UNIX)
-		ADD_CUSTOM_COMMAND(
-			TARGET ${_target} POST_BUILD
-			COMMAND mkdir -p "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
-			COMMENT "Creating '$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/'..."
-		)
-	endif()
-	
-	FOREACH(file IN LISTS TARGET_COPY_FILES)
-		COPY_FILE_TO_TARGET("${_target}" "${file}")
-	ENDFOREACH(file)
-ENDMACRO(COPY_FILES_TO_TARGET)
-
-macro(_clear_old_libraries_state)
-	set(is_debug FALSE)
-	set(is_optimized FALSE)
-endmacro(_clear_old_libraries_state)
-
-function(CONVERT_OLD_LIBRARIES)
-	_clear_old_libraries_state()
-	set(out_list)
-	foreach(lib ${ARGV})
-		if ("${lib}" STREQUAL "debug")
-			_clear_old_libraries_state()
-			set(is_debug TRUE)
-		elseif("${lib}" STREQUAL "optimized")
-			_clear_old_libraries_state()
-			set(is_optimized TRUE)
-		elseif("${lib}" STREQUAL "general")
-			_clear_old_libraries_state()
-		else("${lib}" STREQUAL "debug")
-			# Expecting normal library
-			if(is_debug)
-				list(APPEND out_list "$<$<CONFIG:Debug>:${lib}>" "$<$<CONFIG:FastDebug>:${lib}>")
-			elseif(is_optimized)
-				list(APPEND out_list "$<$<CONFIG:Release>:${lib}>")
-			else(is_debug)
-				list(APPEND out_list "${lib}")
-			endif(is_debug)
-		endif("${lib}" STREQUAL "debug")
-	endforeach(lib)
-
-	set(CONVERTED_LIBRARIES ${out_list} PARENT_SCOPE)
-endfunction(CONVERT_OLD_LIBRARIES)
-
-macro(set_policy policy value)
-	if (POLICY ${policy})
-		cmake_policy(SET ${policy} ${value})
-	endif ()
-endmacro(set_policy)
-
-macro(set_if_not_defined VAR VALUE)
-    if (NOT DEFINED ${VAR})
-        set(${VAR} ${VALUE})
-    endif()
-endmacro(set_if_not_defined)
-
-function(set_precompiled_header _target _headerPath)
-	if (COMMAND target_precompile_headers)
-		target_compile_definitions(${_target} PRIVATE CMAKE_PCH)
-		target_precompile_headers(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${_headerPath}>")
-	else()
-		if (ENABLE_COTIRE)
-			message("${_headerPath}")
-			set_target_properties(${_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${_headerPath}")
-
-			# Disable unity build as it doesn't work well for us
-			set_target_properties(${_target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
-
-			cotire(${_target})
-		else()
-			if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/FI ${_headerPath}>")
-			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-			ELSE()
-				MESSAGE("Unknown compiler for global includes. This will probably break the build.")
-			ENDIF()
-		endif()
-	endif()
-endfunction()
-
-macro(add_target_copy_files)
-	foreach(file ${ARGN})
-		if (IS_DIRECTORY "${file}")
-			INSTALL(DIRECTORY ${file}
-					DESTINATION ${LIBRAY_DESTINATION}
-					)
-		else()
-			INSTALL(FILES ${file}
-					DESTINATION ${LIBRAY_DESTINATION}
-					)
-		endif()
-
-		SET(TARGET_COPY_FILES ${TARGET_COPY_FILES} ${file} CACHE INTERNAL "" FORCE)
-	endforeach()
-endmacro(add_target_copy_files)
-
-function(detect_simd_instructions _out_var)
-	if(CMAKE_CROSSCOMPILING)
-		set(${_out_var} "" PARENT_SCOPE)
-	else()
-		message(STATUS "Detecting SIMD features of current CPU...")
-		TRY_RUN(RUN_RESULT COMPILE_RESULT "${CMAKE_BINARY_DIR}/temp" "${CMAKE_SOURCE_DIR}/cmake/cpufeatures.cpp"
-			RUN_OUTPUT_VARIABLE FEATURE_OUTPUT)
-		
-		IF(COMPILE_RESULT)
-			MESSAGE(STATUS "Detected compatibility for the ${FEATURE_OUTPUT} feature set.")
-			SET(${_out_var} ${FEATURE_OUTPUT} PARENT_SCOPE)
-		ELSE(COMPILE_RESULT)
-			MESSAGE("Compilation of CPU feature detector failed, please set the instruction set manually.")
-			set(${_out_var} "" PARENT_SCOPE)
-		ENDIF(COMPILE_RESULT)
-	endif()
-endfunction()
-
-function (check_linker_flag _flag _out_var)
-	SET(CMAKE_REQUIRED_LINK_OPTIONS "${_flag}")
-	CHECK_C_COMPILER_FLAG("" ${_out_var})
-endfunction(check_linker_flag)
-
-# Suppresses warnings for the specified target
-function(suppress_warnings _target)
-    if (MSVC)
-        target_compile_options(${_target} PRIVATE "/W0")
-	else()
-        # Assume everything else uses GCC style options
-		target_compile_options(${_target} PRIVATE "-w")
-    endif()
-endfunction(suppress_warnings)
-
-# Suppresses warnings for the specified files
-function(suppress_file_warnings)
-	if (MSVC)
-		set_source_files_properties(
-				${ARGN}
-			PROPERTIES
-				COMPILE_FLAGS "/W0")
-	else()
-		# Assume everything else uses GCC style options
-		set_source_files_properties(
-				${ARGN}
-			PROPERTIES
-				COMPILE_FLAGS "-w")
-	endif()
-endfunction(suppress_file_warnings)
-
-
-function(list_target_dependencies _target _out_var)
-	set(out_list)
-	set(work_libs ${_target})
-	list(LENGTH work_libs libs_length)
-
-	while(libs_length GREATER 0)
-		list(GET work_libs 0 current)
-		list(REMOVE_AT work_libs 0)
-		list(APPEND out_list ${current})
-
-		get_target_property(current_libs ${current} INTERFACE_LINK_LIBRARIES)
-
-		if(current_libs)
-			foreach(lib ${current_libs})
-				if (TARGET ${lib})
-					list(APPEND work_libs ${lib})
-				endif (TARGET ${lib})
-			endforeach(lib)
-		endif(current_libs)
-
-		list(LENGTH work_libs libs_length)
-	endwhile(libs_length GREATER 0)
-
-	list(REMOVE_DUPLICATES out_list)
-	set(${_out_var} ${out_list} PARENT_SCOPE)
-endfunction(list_target_dependencies)
-
-macro(add_file_folder FOLDER_NAME)
-	string(MAKE_C_IDENTIFIER "${FOLDER_NAME}" VARIABLE_NAME)
-	set(files_${VARIABLE_NAME} ${files_${VARIABLE_NAME}} ${ARGN})
-
-	string(REPLACE "/" "\\" FIXED_FOLDER_FILE "${FOLDER_NAME}")
-
-	source_group("${FIXED_FOLDER_FILE}" FILES ${ARGN})
-	set(source_files ${source_files} ${ARGN})
-endmacro(add_file_folder)

cmake/version.cmake

@@ -1,52 +0,0 @@
-
-include(util)
-
-if (EXISTS "${PROJECT_SOURCE_DIR}/version_override.cmake")
-    # This allows to override the values by using a special file
-    include("${PROJECT_SOURCE_DIR}/version_override.cmake")
-endif()
-
-set_if_not_defined(FSO_VERSION_MAJOR 20)
-set_if_not_defined(FSO_VERSION_MINOR 1)
-set_if_not_defined(FSO_VERSION_BUILD 0)
-
-# A numeric revision e.g. the CI build number
-set_if_not_defined(FSO_VERSION_REVISION 0)
-
-# A generic revision string, can be anything
-set_if_not_defined(FSO_VERSION_REVISION_STR "${FSO_VERSION_REVISION}")
-
-if("${FSO_VERSION_REVISION}" STREQUAL "0" AND "${FSO_VERSION_REVISION_STR}" STREQUAL "${FSO_VERSION_REVISION}")
-    set(FSO_VERSION_HAS_REVISION 0)
-else()
-    set(FSO_VERSION_HAS_REVISION 1)
-endif()
-
-set(FSO_FULL_VERSION_STRING "${FSO_VERSION_MAJOR}.${FSO_VERSION_MINOR}.${FSO_VERSION_BUILD}")
-set(FSO_PRODUCT_VERSION_STRING "${FSO_FULL_VERSION_STRING}")
-
-if (FSO_VERSION_HAS_REVISION)
-    set(FSO_FULL_VERSION_STRING "${FSO_FULL_VERSION_STRING}.${FSO_VERSION_REVISION_STR}")
-endif()
-
-IF(NOT FSO_VERSION_HAS_REVISION)
-    SET(FSO_BINARY_SUFFIX "${FSO_VERSION_MAJOR}_${FSO_VERSION_MINOR}_${FSO_VERSION_BUILD}")
-ELSE()
-    SET(FSO_BINARY_SUFFIX "${FSO_VERSION_MAJOR}_${FSO_VERSION_MINOR}_${FSO_VERSION_BUILD}_${FSO_VERSION_REVISION_STR}")
-ENDIF()
-
-IF(IS_64BIT)
-	# This is a 64-bit builds
-    SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_x64")
-ENDIF()
-
-IF (NOT "${FSO_INSTRUCTION_SET}" STREQUAL "")
-    SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_${FSO_INSTRUCTION_SET}")
-ENDIF()
-
-IF (NOT "${FSO_BUILD_POSTFIX}" STREQUAL "")
-    SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_${FSO_BUILD_POSTFIX}")
-ENDIF()
-
-set(CONFIG_POSTFIX "$<$<CONFIG:Release>:>$<$<CONFIG:Debug>:-DEBUG>$<$<CONFIG:FastDebug>:-FASTDBG>")
-set(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}${CONFIG_POSTFIX}")

code/CMakeLists.txt

@@ -1,105 +0,0 @@
-
-include(util)
-
-INCLUDE(source_groups.cmake)
-INCLUDE(voice_rec.cmake)
-
-ADD_LIBRARY(code STATIC ${source_files} ${VOICE_REC_FILES})
-
-target_compile_features(code PUBLIC cxx_std_11)
-
-if (MSVC)
-	target_compile_definitions(code PUBLIC "PDB_DEBUGGING=1")
-endif(MSVC)
-
-TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${CODE_HEADERS})
-TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${FREESPACE_HEADERS})
-
-TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${GENERATED_SOURCE_DIR})
-TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${GENERATED_SOURCE_DIR}/code)
-
-if (FSO_BUILD_WITH_OPENGL)
-	target_link_libraries(code PUBLIC OpenGL)
-endif()
-
-TARGET_LINK_LIBRARIES(code PUBLIC openal)
-TARGET_LINK_LIBRARIES(code PUBLIC ${LUA_LIBS})
-TARGET_LINK_LIBRARIES(code PUBLIC ${PNG_LIBS})
-TARGET_LINK_LIBRARIES(code PUBLIC ${JPEG_LIBS})
-
-TARGET_LINK_LIBRARIES(code PUBLIC sdl2)
-
-if (FSO_BUILD_WITH_FFMPEG)
-	TARGET_LINK_LIBRARIES(code PUBLIC ffmpeg)
-endif()
-
-TARGET_LINK_LIBRARIES(code PUBLIC utfcpp)
-
-TARGET_LINK_LIBRARIES(code PUBLIC platform)
-TARGET_LINK_LIBRARIES(code PUBLIC compiler)
-
-target_link_libraries(code PUBLIC md5)
-
-target_link_libraries(code PUBLIC discord-rpc)
-
-target_link_libraries(code PUBLIC libRocket)
-
-target_link_libraries(code PUBLIC pcp)
-
-if (FSO_BUILD_WITH_VULKAN)
-	target_link_libraries(code PUBLIC vulkan-hpp)
-endif()
-
-target_link_libraries(code PUBLIC parsers)
-
-target_link_libraries(code PUBLIC mdns)
-
-enable_clang_tidy(code)
-
-IF (FSO_USE_SPEECH)
-	find_package(Speech REQUIRED)
-	target_link_libraries(code PUBLIC speech)
-ENDIF(FSO_USE_SPEECH)
-
-TARGET_LINK_LIBRARIES(code PUBLIC jansson)
-
-target_link_libraries(code PUBLIC variant)
-
-# Headers for standalone "gui" on UNIX
-IF(UNIX)
-	TARGET_LINK_LIBRARIES(code PUBLIC ${MONGOOSE_LIBS})
-ENDIF(UNIX)
-
-IF(FSO_BUILD_TOOLS)
-	ADD_SUBDIRECTORY(cfilearchiver)
-
-	ADD_SUBDIRECTORY(cfileextractor)
-ENDIF(FSO_BUILD_TOOLS)
-
-if (FSO_RELEASE_LOGGING)
-	target_compile_definitions(code PUBLIC SCP_RELEASE_LOGGING)
-endif()
-
-if (FSO_BUILD_WITH_FFMPEG)
-	target_compile_definitions(code PUBLIC WITH_FFMPEG)
-endif()
-if (FSO_BUILD_WITH_OPENGL)
-	target_compile_definitions(code PUBLIC WITH_OPENGL)
-endif()
-if (FSO_BUILD_WITH_VULKAN)
-	target_compile_definitions(code PUBLIC WITH_VULKAN)
-endif()
-
-include(shaders.cmake)
-
-target_embed_files(code FILES ${default_files_files} RELATIVE_TO "def_files")
-
-handle_embedded_files(code)
-
-set_precompiled_header(code "${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h")
-
-# Ensure that Xcode generates debug symbols on macOS for Debug builds
-set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS[variant=Debug] "YES")
-set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_COPY_PHASE_STRIP[variant=Debug] "NO")
-set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_STRIP_INSTALLED_PRODUCT[variant=Debug] "NO")
-set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN[variant=Debug] "NO")

code/actions/Action.cpp

@@ -1,8 +0,0 @@
-
-#include "Action.h"
-
-namespace actions {
-
-Action::~Action() = default;
-
-}

code/actions/Action.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "common.h"
-
-namespace actions {
-
-enum class ActionResult
-{
-	Finished,
-	Errored,
-	Wait
-};
-
-class Action {
-  public:
-	virtual ~Action() = 0;
-
-	virtual ActionResult execute(ProgramLocals& locals) const = 0;
-
-	virtual std::unique_ptr<Action> clone() const = 0;
-};
-
-} // namespace actions

code/actions/ActionDefinition.cpp

@@ -1,20 +0,0 @@
-
-#include "ActionDefinition.h"
-
-namespace actions {
-
-ActionDefinition::ActionDefinition(SCP_string name, SCP_vector<ActionParameter> parameters)
-	: m_name(std::move(name)), m_parameters(std::move(parameters))
-{
-}
-
-const SCP_string& ActionDefinition::getName() const
-{
-	return m_name;
-}
-const SCP_vector<ActionParameter>& ActionDefinition::getParameters() const
-{
-	return m_parameters;
-}
-
-} // namespace actions

code/actions/ActionDefinition.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include "Action.h"
-
-#include "actions/expression/ActionExpression.h"
-#include "actions/expression/Value.h"
-
-namespace actions {
-
-struct ActionParameter {
-	SCP_string name;
-	expression::ValueType type;
-};
-
-class ActionDefinition {
-  public:
-	ActionDefinition(SCP_string name, SCP_vector<ActionParameter> parameters);
-
-	const SCP_string& getName() const;
-	const SCP_vector<actions::ActionParameter>& getParameters() const;
-
-	virtual flagset<ProgramContextFlags> getRequiredContext() const = 0;
-
-	virtual std::unique_ptr<Action> createAction(
-		const SCP_unordered_map<SCP_string, expression::ActionExpression>& parameterExpressions) const = 0;
-
-  private:
-	SCP_string m_name;
-	SCP_vector<ActionParameter> m_parameters;
-};
-
-} // namespace actions

code/actions/ActionDefinitionManager.cpp

@@ -1,148 +0,0 @@
-
-#include "ActionDefinitionManager.h"
-
-#include "BuiltinActionDefinition.h"
-
-#include "actions/types/MoveToSubmodel.h"
-#include "actions/types/ParticleEffectAction.h"
-#include "actions/types/PlaySoundAction.h"
-#include "actions/types/SetDirectionAction.h"
-#include "actions/types/SetPositionAction.h"
-#include "actions/types/WaitAction.h"
-#include "utils/join_string.h"
-
-namespace actions {
-namespace {
-
-void parseActionParameters(const SCP_vector<ActionParameter>& params,
-	SCP_unordered_map<SCP_string, expression::ActionExpression>& parameterExpressions,
-	const expression::ParseContext& context)
-{
-	// We do not impose a set order of the parameters so we need to do something similar to the outer loop and
-	// check for every possibility in a loop.
-	for (size_t i = 0; i < params.size(); ++i) {
-		// We might be doing some empty loops here in case of errors but there is a bound so this will finish
-		// eventually
-		for (const auto& parameter : params) {
-			// Do not check for parameters which we already found
-			if (parameterExpressions.find(parameter.name) != parameterExpressions.end()) {
-				continue;
-			}
-
-			const auto paramString = "+" + parameter.name + ":";
-
-			if (!optional_string(paramString.c_str())) {
-				continue;
-			}
-
-			// We found our parameter!
-			parameterExpressions[parameter.name] =
-				expression::ActionExpression::parseFromTable(parameter.type, context);
-			break;
-		}
-	}
-}
-
-} // namespace
-
-const ActionDefinitionManager& ActionDefinitionManager::instance()
-{
-	static const ActionDefinitionManager manager = []() {
-		ActionDefinitionManager newManager;
-
-		newManager.addDefinition(
-			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::MoveToSubmodel>("Move To Subobject")));
-		newManager.addDefinition(std::unique_ptr<ActionDefinition>(
-			new BuiltinActionDefinition<types::ParticleEffectAction>("Start Particle Effect")));
-		newManager.addDefinition(
-			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::PlaySoundAction>("Play 3D Sound")));
-		newManager.addDefinition(
-			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetDirectionAction>("Set Direction")));
-		newManager.addDefinition(
-			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetPositionAction>("Set Position")));
-		newManager.addDefinition(
-			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::WaitAction>("Wait")));
-
-		return newManager;
-	}();
-	return manager;
-}
-void ActionDefinitionManager::addDefinition(std::unique_ptr<ActionDefinition> def)
-{
-	m_definitions.push_back(std::move(def));
-}
-std::unique_ptr<Action> ActionDefinitionManager::parseAction(const flagset<ProgramContextFlags>& context_flags,
-	const expression::ParseContext& context) const
-{
-	// We search through all definitions for every time we want to check for an action. This is not the most efficient
-	// way to handle this since it results in an O(n^2) runtime. A better alternative would be to either construct a
-	// regex with all the accepted actions as alternatives (although runtime of this is also doubtful) or peek at the
-	// next token, extract the relevant part (The stuff between "+" and ":") and then look that up in a map. Then we
-	// would get down to O(n).
-	// Since this only happens at parse time, this is good enough for now.
-	for (const auto& actionDef : m_definitions) {
-		const auto parseString = "+" + actionDef->getName() + ":";
-
-		if (!optional_string(parseString.c_str())) {
-			continue;
-		}
-
-		SCP_unordered_map<SCP_string, expression::ActionExpression> parameterExpressions;
-		const auto& params = actionDef->getParameters();
-
-		if (params.size() == 1) {
-			// Single parameters are expected to be placed directly after the action name
-			parameterExpressions[params.front().name] =
-				expression::ActionExpression::parseFromTable(params.front().type, context);
-		} else {
-			parseActionParameters(params, parameterExpressions, context);
-
-			if (parameterExpressions.size() != params.size()) {
-				SCP_vector<ActionParameter> missingParameters;
-				std::copy_if(params.cbegin(),
-					params.cend(),
-					std::back_inserter(missingParameters),
-					[&parameterExpressions](const ActionParameter& param) {
-						const auto iter = parameterExpressions.find(param.name);
-						return iter == parameterExpressions.cend();
-					});
-
-				SCP_vector<SCP_string> missingParameterNames;
-				std::transform(missingParameters.cbegin(),
-					missingParameters.cend(),
-					std::back_inserter(missingParameterNames),
-					[](const ActionParameter& param) { return "+" + param.name; });
-
-				const auto namesList = util::join_container(missingParameterNames, ", ");
-
-				error_display(0, "Missing parameters for action '%s': %s", parseString.c_str(), namesList.c_str());
-
-				// Fix up the parameter list so that we can continue parsing
-				for (const auto& missingParam : missingParameters) {
-					parameterExpressions[missingParam.name] = expression::ActionExpression();
-				}
-			}
-		}
-
-		auto actionInstance = actionDef->createAction(parameterExpressions);
-
-		const auto requiredFlags = actionDef->getRequiredContext();
-
-		if ((context_flags & requiredFlags) != requiredFlags) {
-			// We are missing at least one context flag so this action is not valid here. We still return the action
-			// here though since that is the only way we can keep parsing the table without throwing random error
-			// messages at the user. However, this will trigger an Assertion (in debug) or crashes when the action is
-			// actually run later.
-			error_display(0,
-				"The action %s is not available in the current context. This will lead to an Assertion failure when "
-				"this action is triggered.",
-				parseString.c_str());
-		}
-
-		return actionInstance;
-	}
-
-	return std::unique_ptr<Action>();
-}
-
-} // namespace actions

code/actions/ActionDefinitionManager.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include "ActionDefinition.h"
-
-namespace actions {
-
-class ActionDefinitionManager {
-  public:
-	// This type is supposed to be global so it may not be copied
-	ActionDefinitionManager(const ActionDefinitionManager&) = delete;
-	ActionDefinitionManager& operator=(const ActionDefinitionManager&) = delete;
-
-	ActionDefinitionManager(ActionDefinitionManager&&) noexcept = default;
-	ActionDefinitionManager& operator=(ActionDefinitionManager&&) noexcept = default;
-
-	std::unique_ptr<Action> parseAction(const flagset<ProgramContextFlags>& context_flags,
-		const expression::ParseContext& context) const;
-
-	static const ActionDefinitionManager& instance();
-
-  private:
-	ActionDefinitionManager() = default;
-
-	void addDefinition(std::unique_ptr<ActionDefinition> def);
-
-	SCP_vector<std::unique_ptr<ActionDefinition>> m_definitions;
-};
-
-} // namespace actions

code/actions/BuiltinActionDefinition.cpp

@@ -1,2 +0,0 @@
-
-#include "BuiltinActionDefinition.h"

code/actions/BuiltinActionDefinition.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "ActionDefinition.h"
-
-#include "expression/Value.h"
-
-namespace actions {
-
-template <typename TAction>
-class BuiltinActionDefinition : public ActionDefinition {
-	using ActionValueType = typename TAction::ValueType;
-
-  public:
-	BuiltinActionDefinition(SCP_string name)
-		: ActionDefinition(std::move(name), {{"parameter", expression::ValueTypeTraits<ActionValueType>::type}})
-	{
-	}
-
-	flagset<ProgramContextFlags> getRequiredContext() const override
-	{
-		return flagset<ProgramContextFlags>(TAction::getRequiredExecutionContextFlags());
-	}
-
-	std::unique_ptr<Action> createAction(
-		const SCP_unordered_map<SCP_string, expression::ActionExpression>& parameterExpressions) const override
-	{
-		const auto paramIter = parameterExpressions.find("parameter");
-
-		// This should have been caught earlier
-		Assertion(paramIter != parameterExpressions.cend(), "Could not find built-in parameter!");
-
-		return std::unique_ptr<Action>(new TAction(paramIter->second.template asTyped<ActionValueType>()));
-	}
-};
-
-} // namespace actions

code/actions/Program.cpp

@@ -1,174 +0,0 @@
-
-#include "Program.h"
-
-#include "Action.h"
-
-#include "actions/ActionDefinitionManager.h"
-#include "executor/global_executors.h"
-#include "tracing/Monitor.h"
-#include "tracing/categories.h"
-#include "tracing/tracing.h"
-
-namespace {
-using namespace actions;
-
-tracing::Monitor<int> RunningProgramsMonitor("RunningPrograms", 0);
-
-struct ProgramRunner {
-	tracing::RunningCounter runningCounter{RunningProgramsMonitor};
-
-	ProgramInstance instance;
-
-	explicit ProgramRunner(const ProgramInstance& _instance) : instance(_instance) {}
-
-	executor::Executor::CallbackResult operator()()
-	{
-		TRACE_SCOPE(tracing::ProgramStepOne);
-
-		auto res = instance.step();
-
-		switch (res) {
-		case ProgramState::Running:
-			// If the program is still running then we need to reschedule our execution
-			return executor::Executor::CallbackResult::Reschedule;
-		case ProgramState::Done:
-		case ProgramState::Errored:
-		default:
-			return executor::Executor::CallbackResult::Done;
-		}
-	}
-};
-
-} // namespace
-
-namespace actions {
-
-ProgramInstance::ProgramInstance(const actions::Program* program) : _program(program) {}
-
-ProgramState ProgramInstance::step()
-{
-	if (!_locals.host.IsValid()) {
-		return ProgramState::Done;
-	}
-
-	auto& actions = _program->getActions();
-
-	for (; _currentInstruction < actions.size(); ++_currentInstruction) {
-		auto& action = actions[_currentInstruction];
-
-		auto result = action->execute(_locals);
-
-		if (result == ActionResult::Errored) {
-			return ProgramState::Errored;
-		}
-
-		if (result == ActionResult::Wait) {
-			// Action is not done yet, call again next frame
-			return ProgramState::Running;
-		}
-
-		// Action finished, run next action in program
-	}
-
-	// End of program reached, we are done now
-	return ProgramState::Done;
-}
-ProgramLocals& ProgramInstance::locals()
-{
-	return _locals;
-}
-const ProgramLocals& ProgramInstance::locals() const
-{
-	return _locals;
-}
-
-const SCP_vector<std::unique_ptr<actions::Action>>& Program::getActions() const
-{
-	return _actions;
-}
-
-Program::Program() = default;
-
-ProgramInstance Program::newInstance() const
-{
-	return ProgramInstance(this);
-}
-
-void Program::parseActions(const flagset<ProgramContextFlags>& context_flags, const expression::ParseContext& context)
-{
-	while (true) {
-		auto action = ActionDefinitionManager::instance().parseAction(context_flags, context);
-
-		if (!action) {
-			break;
-		}
-
-		_actions.push_back(std::move(action));
-	}
-}
-
-Program::Program(const Program& other) { *this = other; }
-Program& Program::operator=(const Program& other)
-{
-	_actions.clear();
-	_actions.reserve(other._actions.size());
-
-	for (auto& action : other._actions) {
-		_actions.emplace_back(action->clone());
-	}
-
-	return *this;
-}
-
-Program& Program::operator=(Program&&) noexcept = default;
-Program::Program(Program&&) noexcept = default;
-
-const SCP_vector<actions::Program>& ProgramSet::getPrograms() const
-{
-	return _programs;
-}
-
-ProgramSet::ProgramSet() = default;
-
-ProgramSet::ProgramSet(const flagset<ProgramContextFlags>& context_flags) : _contextFlags(context_flags) {}
-
-void ProgramSet::start(object* objp, const vec3d* local_pos, const matrix* local_orient, int submodel) const
-{
-	if (_contextFlags[ProgramContextFlags::HasObject]) {
-		Assertion(objp != nullptr, "Invalid object pointer supplied.");
-	}
-	if (_contextFlags[ProgramContextFlags::HasSubobject]) {
-		Assertion(submodel >= 0, "Invalid subobject supplied.");
-	}
-
-	for (const auto& prog : _programs) {
-		auto instance = prog.newInstance();
-
-		instance.locals().host = object_h(objp);
-		instance.locals().localPosition = *local_pos;
-		instance.locals().localOrient = *local_orient;
-		instance.locals().hostSubobject = submodel;
-		instance.locals().variables = getDefaultTableVariables();
-
-		// Just use the executor system to take care of running this program
-		executor::OnSimulationExecutor->post(ProgramRunner(instance));
-	}
-}
-
-ProgramSet ProgramSet::parseProgramSet(const char* tag, const flagset<ProgramContextFlags>& context_flags)
-{
-	ProgramSet set(context_flags);
-
-	const auto parseContext = getTableParseContext();
-
-	while (optional_string(tag)) {
-		Program p;
-		p.parseActions(context_flags, parseContext);
-
-		set._programs.push_back(std::move(p));
-	}
-
-	return set;
-}
-
-} // namespace actions

code/actions/Program.h

@@ -1,112 +0,0 @@
-#pragma once
-
-#include "globalincs/pstypes.h"
-
-#include "Action.h"
-#include "common.h"
-
-namespace actions {
-
-class Program;
-class ProgramSet;
-
-enum class ProgramState
-{
-	Running,
-	Done,
-	Errored
-};
-
-/**
- * @brief An instance of a program execution
- *
- * A program instance contains all information related to a single execution of a program. A program instance is
- * independent from other instances. Local variables used by actions are stored in a specific structure which can be
- * used by actions to keep track of state in this specific instance.
- */
-class ProgramInstance {
-	size_t _currentInstruction = 0;
-	ProgramLocals _locals;
-	const Program* _program = nullptr;
-
-  public:
-	explicit ProgramInstance(const Program* program);
-
-	ProgramState step();
-
-	ProgramLocals& locals();
-	const ProgramLocals& locals() const;
-};
-
-/**
- * @brief A program specified in a table
- *
- * A program is a sequential collection of Actions which are executed in sequence.
- */
-class Program {
-	SCP_vector<std::unique_ptr<Action>> _actions;
-
-  public:
-	Program();
-
-	Program(const Program& other);
-	Program& operator=(const Program& other);
-
-	Program(Program&& other) noexcept;
-	Program& operator=(Program&& other) noexcept;
-
-	const SCP_vector<std::unique_ptr<actions::Action>>& getActions() const;
-
-	/**
-	 * @brief Creates a new program instance from this program
-	 *
-	 * The program instance is initialized to its initial values.
-	 *
-	 * @return The new program instance
-	 */
-	ProgramInstance newInstance() const;
-
-	void parseActions(const flagset<ProgramContextFlags>& context_flags, const expression::ParseContext& context);
-};
-
-/**
- * @brief A set of parsed programs
- *
- * Programs are parsed in sets of zero or more programs to make it possible for the content creator to split up
- * programs.
- */
-class ProgramSet {
-	flagset<ProgramContextFlags> _contextFlags;
-
-	SCP_vector<Program> _programs;
-
-  public:
-	ProgramSet();
-	explicit ProgramSet(const flagset<ProgramContextFlags>& context_flags);
-
-	const SCP_vector<actions::Program>& getPrograms() const;
-
-	/**
-	 * @brief Starts the execution of all programs within this set with the specified parameters
-	 * @param objp The object on which this program is executed
-	 * @param local_pos The local position relative to the object or the subsystem if specified
-	 * @param local_orien The local orientation relative to the object or the subsystem if specified
-	 * @param submodel The submodel of the model to which this program is attached to.
-	 */
-	void start(object* objp, const vec3d* local_pos, const matrix* local_orient, int submodel = -1) const;
-
-	/**
-	 * @brief Parses a program set of zero or more programs
-	 *
-	 * The tag is entirely optional and if it doesn't appear in the current table then an empty set will be returned
-	 * which does nothing if started.
-	 *
-	 * @param tag The tag which is required before a program can be specified
-	 * @param context_flags A set of flags which specify in which environment the program will be used. This is used
-	 * mainly for validating the used actions.
-	 * @return The parsed program set.
-	 */
-	static ProgramSet parseProgramSet(const char* tag, const flagset<ProgramContextFlags>& context_flags = {});
-};
-
-} // namespace actions

code/actions/common.cpp

@@ -1,27 +0,0 @@
-
-#include "common.h"
-
-namespace actions {
-
-expression::ParseContext getTableParseContext()
-{
-	expression::ParseContext ctx;
-
-	auto& locals = ctx.variables.addScope("locals");
-
-	locals.addMember("position", expression::ValueType::Vector);
-	locals.addMember("direction", expression::ValueType::Vector);
-
-	return ctx;
-}
-expression::ProgramVariables getDefaultTableVariables()
-{
-	expression::ProgramVariables vars;
-
-	vars.setValue({"locals", "position"}, expression::Value(vmd_zero_vector));
-	vars.setValue({"locals", "direction"}, expression::Value(vmd_zero_vector));
-
-	return vars;
-}
-
-} // namespace actions

code/actions/common.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include "globalincs/flagset.h"
-
-#include "actions/expression/ParseContext.h"
-#include "actions/expression/ProgramVariables.h"
-#include "math/vecmat.h"
-#include "object/object.h"
-
-class object;
-class ship_subsys;
-
-namespace actions {
-
-struct ProgramLocals {
-	object_h host;
-	vec3d localPosition = vmd_zero_vector;
-	matrix localOrient = vmd_identity_matrix;
-	int hostSubobject = -1;
-
-	int waitTimestamp = 0;
-
-	expression::ProgramVariables variables;
-};
-
-/**
- * @brief A list of flags for altering the program parsing behavior
- *
- * This should be used for differentiating between different program environments when validating the program (e.g. a
- * particle effect requires an object host).
- */
-// clang-format off
-FLAG_LIST(ProgramContextFlags) {
-	HasObject = 0, //!< The program will be started with an object host
-	HasSubobject,  //!< The program will be started with a subobject host
-
-	NUM_VALUES
-};
-// clang-format on
-
-/**
- * @brief Constructs the "table" parse context
- *
- * This is the context that is available when parsing a program from an external table (e.g. ships or weapons).
- *
- * @return The parse context
- */
-expression::ParseContext getTableParseContext();
-
-/**
- * @brief Gets a program variables instance initialized with the default values
- *
- * The values are consistent with what is required for the default table parse context;
- *
- * @return The program variables
- */
-expression::ProgramVariables getDefaultTableVariables();
-
-} // namespace actions

code/actions/expression/ActionExpression.cpp

@@ -1,66 +0,0 @@
-
-#include "ActionExpression.h"
-
-#include "ExpressionParser.h"
-#include "TypeDefinition.h"
-
-#include "actions/expression/nodes/AbstractExpression.h"
-
-namespace actions {
-namespace expression {
-namespace {
-
-SCP_string getTypeName(ValueType type)
-{
-	const auto& typeDef = TypeDefinition::forValueType(type);
-	return typeDef.getName();
-}
-
-} // namespace
-
-ActionExpression ActionExpression::parseFromTable(ValueType expectedReturnType, const ParseContext& context)
-{
-	SCP_string expressionText;
-
-	stuff_string(expressionText, F_NAME);
-
-	ExpressionParser parser(expressionText);
-
-	auto expression = parser.parse(context);
-
-	if (!expression) {
-		error_display(0, "Failed to parse action expression:\n%s", parser.getErrorText().c_str());
-		return ActionExpression();
-	}
-
-	auto type = expression->getExpressionType();
-
-	// Check if the type this evaluates to matches what we expect
-	if (!checkTypeWithImplicitConversion(type, expectedReturnType)) {
-		error_display(0,
-			"Expression evaluates to type <%s> but <%s> was expected!",
-			getTypeName(type).c_str(),
-			getTypeName(expectedReturnType).c_str());
-		return ActionExpression();
-	}
-
-	// Everything is valid
-	return ActionExpression(expression);
-}
-
-Value ActionExpression::execute(const ProgramVariables& variables) const
-{
-	// Do not crash on invalid expressions
-	if (!isValid()) {
-		return Value();
-	}
-
-	return m_expression->execute(variables);
-}
-bool ActionExpression::isValid() const
-{
-	return m_expression != nullptr;
-}
-
-} // namespace expression
-} // namespace actions

code/actions/expression/ActionExpression.h

@@ -1,70 +0,0 @@
-#pragma once
-
-#include "ParseContext.h"
-#include "ProgramVariables.h"
-#include "TypeDefinition.h"
-
-#include "parse/parselo.h"
-
-namespace actions {
-namespace expression {
-namespace nodes {
-class AbstractExpression;
-}
-template <typename T>
-class TypedActionExpression;
-
-class ActionExpression {
-  public:
-	ActionExpression() = default;
-
-	Value execute(const ProgramVariables& variables) const;
-
-	bool isValid() const;
-
-	template <typename T>
-	TypedActionExpression<T> asTyped() const;
-
-	static ActionExpression parseFromTable(ValueType expectedReturnType, const ParseContext& context);
-
-  protected:
-	explicit ActionExpression(std::shared_ptr<nodes::AbstractExpression> expression)
-		: m_expression(std::move(expression))
-	{
-	}
-
-	std::shared_ptr<nodes::AbstractExpression> m_expression;
-};
-
-template <typename T>
-class TypedActionExpression {
-  public:
-	explicit TypedActionExpression(ActionExpression expression) : m_expression(std::move(expression)) {}
-
-	T execute(const ProgramVariables& variables) const
-	{
-		// Do not crash on invalid expressions
-		if (!m_expression.isValid()) {
-			return T();
-		}
-
-		return m_expression.execute(variables).template get<T>();
-	}
-
-	static TypedActionExpression<T> parseFromTable(const ParseContext& context)
-	{
-		return ActionExpression::parseFromTable(ValueTypeTraits<T>::type, context).template asTyped<T>();
-	}
-
-  private:
-	ActionExpression m_expression;
-};
-
-template <typename T>
-TypedActionExpression<T> ActionExpression::asTyped() const
-{
-	return TypedActionExpression<T>(*this);
-}
-
-} // namespace expression
-} // namespace actions

code/actions/expression/ExpressionParser.cpp

@@ -1,194 +0,0 @@
-
-#include "ExpressionParser.h"
-
-#include "actions/expression/nodes/FunctionCallExpression.h"
-#include "actions/expression/nodes/LiteralExpression.h"
-#include "actions/expression/nodes/RandomRangeExpression.h"
-#include "actions/expression/nodes/VariableReferenceExpression.h"
-#include "actions/expression/nodes/VectorConstructorExpression.h"
-#include "libs/antlr/ErrorListener.h"
-
-PUSH_SUPPRESS_WARNINGS
-#include "action_expression/generated/ActionExpressionLexer.h"
-#include "action_expression/generated/ActionExpressionParser.h"
-#include "action_expression/generated/ActionExpressionVisitor.h"
-POP_SUPPRESS_WARNINGS
-
-namespace actions {
-namespace expression {
-
-namespace {
-
-class ExpressionBuilderVisitor : public ActionExpressionVisitor {
-  public:
-	antlrcpp::Any visitExpression_main(ActionExpressionParser::Expression_mainContext* context) override
-	{
-		return visit(context->expression());
-	}
-	antlrcpp::Any visitExpression(ActionExpressionParser::ExpressionContext* context) override
-	{
-		if (context->value_expression() != nullptr) {
-			return visit(context->value_expression());
-		}
-		if (context->parenthesis_expression()) {
-			return visit(context->parenthesis_expression());
-		}
-		if (context->random_range_expression()) {
-			return visit(context->random_range_expression());
-		}
-		if (context->variable_reference_expression()) {
-			return visit(context->variable_reference_expression());
-		}
-
-		// This is an operator so treat it as one.
-		antlr4::Token* operatorTok;
-		SCP_string operatorText;
-		if (context->PLUS() != nullptr) {
-			operatorTok = context->PLUS()->getSymbol();
-			operatorText = context->PLUS()->getText();
-		} else {
-			operatorTok = context->MINUS()->getSymbol();
-			operatorText = context->MINUS()->getText();
-		}
-
-		const auto leftExpr = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
-		const auto rightExpr = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();
-
-		auto operatorExpression = std::make_shared<nodes::FunctionCallExpression>(operatorTok,
-			true,
-			std::move(operatorText),
-			SCP_vector<std::shared_ptr<nodes::AbstractExpression>>{leftExpr, rightExpr});
-		return std::static_pointer_cast<nodes::AbstractExpression>(operatorExpression);
-	}
-	antlrcpp::Any visitVariable_reference_expression(
-		ActionExpressionParser::Variable_reference_expressionContext* context) override
-	{
-		const auto identifiers = context->IDENTIFIER();
-
-		SCP_vector<SCP_string> partNames;
-		partNames.reserve(identifiers.size());
-
-		std::transform(identifiers.begin(),
-			identifiers.end(),
-			std::back_inserter(partNames),
-			[](antlr4::tree::TerminalNode* node) { return node->getText(); });
-
-		SCP_vector<antlr4::Token*> partTokens;
-		partTokens.reserve(identifiers.size());
-
-		std::transform(identifiers.begin(),
-			identifiers.end(),
-			std::back_inserter(partTokens),
-			[](antlr4::tree::TerminalNode* node) { return node->getSymbol(); });
-
-		auto expression =
-			std::make_shared<nodes::VariableReferenceExpression>(std::move(partNames), std::move(partTokens));
-		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
-	}
-	antlrcpp::Any visitRandom_range_expression(ActionExpressionParser::Random_range_expressionContext* context) override
-	{
-		auto expression = std::make_shared<nodes::RandomRangeExpression>(context->RAND_L_PAREN()->getSymbol(),
-			visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>(),
-			visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>());
-		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
-	}
-	antlrcpp::Any visitLiteral_expression(ActionExpressionParser::Literal_expressionContext* context) override
-	{
-		std::shared_ptr<nodes::LiteralExpression> expression;
-
-		if (context->FLOAT() != nullptr) {
-			expression = std::make_shared<nodes::LiteralExpression>(context->FLOAT()->getSymbol(),
-				Value(std::stof(context->FLOAT()->getText())));
-		} else if (context->INT() != nullptr) {
-			expression = std::make_shared<nodes::LiteralExpression>(context->INT()->getSymbol(),
-				Value(std::stoi(context->INT()->getText())));
-		} else {
-			const auto idText = context->STRING()->getText();
-
-			// Cut off the first and last characters since those are the < > braces
-			expression = std::make_shared<nodes::LiteralExpression>(context->STRING()->getSymbol(),
-				Value(idText.substr(1, idText.size() - 2)));
-		}
-
-		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
-	}
-	antlrcpp::Any visitParenthesis_expression(ActionExpressionParser::Parenthesis_expressionContext* context) override
-	{
-		return visit(context->expression());
-	}
-	antlrcpp::Any visitValue_expression(ActionExpressionParser::Value_expressionContext* context) override
-	{
-		return visitChildren(context);
-	}
-	antlrcpp::Any visitVec3d_constructor(ActionExpressionParser::Vec3d_constructorContext* context) override
-	{
-		auto xExpression = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
-		auto yExpression = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();
-		auto zExpression = visit(context->expression(2)).as<std::shared_ptr<nodes::AbstractExpression>>();
-
-		auto expression = std::make_shared<nodes::VectorConstructorExpression>(context->L_PAREN()->getSymbol(),
-			xExpression,
-			yExpression,
-			zExpression);
-
-		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
-	}
-};
-
-} // namespace
-
-ExpressionParser::ExpressionParser(SCP_string expressionText) : m_expressionText(std::move(expressionText)) {}
-
-std::shared_ptr<nodes::AbstractExpression> ExpressionParser::parse(const ParseContext& context)
-{
-	antlr4::ANTLRInputStream input(m_expressionText);
-	ActionExpressionLexer lexer(&input);
-	antlr4::CommonTokenStream tokens(&lexer);
-
-	::ActionExpressionParser parser(&tokens);
-	// By default we log to stderr which we do not want
-	parser.removeErrorListeners();
-	libs::antlr::ErrorListener errListener;
-	parser.addErrorListener(&errListener);
-
-	antlr4::tree::ParseTree* tree = parser.expression_main();
-
-	std::shared_ptr<nodes::AbstractExpression> exprReturn;
-	if (errListener.diagnostics.empty()) {
-		// Only do semantic checking if syntax is valid
-		ExpressionBuilderVisitor builder;
-		exprReturn = tree->accept(&builder).as<std::shared_ptr<nodes::AbstractExpression>>();
-
-		if (!exprReturn->validate(&parser, context)) {
-			exprReturn = nullptr;
-		} else {
-			exprReturn->validationDone();
-		}
-	}
-
-	if (!errListener.diagnostics.empty()) {
-		SCP_stringstream outStream;
-		for (const auto& diag : errListener.diagnostics) {
-			SCP_string tokenUnderline;
-			if (diag.tokenLength > 1) {
-				tokenUnderline = SCP_string(diag.tokenLength - 1, '~');
-			}
-			outStream << m_expressionText << "\n"
-					  << SCP_string(diag.columnInLine, ' ') << "^" << tokenUnderline << "\n"
-					  << diag.errorMessage << "\n";
-		}
-
-		m_errorText = outStream.str();
-		return nullptr;
-	}
-
-	return exprReturn;
-}
-
-const SCP_string& ExpressionParser::getErrorText() const
-{
-	return m_errorText;
-}
-
-} // namespace expression
-} // namespace actions

code/actions/expression/ExpressionParser.h

@@ -1,27 +0,0 @@
-#pragma once
-
-#include "globalincs/pstypes.h"
-
-#include "ParseContext.h"
-
-#include "actions/expression/nodes/AbstractExpression.h"
-
-namespace actions {
-namespace expression {
-
-class ExpressionParser {
-  public:
-	ExpressionParser(SCP_string expressionText);
-
-	std::shared_ptr<nodes::AbstractExpression> parse(const ParseContext& context);
-
-	const SCP_string& getErrorText() const;
-
-  private:
-	SCP_string m_expressionText;
-
-	SCP_string m_errorText;
-};
-
-} // namespace expression
-} // namespace actions

code/actions/expression/FunctionManager.cpp

@@ -1,93 +0,0 @@
-
-#include "FunctionManager.h"
-
-#include "TypeDefinition.h"
-
-#include "math/vecmat.h"
-
-namespace actions {
-namespace expression {
-namespace {
-template <typename T>
-Value value_plus(const SCP_vector<Value>& parameters)
-{
-	return Value(parameters[0].get<T>() + parameters[1].get<T>());
-}
-template <typename T>
-Value value_minus(const SCP_vector<Value>& parameters)
-{
-	return Value(parameters[0].get<T>() - parameters[1].get<T>());
-}
-} // namespace
-
-const FunctionManager& FunctionManager::instance()
-{
-	static const FunctionManager manager = []() {
-		FunctionManager newManager;
-
-		newManager.addOperator("+", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_plus<int>);
-		newManager.addOperator("+", {ValueType::Float, ValueType::Float}, ValueType::Float, value_plus<float>);
-		newManager.addOperator("+", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_plus<vec3d>);
-
-		newManager.addOperator("-", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_minus<int>);
-		newManager.addOperator("-", {ValueType::Float, ValueType::Float}, ValueType::Float, value_minus<float>);
-		newManager.addOperator("-", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_minus<vec3d>);
-
-		return newManager;
-	}();
-	return manager;
-}
-void FunctionManager::addOperator(const SCP_string& name,
-	std::initializer_list<ValueType> parameterTypes,
-	ValueType returnType,
-	FunctionImplementation implementation)
-{
-	m_operators[name].push_back({name, parameterTypes, returnType, std::move(implementation)});
-}
-const FunctionDefinition* FunctionManager::findOperator(const SCP_string& name,
-	const SCP_vector<ValueType>& parameters) const
-{
-	const auto iter = m_operators.find(name);
-
-	if (iter == m_operators.end()) {
-		return nullptr;
-	}
-
-	// Prefer exact matches
-	for (const auto& funcDef : iter->second) {
-		if (funcDef.parameterTypes == parameters) {
-			return &funcDef;
-		}
-	}
-
-	// Now check if there are matches with implicit conversions
-	for (const auto& funcDef : iter->second) {
-		// Reject functions with different amount of elements
-		if (funcDef.parameterTypes.size() != parameters.size()) {
-			continue;
-		}
-
-		auto funcParamIter = funcDef.parameterTypes.cbegin();
-		auto actualParamIter = parameters.cbegin();
-
-		bool match = true;
-		for (; funcParamIter != funcDef.parameterTypes.cend(); ++funcParamIter, ++actualParamIter) {
-			if (!checkTypeWithImplicitConversion(*actualParamIter, *funcParamIter)) {
-				// Also doesn't match with implicit conversions
-				match = false;
-				break;
-			}
-		}
-
-		if (match) {
-			return &funcDef;
-		}
-	}
-
-	return nullptr;
-}
-
-FunctionManager::FunctionManager() = default;
-
-} // namespace expression
-} // namespace actions

code/actions/expression/FunctionManager.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "Value.h"
-
-namespace actions {
-namespace expression {
-
-using FunctionImplementation = std::function<Value(const SCP_vector<Value>& parameters)>;
-
-struct FunctionDefinition {
-	SCP_string name;
-
-	SCP_vector<ValueType> parameterTypes;
-
-	ValueType returnType;
-
-	FunctionImplementation implementation;
-};
-
-class FunctionManager {
-  public:
-	// This type is supposed to be global so it may not be copied
-	FunctionManager(const FunctionManager&) = delete;
-	FunctionManager& operator=(const FunctionManager&) = delete;
-
-	FunctionManager(FunctionManager&&) noexcept = default;
-	FunctionManager& operator=(FunctionManager&&) noexcept = default;
-
-	void addOperator(const SCP_string& name,
-		std::initializer_list<ValueType> parameterTypes,
-		ValueType returnType,
-		FunctionImplementation implementation);
-
-	const FunctionDefinition* findOperator(const SCP_string& name, const SCP_vector<ValueType>& parameterTypes) const;
-
-	static const FunctionManager& instance();
-
-  private:
-	FunctionManager();
-
-	SCP_unordered_map<SCP_string, SCP_vector<FunctionDefinition>> m_operators;
-};
-
-} // namespace expression
-} // namespace actions

code/actions/expression/ParseContext.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "ProgramVariables.h"
-
-namespace actions {
-namespace expression {
-
-struct ParseContext {
-	ProgramVariablesDefinition variables;
-};
-
-} // namespace expression
-} // namespace actions