Fix some save file corruption (type 0 objects) caused by children of deleted objects not getting properly deleted.

Career: Save the rest of the level as well as just the spaceship. Also put all career save files in __career__ folder.
1000 seems very low
2023-11-20 11:52:37 +01:00 · 2023-11-18 19:45:52 +01:00 · 2023-11-18 19:45:06 +01:00 · 2023-11-18 19:06:52 +01:00 · 2023-11-18 14:53:58 +01:00 · 2023-11-18 14:11:52 +01:00
840 changed files with 35105 additions and 61184 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -0,0 +1,211 @@
+name: Build
+
+on: [push, pull_request]
+
+jobs:
+  build-linux:
+    runs-on: ${{ matrix.host_os }}
+    container: ${{ matrix.container }}
+    strategy:
+      matrix:
+        target_os: [linux]
+        host_os: [ubuntu-20.04]
+        container: ['']
+      fail-fast: false
+    steps:
+    - name: Install Colobot dependencies
+      run: sudo apt-get update && sudo apt-get install -y --no-install-recommends build-essential cmake libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev libsndfile1-dev libvorbis-dev libogg-dev libpng-dev libglew-dev libopenal-dev libphysfs-dev gettext git po4a vorbis-tools librsvg2-bin xmlstarlet libglm-dev libmpg123-dev
+      if: matrix.container == ''
+    - uses: actions/checkout@v3
+    - name: Checkout the Google Test submodule
+      run: git submodule update --init -- lib/googletest
+    - name: Checkout the nlohmann json submodule
+      run: git submodule update --init -- lib/json
+    - name: Create build directory
+      run: cmake -E make_directory build
+    - name: Run CMake (for Linux)
+      run: cmake --preset Linux-CI
+      if: matrix.target_os == 'linux'
+    - name: Build
+      run: cmake --build --preset Linux-CI
+    - name: Install
+      run: cmake --build --preset Linux-CI --target install
+    - name: Patch library path
+      run: patchelf --set-rpath '.' install/colobot
+      if: matrix.target_os == 'linux'
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: ${{matrix.target_os}}-debug
+        path: install
+      if: matrix.host_os == 'ubuntu-20.04'
+    - name: Create AppImage
+      working-directory: build
+      run: |
+        # Download app image tool
+        wget -N https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+        chmod +x linuxdeploy-x86_64.AppImage
+        ./linuxdeploy-x86_64.AppImage --appimage-extract
+        
+        # Create AppImage
+        NO_STRIP=1 ./squashfs-root/AppRun -e colobot --output appimage --appdir colobot.AppDir -d desktop/colobot.desktop -i ../desktop/colobot.svg
+        chmod +x Colobot-x86_64.AppImage
+        
+        # Prepare folder for zip
+        mkdir -p appimage
+        cp -rp ../install/data appimage/data
+        cp -rp ../install/lang appimage/lang
+        cp -p Colobot-x86_64.AppImage appimage/colobot
+      if: matrix.target_os == 'linux'
+    - name: Upload AppImage
+      uses: actions/upload-artifact@v3
+      with:
+        name: ${{matrix.target_os}}-debug-AppImage
+        path: build/appimage
+      if: matrix.target_os == 'linux' && matrix.host_os == 'ubuntu-20.04'
+    - name: Run tests
+      # TODO: Maybe run Windows tests using wine as well?
+      working-directory: build
+      run: ./Colobot-UnitTests --gtest_output=xml:gtestresults.xml
+      if: matrix.target_os == 'linux'
+    - name: Upload test results
+      uses: actions/upload-artifact@v3
+      with:
+        name: Test results (${{ matrix.target_os }}, ${{ matrix.host_os }})
+        path: build/gtestresults.xml
+      if: matrix.target_os == 'linux'
+  build-macos:
+    runs-on: ${{ matrix.host_os }}
+    container: ${{ matrix.container }}
+    strategy:
+      matrix:
+        target_os: [macos]
+        host_os: [macos-11, macos-12]
+        container: ['']
+      fail-fast: false
+    steps:
+    - name: Install Colobot dependencies
+      run: brew install cmake sdl2 sdl2_image sdl2_ttf glew physfs flac libsndfile libvorbis vorbis-tools gettext libicns librsvg wget xmlstarlet glm
+      if: matrix.container == ''
+    - uses: actions/checkout@v3
+    - name: Checkout the Google Test submodule
+      run: git submodule update --init -- lib/googletest
+    - name: Checkout the nlohmann json submodule
+      run: git submodule update --init -- lib/json
+    - name: Create build directory
+      run: cmake -E make_directory build
+    - name: Run CMake (for Mac)
+      run: cmake --preset MacOS-CI
+      if: matrix.target_os == 'macos'
+    - name: Build
+      run: cmake --build --preset MacOS-CI
+    - name: Run tests
+      # TODO: Maybe run Windows tests using wine as well?
+      working-directory: build
+      run: ./Colobot-UnitTests --gtest_output=xml:gtestresults.xml
+      if: matrix.target_os == 'macos'
+    - name: Upload test results
+      uses: actions/upload-artifact@v3
+      with:
+        name: Test results (${{ matrix.target_os }}, ${{ matrix.host_os }})
+        path: build/gtestresults.xml
+      if: matrix.target_os == 'macos'
+  build-windows:
+    runs-on: windows-2019
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            vcpkg_triplet: 'x64-windows-static'
+          - arch: x86
+            vcpkg_triplet: 'x86-windows-static'
+    steps:
+    - uses: actions/checkout@v3
+    - name: Checkout the Google Test submodule
+      run: git submodule update --init -- lib/googletest
+    - name: Checkout the nlohmann json submodule
+      run: git submodule update --init -- lib/json
+    - name: Install Ninja
+      uses: seanmiddleditch/gha-setup-ninja@master
+    - name: Setup VS Environment
+      uses: seanmiddleditch/gha-setup-vsdevenv@master
+      with:
+        arch: ${{ matrix.arch }}
+    - name: Install Colobot dependencies
+      uses: lukka/run-vcpkg@v7
+      with:
+        setupOnly: true
+        vcpkgGitCommitId: 'f6a5d4e8eb7476b8d7fc12a56dff300c1c986131'
+        vcpkgTriplet: ${{ matrix.vcpkg_triplet }}
+        # SHA-256 hash of the vcpkg.json file, recalculated automatically when it changes
+        appendedCacheKey: ${{ hashFiles( '**/vcpkg.json' ) }}
+        additionalCachedPaths: ${{ github.workspace }}/build/vcpkg_installed
+    - name: Install external tools
+      working-directory: ${{ github.workspace }}
+      run: |
+        echo "Downloading gettext..."
+        (New-Object System.Net.WebClient).DownloadFile("https://github.com/mlocati/gettext-iconv-windows/releases/download/v0.20.2-v1.16/gettext0.20.2-iconv1.16-static-64.zip", "gettext.zip");
+        echo "Unpacking gettext..."
+        7z x -ogettext gettext.zip;
+        echo "Adding gettext to PATH..."
+        echo "${{ github.workspace }}\gettext\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo "Downloading xmlstarlet..."
+        (New-Object System.Net.WebClient).DownloadFile("https://downloads.sourceforge.net/project/xmlstar/xmlstarlet/1.6.1/xmlstarlet-1.6.1-win32.zip", "xmlstarlet.zip");
+        echo "Unpacking xmlstarlet..."
+        7z x -oxmlstarlet xmlstarlet.zip;
+        echo "Renaming xml.exe to xmlstarlet.exe"
+        Rename-Item -Path "${{ github.workspace }}\xmlstarlet\xmlstarlet-1.6.1\xml.exe" -NewName "xmlstarlet.exe"
+        echo "Adding xmlstarlet to PATH..."
+        echo "${{ github.workspace }}\xmlstarlet\xmlstarlet-1.6.1" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo "Downloading rsvg-convert..."
+        (New-Object System.Net.WebClient).DownloadFile("https://downloads.sourceforge.net/project/tumagcc/rsvg-convert-2.40.20.7z", "rsvg-convert.zip");
+        echo "Unpacking xmlstarlet..."
+        7z x -orsvg-convert rsvg-convert.zip;
+        echo "Adding rsvg-convert to PATH..."
+        echo "${{ github.workspace }}\rsvg-convert" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+      shell: pwsh
+    - name: Create build directory
+      run: cmake -E make_directory build
+    - name: Run CMake (for Windows)
+      run: cmake --preset Windows-CI -DVCPKG_TARGET_TRIPLET=${{ matrix.vcpkg_triplet }} -DCMAKE_TOOLCHAIN_FILE=${{ env.VCPKG_ROOT }}\scripts\buildsystems\vcpkg.cmake
+    - name: Build
+      run: |
+        $nproc = (Get-CIMInstance -Class 'CIM_Processor').NumberOfLogicalProcessors
+        cmake --build --preset Windows-CI -j $nproc
+      shell: pwsh
+    - name: Install
+      run: cmake --build --preset Windows-CI --target install
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: windows-msvc-debug-${{ matrix.arch }}
+        path: install
+    - name: Run tests
+      working-directory: build
+      run: ./Colobot-UnitTests --gtest_output=xml:gtestresults.xml
+    - name: Upload test results
+      uses: actions/upload-artifact@v3
+      with:
+        name: 'Test results (windows, MSVC, ${{ matrix.arch }})'
+        path: build/gtestresults.xml
+  doc:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Install Colobot dependencies
+      run: sudo apt-get update && sudo apt-get install -y --no-install-recommends build-essential cmake libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev libsndfile1-dev libvorbis-dev libogg-dev libpng-dev libglew-dev libopenal-dev libphysfs-dev gettext git po4a vorbis-tools librsvg2-bin xmlstarlet doxygen graphviz libglm-dev libmpg123-dev
+    - uses: actions/checkout@v3
+    - name: Create build directory
+      run: cmake -E make_directory build
+    - name: Checkout the nlohmann json submodule
+      run: git submodule update --init -- lib/json
+    - name: Run CMake
+      working-directory: build
+      run: cmake ..
+    - name: Build docs
+      working-directory: build
+      run: make doc
+    - name: Upload docs
+      uses: actions/upload-artifact@v3
+      with:
+        name: doc
+        path: build/doc
--- a/.github/workflows/verify-pr-target.yml
+++ b/.github/workflows/verify-pr-target.yml
@ -0,0 +1,21 @@
+name: Verify pull request target
+
+on: [pull_request_target]
+
+jobs:
+  check_pr_target:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Send comment if wrong pull request target
+      if: github.base_ref == 'master'
+      uses: peter-evans/create-or-update-comment@v1
+      with:
+        issue-number: ${{ github.event.number }}
+        body: |
+          Hey! This pull request targets the `master` branch. You should probably target `dev` instead. Make sure to read the [contributing guidelines](https://github.com/colobot/colobot/blob/master/CONTRIBUTING.md#submitting-pull-requests) and [edit the target branch if necessary](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/changing-the-base-branch-of-a-pull-request).
+    - name: Wrong pull request target
+      if: github.base_ref == 'master'
+      run: echo "This pull request targets the master branch. Please edit the pull request to target dev." && exit 1
+    - name: Correct pull request target
+      if: github.base_ref != 'master'
+      run: echo "This pull request targets the correct branch." && exit 0
--- a/.gitignore
+++ b/.gitignore
@ -11,11 +11,12 @@ Makefile
 /src/libcolobotbase.a

 # Ignore the generated documentation
+CMakeDoxyfile.in
+CMakeDoxygenDefaults.cmake
 /doc
 /Doxyfile

 # Ignore targets
-/colobot
 /src/CBot/libCBot.so

 # Ignore local data
@ -23,7 +24,7 @@ Makefile
 /saves

 # Standard build directory
-/build
+/build*

 # Ignore KDevelop files
 .kdev4
@ -39,6 +40,13 @@ CMakeLists.txt.user.*
 # Ignore Visual Studio Code files
 /.vscode

+# Ignore CLion files
+/.idea
+
 # Ignore Visual Studio files
 /CMakeSettings.json
 /.vs
+/out
+
+# Ignore CMakeUserPresets.json
+CMakeUserPresets.json
--- a/.gitmodules
+++ b/.gitmodules
@ -1,3 +1,12 @@
 [submodule "data"]
 	path = data
-	url = git://github.com/colobot/colobot-data.git
+	url = https://github.com/colobot/colobot-data.git
+	branch = .
+	update = rebase
+[submodule "lib/googletest"]
+	path = lib/googletest
+	url = https://github.com/google/googletest.git
+	ignore = all
+[submodule "lib/json"]
+	path = lib/json
+	url = https://github.com/nlohmann/json
--- a/CBot/CMakeLists.txt
+++ b/CBot/CMakeLists.txt
@ -0,0 +1,175 @@
+if(CBOT_STATIC)
+    add_library(CBot STATIC)
+else()
+    add_library(CBot SHARED)
+    install(TARGETS CBot
+            LIBRARY DESTINATION ${COLOBOT_INSTALL_LIB_DIR}
+            ARCHIVE DESTINATION ${COLOBOT_INSTALL_LIB_DIR}
+            RUNTIME DESTINATION ${COLOBOT_INSTALL_BIN_DIR})
+endif()
+
+target_sources(CBot PRIVATE
+    src/CBot/CBot.h
+    src/CBot/CBotCStack.cpp
+    src/CBot/CBotCStack.h
+    src/CBot/CBotClass.cpp
+    src/CBot/CBotClass.h
+    src/CBot/CBotDebug.cpp
+    src/CBot/CBotDebug.h
+    src/CBot/CBotDefParam.cpp
+    src/CBot/CBotDefParam.h
+    src/CBot/CBotDefines.h
+    src/CBot/CBotEnums.h
+    src/CBot/CBotExternalCall.cpp
+    src/CBot/CBotExternalCall.h
+    src/CBot/CBotFileUtils.cpp
+    src/CBot/CBotFileUtils.h
+    src/CBot/CBotInstr/CBotBlock.cpp
+    src/CBot/CBotInstr/CBotBlock.h
+    src/CBot/CBotInstr/CBotBoolExpr.cpp
+    src/CBot/CBotInstr/CBotBoolExpr.h
+    src/CBot/CBotInstr/CBotBreak.cpp
+    src/CBot/CBotInstr/CBotBreak.h
+    src/CBot/CBotInstr/CBotCase.cpp
+    src/CBot/CBotInstr/CBotCase.h
+    src/CBot/CBotInstr/CBotCatch.cpp
+    src/CBot/CBotInstr/CBotCatch.h
+    src/CBot/CBotInstr/CBotCondition.cpp
+    src/CBot/CBotInstr/CBotCondition.h
+    src/CBot/CBotInstr/CBotDefArray.cpp
+    src/CBot/CBotInstr/CBotDefArray.h
+    src/CBot/CBotInstr/CBotDefBoolean.cpp
+    src/CBot/CBotInstr/CBotDefBoolean.h
+    src/CBot/CBotInstr/CBotDefClass.cpp
+    src/CBot/CBotInstr/CBotDefClass.h
+    src/CBot/CBotInstr/CBotDefFloat.cpp
+    src/CBot/CBotInstr/CBotDefFloat.h
+    src/CBot/CBotInstr/CBotDefInt.cpp
+    src/CBot/CBotInstr/CBotDefInt.h
+    src/CBot/CBotInstr/CBotDefString.cpp
+    src/CBot/CBotInstr/CBotDefString.h
+    src/CBot/CBotInstr/CBotDo.cpp
+    src/CBot/CBotInstr/CBotDo.h
+    src/CBot/CBotInstr/CBotEmpty.cpp
+    src/CBot/CBotInstr/CBotEmpty.h
+    src/CBot/CBotInstr/CBotExprLitBool.cpp
+    src/CBot/CBotInstr/CBotExprLitBool.h
+    src/CBot/CBotInstr/CBotExprLitChar.cpp
+    src/CBot/CBotInstr/CBotExprLitChar.h
+    src/CBot/CBotInstr/CBotExprLitNan.cpp
+    src/CBot/CBotInstr/CBotExprLitNan.h
+    src/CBot/CBotInstr/CBotExprLitNull.cpp
+    src/CBot/CBotInstr/CBotExprLitNull.h
+    src/CBot/CBotInstr/CBotExprLitNum.cpp
+    src/CBot/CBotInstr/CBotExprLitNum.h
+    src/CBot/CBotInstr/CBotExprLitString.cpp
+    src/CBot/CBotInstr/CBotExprLitString.h
+    src/CBot/CBotInstr/CBotExprRetVar.cpp
+    src/CBot/CBotInstr/CBotExprRetVar.h
+    src/CBot/CBotInstr/CBotExprUnaire.cpp
+    src/CBot/CBotInstr/CBotExprUnaire.h
+    src/CBot/CBotInstr/CBotExprVar.cpp
+    src/CBot/CBotInstr/CBotExprVar.h
+    src/CBot/CBotInstr/CBotExpression.cpp
+    src/CBot/CBotInstr/CBotExpression.h
+    src/CBot/CBotInstr/CBotFieldExpr.cpp
+    src/CBot/CBotInstr/CBotFieldExpr.h
+    src/CBot/CBotInstr/CBotFor.cpp
+    src/CBot/CBotInstr/CBotFor.h
+    src/CBot/CBotInstr/CBotFunction.cpp
+    src/CBot/CBotInstr/CBotFunction.h
+    src/CBot/CBotInstr/CBotIf.cpp
+    src/CBot/CBotInstr/CBotIf.h
+    src/CBot/CBotInstr/CBotIndexExpr.cpp
+    src/CBot/CBotInstr/CBotIndexExpr.h
+    src/CBot/CBotInstr/CBotInstr.cpp
+    src/CBot/CBotInstr/CBotInstr.h
+    src/CBot/CBotInstr/CBotInstrCall.cpp
+    src/CBot/CBotInstr/CBotInstrCall.h
+    src/CBot/CBotInstr/CBotInstrMethode.cpp
+    src/CBot/CBotInstr/CBotInstrMethode.h
+    src/CBot/CBotInstr/CBotInstrUtils.cpp
+    src/CBot/CBotInstr/CBotInstrUtils.h
+    src/CBot/CBotInstr/CBotLeftExpr.cpp
+    src/CBot/CBotInstr/CBotLeftExpr.h
+    src/CBot/CBotInstr/CBotLeftExprVar.cpp
+    src/CBot/CBotInstr/CBotLeftExprVar.h
+    src/CBot/CBotInstr/CBotListArray.cpp
+    src/CBot/CBotInstr/CBotListArray.h
+    src/CBot/CBotInstr/CBotListExpression.cpp
+    src/CBot/CBotInstr/CBotListExpression.h
+    src/CBot/CBotInstr/CBotListInstr.cpp
+    src/CBot/CBotInstr/CBotListInstr.h
+    src/CBot/CBotInstr/CBotLogicExpr.cpp
+    src/CBot/CBotInstr/CBotLogicExpr.h
+    src/CBot/CBotInstr/CBotNew.cpp
+    src/CBot/CBotInstr/CBotNew.h
+    src/CBot/CBotInstr/CBotParExpr.cpp
+    src/CBot/CBotInstr/CBotParExpr.h
+    src/CBot/CBotInstr/CBotPostIncExpr.cpp
+    src/CBot/CBotInstr/CBotPostIncExpr.h
+    src/CBot/CBotInstr/CBotPreIncExpr.cpp
+    src/CBot/CBotInstr/CBotPreIncExpr.h
+    src/CBot/CBotInstr/CBotRepeat.cpp
+    src/CBot/CBotInstr/CBotRepeat.h
+    src/CBot/CBotInstr/CBotReturn.cpp
+    src/CBot/CBotInstr/CBotReturn.h
+    src/CBot/CBotInstr/CBotSwitch.cpp
+    src/CBot/CBotInstr/CBotSwitch.h
+    src/CBot/CBotInstr/CBotThrow.cpp
+    src/CBot/CBotInstr/CBotThrow.h
+    src/CBot/CBotInstr/CBotTry.cpp
+    src/CBot/CBotInstr/CBotTry.h
+    src/CBot/CBotInstr/CBotTwoOpExpr.cpp
+    src/CBot/CBotInstr/CBotTwoOpExpr.h
+    src/CBot/CBotInstr/CBotWhile.cpp
+    src/CBot/CBotInstr/CBotWhile.h
+    src/CBot/CBotProgram.cpp
+    src/CBot/CBotProgram.h
+    src/CBot/CBotStack.cpp
+    src/CBot/CBotStack.h
+    src/CBot/CBotToken.cpp
+    src/CBot/CBotToken.h
+    src/CBot/CBotTypResult.cpp
+    src/CBot/CBotTypResult.h
+    src/CBot/CBotUtils.cpp
+    src/CBot/CBotUtils.h
+    src/CBot/CBotVar/CBotVar.cpp
+    src/CBot/CBotVar/CBotVar.h
+    src/CBot/CBotVar/CBotVarValue.h
+    src/CBot/CBotVar/CBotVarArray.cpp
+    src/CBot/CBotVar/CBotVarArray.h
+    src/CBot/CBotVar/CBotVarBoolean.cpp
+    src/CBot/CBotVar/CBotVarBoolean.h
+    src/CBot/CBotVar/CBotVarByte.h
+    src/CBot/CBotVar/CBotVarChar.h
+    src/CBot/CBotVar/CBotVarClass.cpp
+    src/CBot/CBotVar/CBotVarClass.h
+    src/CBot/CBotVar/CBotVarDouble.h
+    src/CBot/CBotVar/CBotVarFloat.cpp
+    src/CBot/CBotVar/CBotVarFloat.h
+    src/CBot/CBotVar/CBotVarInt.cpp
+    src/CBot/CBotVar/CBotVarInt.h
+    src/CBot/CBotVar/CBotVarLong.h
+    src/CBot/CBotVar/CBotVarPointer.cpp
+    src/CBot/CBotVar/CBotVarPointer.h
+    src/CBot/CBotVar/CBotVarShort.h
+    src/CBot/CBotVar/CBotVarString.cpp
+    src/CBot/CBotVar/CBotVarString.h
+    src/CBot/stdlib/Compilation.cpp
+    src/CBot/stdlib/Compilation.h
+    src/CBot/stdlib/FileFunctions.cpp
+    src/CBot/stdlib/MathFunctions.cpp
+    src/CBot/stdlib/StringFunctions.cpp
+    src/CBot/stdlib/stdlib.h
+    src/CBot/stdlib/stdlib_public.h
+)
+
+target_include_directories(CBot PUBLIC src)
+target_link_libraries(CBot PRIVATE
+    Colobot-Common
+)
+
+if(COLOBOT_LINT_BUILD)
+    add_fake_header_sources("src/CBot" CBot)
+endif()
--- a/src/CBot/README.txt
+++ b/src/CBot/README.txt
@ -1,5 +1,5 @@
 /**
- * \dir src/CBot
+ * \dir CBot
 * \brief CBot library
 */

@ -7,3 +7,4 @@
 * \namespace CBot
 * \brief CBot engine
 */
+ 
--- a/CBot/src/CBot/CBot.h
+++ b/CBot/src/CBot/CBot.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotCStack.cpp
+++ b/CBot/src/CBot/CBotCStack.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -20,6 +20,7 @@

 #include "CBot/CBotCStack.h"

+#include "CBot/CBotClass.h"
 #include "CBot/CBotToken.h"
 #include "CBot/CBotExternalCall.h"

@ -30,107 +31,100 @@
 namespace CBot
 {

-////////////////////////////////////////////////////////////////////////////////
-CBotProgram* CBotCStack::m_prog    = nullptr;            // init the static variable
-CBotError CBotCStack::m_error   = CBotNoErr;
-int CBotCStack::m_end      = 0;
-CBotTypResult CBotCStack::m_retTyp  = CBotTypResult(0);
+struct CBotCStack::Data
+{
+    //! The program currently being compiled
+    CBotProgram*  prog   = nullptr;
+    //! The current error state of the compile stack
+    CBotError     error  = CBotNoErr;
+    int           errEnd = 0;
+    //! The return type of the function currently being compiled
+    CBotTypResult retTyp = CBotTypResult(CBotTypVoid);
+};

-////////////////////////////////////////////////////////////////////////////////
 CBotCStack::CBotCStack(CBotCStack* ppapa)
 {
-    m_next = nullptr;
    m_prev = ppapa;

    if (ppapa == nullptr)
    {
-        m_error = CBotNoErr;
-        m_start = 0;
-        m_end    = 0;
+        m_data = new CBotCStack::Data;
+        m_errStart = 0;
        m_bBlock = true;
    }
    else
    {
-        m_start = ppapa->m_start;
+        m_data = ppapa->m_data;
+        m_errStart = ppapa->m_errStart;
        m_bBlock = false;
    }
-
-    m_listVar = nullptr;
-    m_var      = nullptr;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotCStack::~CBotCStack()
 {
-    if (m_next != nullptr) delete m_next;
-    if (m_prev != nullptr) m_prev->m_next = nullptr;        // removes chain
-
-    delete m_var;
-    delete m_listVar;
+    if (m_prev == nullptr) delete m_data;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, bool bBlock)
 {
-    if (m_next != nullptr) return m_next;            // include on an existing stack
+    if (m_next) return m_next.get();                 // include on an existing stack

-    CBotCStack*    p = new CBotCStack(this);
-    m_next = p;                                    // channel element
-    p->m_bBlock = bBlock;
+    m_next.reset(new CBotCStack(this));
+    m_next->m_bBlock = bBlock;

-    if (pToken != nullptr) p->SetStartError(pToken->GetStart());
+    if (pToken != nullptr) m_next->SetStartError(pToken->GetStart());

-    return    p;
+    return m_next.get();
+}
+
+void CBotCStack::DeleteNext()
+{
+    m_next.reset();
 }

-////////////////////////////////////////////////////////////////////////////////
 CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils)
 {
    if ( pfils == this ) return inst;

-    if (m_var != nullptr) delete m_var;            // value replaced?
-    m_var = pfils->m_var;                        // result transmitted
-    pfils->m_var = nullptr;                        // not to destroy the variable
+    m_var = std::move(pfils->m_var);             // result transmitted

-    if (m_error)
+    if (m_data->error != CBotNoErr)
    {
-        m_start = pfils->m_start;                // retrieves the position of the error
-        m_end    = pfils->m_end;
+        m_errStart = pfils->m_errStart;          // retrieves the position of the error
    }

-    delete pfils;
+    m_next.reset();
    return inst;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotFunction* CBotCStack::ReturnFunc(CBotFunction* inst, CBotCStack* pfils)
 {
-    if (m_var != nullptr) delete m_var;            // value replaced?
-    m_var = pfils->m_var;                        // result transmitted
-    pfils->m_var = nullptr;                        // not to destroy the variable
+    m_var = std::move(pfils->m_var);             // result transmitted

-    if (m_error)
+    if (m_data->error != CBotNoErr)
    {
-        m_start = pfils->m_start;                // retrieves the position of the error
-        m_end    = pfils->m_end;
+        m_errStart = pfils->m_errStart;          // retrieves the position of the error
    }

-    delete pfils;
+    m_next.reset();
    return inst;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotError CBotCStack::GetError(int& start, int& end)
 {
-    start = m_start;
-    end      = m_end;
-    return m_error;
+    start = m_errStart;
+    end = m_data->errEnd;
+    return m_data->error;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotError CBotCStack::GetError()
 {
-    return m_error;
+    return m_data->error;
 }

 ////////////////////////////////////////////////////////////////////////////////
@ -170,18 +164,13 @@ void CBotCStack::SetType(CBotTypResult& type)
 CBotVar* CBotCStack::FindVar(CBotToken* &pToken)
 {
    CBotCStack*    p = this;
-    std::string    name = pToken->GetString();
+    const auto&    name = pToken->GetString();

    while (p != nullptr)
    {
-        CBotVar*    pp = p->m_listVar;
-        while ( pp != nullptr)
+        if (p->m_bBlock) for (auto& var : p->m_listVar)
        {
-            if (name == pp->GetName())
-            {
-                return pp;
-            }
-            pp = pp->m_next;
+            if (name == var->GetName()) return var.get();
        }
        p = p->m_prev;
    }
@ -210,39 +199,39 @@ CBotVar* CBotCStack::CopyVar(CBotToken& Token)
 ////////////////////////////////////////////////////////////////////////////////
 bool CBotCStack::IsOk()
 {
-    return (m_error == 0);
+    return (m_data->error == CBotNoErr);
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetStartError( int pos )
 {
-    if ( m_error != 0) return;            // does not change existing error
-    m_start = pos;
+    if (m_data->error != CBotNoErr) return; // does not change existing error
+    m_errStart = pos;
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetError(CBotError n, int pos)
 {
-    if ( n!= 0 && m_error != 0) return;    // does not change existing error
-    m_error = n;
-    m_end    = pos;
+    if (n != CBotNoErr && m_data->error != CBotNoErr) return; // does not change existing error
+    m_data->error = n;
+    m_data->errEnd = pos;
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetError(CBotError n, CBotToken* p)
 {
-    if (m_error) return;    // does not change existing error
-    m_error = n;
-    m_start    = p->GetStart();
-    m_end    = p->GetEnd();
+    if (m_data->error != CBotNoErr) return; // does not change existing error
+    m_data->error = n;
+    m_errStart = p->GetStart();
+    m_data->errEnd = p->GetEnd();
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::ResetError(CBotError n, int start, int end)
 {
-    m_error = n;
-    m_start    = start;
-    m_end    = end;
+    m_data->error = n;
+    m_errStart = start;
+    m_data->errEnd = end;
 }

 ////////////////////////////////////////////////////////////////////////////////
@ -260,48 +249,47 @@ bool CBotCStack::NextToken(CBotToken* &p)
 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetProgram(CBotProgram* p)
 {
-    m_prog = p;
+    m_data->prog = p;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotProgram* CBotCStack::GetProgram()
 {
-    return m_prog;
+    return m_data->prog;
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetRetType(CBotTypResult& type)
 {
-    m_retTyp = type;
+    m_data->retTyp = type;
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotTypResult CBotCStack::GetRetType()
 {
-    return m_retTyp;
+    return m_data->retTyp;
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetVar( CBotVar* var )
 {
-    if (m_var) delete m_var;    // replacement of a variable
-    m_var = var;
+    m_var.reset(var);
 }

 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetCopyVar( CBotVar* var )
 {
-    if (m_var) delete m_var;    // replacement of a variable
+    m_var.reset();

    if ( var == nullptr ) return;
-    m_var = CBotVar::Create("", var->GetTypResult(CBotVar::GetTypeMode::CLASS_AS_INTRINSIC));
+    m_var.reset(CBotVar::Create("", var->GetTypResult(CBotVar::GetTypeMode::CLASS_AS_INTRINSIC)));
    m_var->Copy( var );
 }

 ////////////////////////////////////////////////////////////////////////////////
 CBotVar* CBotCStack::GetVar()
 {
-    return m_var;
+    return m_var.get();
 }

 ////////////////////////////////////////////////////////////////////////////////
@ -309,34 +297,70 @@ void CBotCStack::AddVar(CBotVar* pVar)
 {
    CBotCStack*    p = this;

-    // returns to the father element
+    // find the level of the current block
    while (p != nullptr && p->m_bBlock == 0) p = p->m_prev;

-    if ( p == nullptr ) return;
+    if (p == nullptr || pVar == nullptr) return;

-    CBotVar**    pp = &p->m_listVar;
-    while ( *pp != nullptr ) pp = &(*pp)->m_next;
+    p->m_listVar.emplace_back(pVar);
+}

-    *pp = pVar;                    // added after
+////////////////////////////////////////////////////////////////////////////////
+void CBotCStack::CreateVarThis(CBotClass* pClass)
+{
+    if ( pClass == nullptr ) return;
+
+    CBotVar* pThis = CBotVar::Create("this", CBotTypResult(CBotTypClass, pClass));
+
+    pThis->SetUniqNum(-2); // special ID for "this"
+    AddVar(pThis);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void CBotCStack::CreateVarSuper(CBotClass* pClass)
+{
+    if ( pClass == nullptr ) return;
+
+    CBotVar* pSuper = CBotVar::Create("super", CBotTypResult(CBotTypClass, pClass));
+
+    pSuper->SetUniqNum(-3); // special ID for "super"
+    AddVar(pSuper);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void CBotCStack::CreateMemberVars(CBotClass* pClass, bool setDefined)
+{
+    while (pClass != nullptr)
+    {
+        CBotVar* pv = pClass->GetVar();
+        while (pv != nullptr)
+        {
+            CBotVar* pcopy = CBotVar::Create(pv);
+            CBotVar::InitType initType = CBotVar::InitType::UNDEF;
+            if (setDefined || pv->IsStatic())
+                initType = CBotVar::InitType::DEF;
+            pcopy->SetInit(initType);
+            pcopy->SetUniqNum(pv->GetUniqNum());
+            pcopy->SetPrivate(pv->GetPrivate());
+            AddVar(pcopy);
+            pv = pv->GetNext();
+        }
+        pClass = pClass->GetParent();
+    }
 }

 ////////////////////////////////////////////////////////////////////////////////
 bool CBotCStack::CheckVarLocal(CBotToken* &pToken)
 {
    CBotCStack*    p = this;
-    std::string    name = pToken->GetString();
+    const auto&    name = pToken->GetString();

-    while (p != nullptr)
+    // find the level of the current block
+    while (p != nullptr && p->m_bBlock == 0) p = p->m_prev;
+
+    if (p != nullptr) for (auto& var : p->m_listVar)
    {
-        CBotVar*    pp = p->m_listVar;
-        while ( pp != nullptr)
-        {
-            if (name == pp->GetName())
-                return true;
-            pp = pp->m_next;
-        }
-        if ( p->m_bBlock ) return false;
-        p = p->m_prev;
+        if (name == var->GetName()) return true;
    }
    return false;
 }
@ -347,10 +371,10 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId
    nIdent = 0;
    CBotTypResult val(-1);

-    val = m_prog->GetExternalCalls()->CompileCall(p, nullptr, ppVars, this);
+    val = GetProgram()->GetExternalCalls()->CompileCall(p, nullptr, ppVars, this);
    if (val.GetType() < 0)
    {
-        val = CBotFunction::CompileCall(m_prog->GetFunctions(), p->GetString(), ppVars, nIdent);
+        val = CBotFunction::CompileCall(p->GetString(), ppVars, nIdent, GetProgram());
        if ( val.GetType() < 0 )
        {
    //        pVar = nullptr;                    // the error is not on a particular parameter
@ -363,16 +387,19 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId
 }

 ////////////////////////////////////////////////////////////////////////////////
-bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
+bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam, const std::string& className)
 {
-    std::string    name = pToken->GetString();
+    const auto& name = pToken->GetString();

-    if ( m_prog->GetExternalCalls()->CheckCall(name) ) return true;
+    if ( GetProgram()->GetExternalCalls()->CheckCall(name) ) return true;

-    for (CBotFunction* pp : m_prog->GetFunctions())
+    for (CBotFunction* pp : GetProgram()->GetFunctions())
    {
-        if ( pToken->GetString() == pp->GetName() )
+        if ( name == pp->GetName() )
        {
+            // ignore methods for a different class
+            if ( className != pp->GetClassName() )
+                continue;
            // are parameters exactly the same?
            if ( pp->CheckParam( pParam ) )
                return true;
@ -381,8 +408,11 @@ bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)

    for (CBotFunction* pp : CBotFunction::m_publicFunctions)
    {
-        if ( pToken->GetString() == pp->GetName() )
+        if ( name == pp->GetName() )
        {
+            // ignore methods for a different class
+            if ( className != pp->GetClassName() )
+                continue;
            // are parameters exactly the same?
            if ( pp->CheckParam( pParam ) )
                return true;
@ -392,4 +422,4 @@ bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
    return false;
 }

-}
+} // namespace CBot
--- a/CBot/src/CBot/CBotCStack.h
+++ b/CBot/src/CBot/CBotCStack.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -22,6 +22,9 @@
 #include "CBot/CBotVar/CBotVar.h"
 #include "CBot/CBotProgram.h"

+#include <list>
+#include <memory>
+
 namespace CBot
 {

@ -100,6 +103,25 @@ public:
     */
    void AddVar(CBotVar* p);

+    /*!
+     * \brief Create 'this' as a local variable.
+     * \param pClass The current class referred to by 'this'
+     */
+    void CreateVarThis(CBotClass* pClass);
+
+    /*!
+     * \brief Create 'super' as a local variable.
+     * \param pClass The parent class referred to by 'super'
+     */
+    void CreateVarSuper(CBotClass* pClass);
+
+    /*!
+     * \brief Create member variables of the current class as local variables.
+     * \param pClass The current class.
+     * \param setDefined Whether to mark the variables as initialized.
+     */
+    void CreateMemberVars(CBotClass* pClass, bool setDefined);
+
    /*!
     * \brief FindVar Finds a variable. Seeks a variable on the stack the token
     * may be a result of TokenTypVar (object of a class) or a pointer in the
@ -138,6 +160,11 @@ public:
     */
    CBotCStack* TokenStack(CBotToken* pToken = nullptr, bool bBlock = false);

+    /*!
+     * \brief Deletes all subsequent stack frames created by TokenStack.
+     */
+    void DeleteNext();
+
    /*!
     * \brief Return Transmits the result upper.
     * \param p
@ -235,11 +262,12 @@ public:

    /*!
     * \brief CheckCall Test if a procedure name is already defined somewhere.
-     * \param pToken
-     * \param pParam
+     * \param pToken Token representing the name of a function.
+     * \param pParam List of parameters.
+     * \param className Name of a class when checking for methods.
     * \return
     */
-    bool CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
+    bool CheckCall(CBotToken* &pToken, CBotDefParam* pParam, const std::string& className);

    /*!
     * \brief NextToken
@ -249,21 +277,20 @@ public:
    bool NextToken(CBotToken* &p);

 private:
-    CBotCStack* m_next;
+    std::unique_ptr<CBotCStack> m_next;
    CBotCStack* m_prev;

-    static CBotError m_error;
-    static int m_end;
-    int m_start;
+    int m_errStart = 0;
+
+    struct Data;
+
+    CBotCStack::Data* m_data;

    //! Result of the operations.
-    CBotVar* m_var;
+    std::unique_ptr<CBotVar> m_var;
    //! Is part of a block (variables are local to this block).
    bool m_bBlock;
-    CBotVar* m_listVar;
-    //! List of compiled functions.
-    static CBotProgram* m_prog;
-    static CBotTypResult m_retTyp;
+    std::list<std::unique_ptr<CBotVar>> m_listVar;
 };

 } // namespace CBot
--- a/CBot/src/CBot/CBotClass.cpp
+++ b/CBot/src/CBot/CBotClass.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -315,7 +315,7 @@ CBotTypResult CBotClass::CompileMethode(CBotToken* name,

    // find the methods declared by user

-    r = CBotFunction::CompileCall(m_pMethod, name->GetString(), ppParams, nIdent);
+    r = CBotFunction::CompileMethodCall(name->GetString(), ppParams, nIdent, pStack, this);
    if ( r.Eq(CBotErrUndefCall) && m_parent != nullptr )
        return m_parent->CompileMethode(name, pThis, ppParams, pStack, nIdent);
    return r;
@ -332,7 +332,7 @@ bool CBotClass::ExecuteMethode(long& nIdent,
    int ret = m_externalMethods->DoCall(pToken, pThis, ppParams, pStack, pResultType);
    if (ret >= 0) return ret;

-    ret = CBotFunction::DoCall(m_pMethod, nIdent, pToken->GetString(), pThis, ppParams, pStack, pToken, this);
+    ret = CBotFunction::DoCall(nIdent, pToken->GetString(), pThis, ppParams, pStack, pToken, this);
    if (ret >= 0) return ret;

    if (m_parent != nullptr)
@ -355,7 +355,7 @@ void CBotClass::RestoreMethode(long& nIdent,
    CBotClass* pClass = this;
    while (pClass != nullptr)
    {
-        bool ok = CBotFunction::RestoreCall(pClass->m_pMethod, nIdent, name->GetString(), pThis, ppParams, pStack, pClass);
+        bool ok = CBotFunction::RestoreCall(nIdent, name->GetString(), pThis, ppParams, pStack, pClass);
        if (ok) return;
        pClass = pClass->m_parent;
    }
@ -542,6 +542,11 @@ void CBotClass::DefineClasses(std::list<CBotClass*> pClassList, CBotCStack* pSta
    }
 }

+const std::list<CBotFunction*>& CBotClass::GetFunctions() const
+{
+    return m_pMethod;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
 {
@ -600,8 +605,8 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
                    // return a method precompiled in pass 1
                    CBotCStack* pStk = pStack->TokenStack(nullptr, true);
                    CBotDefParam* params = CBotDefParam::Compile(p, pStk );
-                    delete pStk;
-                    std::list<CBotFunction*>::iterator pfIter = std::find_if(m_pMethod.begin(), m_pMethod.end(), [&pp, &params](CBotFunction* x)
+                    pStack->DeleteNext();
+                    auto pfIter = std::find_if(m_pMethod.begin(), m_pMethod.end(), [&pp, &params](CBotFunction* x)
                    {
                        return x->GetName() == pp && x->CheckParam( params );
                    });
@ -609,45 +614,8 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
                    CBotFunction* pf = *pfIter;
                    delete params;

-                    bool bConstructor = (pp == GetName());
                    CBotCStack* pile = pStack->TokenStack(nullptr, true);

-                    // make "this" known
-                    CBotToken TokenThis(std::string("this"), std::string());
-                    CBotVar* pThis = CBotVar::Create(TokenThis, CBotTypResult( CBotTypClass, this ) );
-                    pThis->SetUniqNum(-2);
-                    pile->AddVar(pThis);
-
-                    if (m_parent)
-                    {
-                        // makes "super" known
-                        CBotToken TokenSuper(std::string("super"), std::string());
-                        CBotVar* pThis = CBotVar::Create(TokenSuper, CBotTypResult(CBotTypClass, m_parent) );
-                        pThis->SetUniqNum(-3);
-                        pile->AddVar(pThis);
-                    }
-
-//                  int num = 1;
-                    CBotClass*  my = this;
-                    while (my != nullptr)
-                    {
-                        // places a copy of variables of a class (this) on a stack
-                        CBotVar* pv = my->m_pVar;
-                        while (pv != nullptr)
-                        {
-                            CBotVar* pcopy = CBotVar::Create(pv);
-                            CBotVar::InitType initType = CBotVar::InitType::UNDEF;
-                            if (!bConstructor || pv->IsStatic())
-                                initType = CBotVar::InitType::DEF;
-                            pcopy->SetInit(initType);
-                            pcopy->SetUniqNum(pv->GetUniqNum());
-                            pcopy->SetPrivate(pv->GetPrivate());
-                            pile->AddVar(pcopy);
-                            pv = pv->GetNext();
-                        }
-                        my = my->m_parent;
-                    }
-
                    // compiles a method
                    p = pBase;
                    CBotFunction* f =
@ -658,7 +626,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
                        f->m_pProg = pStack->GetProgram();
                        f->m_bSynchro = bSynchro;
                    }
-                    pStack->Return(nullptr, pile);
+                    pStack->DeleteNext();
                }

                return pStack->IsOk();
--- a/CBot/src/CBot/CBotClass.h
+++ b/CBot/src/CBot/CBotClass.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -303,6 +303,12 @@ public:
     */
    static void DefineClasses(std::list<CBotClass*> pClassList, CBotCStack* pStack);

+    /*!
+     * \brief Get the list of user-defined methods in this class.
+     * \return List of methods, can be empty.
+     */
+    const std::list<CBotFunction*>& GetFunctions() const;
+
    /*!
     * \brief CompileDefItem
     * \param p
--- a/CBot/src/CBot/CBotDebug.cpp
+++ b/CBot/src/CBot/CBotDebug.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -23,11 +23,11 @@
 #include "CBot/CBotInstr/CBotFunction.h"
 #include "CBot/CBotInstr/CBotInstrCall.h"

+#include <array>
 #include <functional>
 #include <sstream>
 #include <iostream>
 #include <iomanip>
-#include <boost/algorithm/string/replace.hpp>

 namespace CBot
 {
@ -53,22 +53,34 @@ void CBotDebug::DumpCompiledProgram(CBotProgram* program)
            instructions[ptr] = instructionsNextId++;
        }

-        char buffer[20];
-        sprintf(buffer, "instr%d", instructions[ptr]);
-        return std::string(buffer);
+        std::array<char, 20> buffer;
+        snprintf(buffer.data(), buffer.size(), "instr%d", instructions[ptr]);
+        return std::string(buffer.data());
    };
    std::function<void(CBotInstr*)> DumpInstr = [&](CBotInstr* instr)
    {
        if (finished.find(instr) != finished.end()) return;
        finished.insert(instr);

-        std::string label = "<b>"+instr->GetDebugName()+"</b>\n";
+        auto replaceAll = [](std::string& text, const std::string& from, const std::string& to)
+        {
+            std::size_t pos = 0;
+
+            while ((pos = text.find(from, pos)) != std::string::npos)
+            {
+                text.replace(pos, from.length(), to);
+                pos += to.length();
+            }
+        };
+
        std::string data = instr->GetDebugData();
-        boost::algorithm::replace_all(data, "&", "&amp;");
-        boost::algorithm::replace_all(data, "<", "&lt;");
-        boost::algorithm::replace_all(data, ">", "&gt;");
+        replaceAll(data, "&", "&amp;");
+        replaceAll(data, "<", "&lt;");
+        replaceAll(data, ">", "&gt;");
+
+        std::string label = "<b>"+instr->GetDebugName()+"</b>\n";
        label += data;
-        boost::algorithm::replace_all(label, "\n", "<br/>");
+        replaceAll(label, "\n", "<br/>");

        std::string additional = "";
        if (instr->GetDebugName() == "CBotFunction")
--- a/CBot/src/CBot/CBotDebug.h
+++ b/CBot/src/CBot/CBotDebug.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotDefParam.cpp
+++ b/CBot/src/CBot/CBotDefParam.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -64,10 +64,8 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
            if (list == nullptr) list = param;
            else list->AddNext(param);          // added to the list

-//            CBotClass*  pClass = nullptr;//= CBotClass::Find(p);
            param->m_typename = p->GetString();
            CBotTypResult type = param->m_type = TypeParam(p, pStack);
-//          if ( type == CBotTypPointer ) type = CBotTypClass;          // we must create a new object

            if (param->m_type.GetType() > 0)
            {
@ -96,7 +94,7 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
                            prevHasDefault = true;
                        }
                        else pStack->SetError(CBotErrNoExpression, p);
-                        delete pStk;
+                        pStack->DeleteNext();
                    }
                    else
                        if (prevHasDefault) pStack->SetError(CBotErrDefaultValue, p->GetPrev());
@ -105,7 +103,6 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)

                    if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);
                    CBotVar*    var = CBotVar::Create(pp->GetString(), type);       // creates the variable
-//                  if ( pClass ) var->SetClass(pClass);
                    var->SetInit(CBotVar::InitType::IS_POINTER);                                    // mark initialized
                    param->m_nIdent = CBotVar::NextUniqNum();
                    var->SetUniqNum(param->m_nIdent);
@ -140,6 +137,7 @@ bool CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
    while ( p != nullptr )
    {
        pile = pile->AddStack();
+        if (pile->StackOver()) return pj->Return(pile);
        if (pile->GetState() == 1) // already done?
        {
            if (ppVars != nullptr && ppVars[i] != nullptr) ++i;
@ -151,13 +149,12 @@ bool CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)

        if (useDefault || (ppVars == nullptr || ppVars[i] == nullptr))
        {
-            assert(p->m_expr != nullptr);
-
-            useDefault = true;
-
-            if (!p->m_expr->Execute(pile)) return false; // interupt here
-
-            pVar = pile->GetVar();
+            useDefault = true; // end of arguments found
+            if (p->m_expr != nullptr) // has default expression ?
+            {
+                if (!p->m_expr->Execute(pile)) return false; // interupt here
+                pVar = pile->GetVar();
+            }
        }
        else
            pVar = ppVars[i];
--- a/CBot/src/CBot/CBotDefParam.h
+++ b/CBot/src/CBot/CBotDefParam.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotDefines.h
+++ b/CBot/src/CBot/CBotDefines.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotEnums.h
+++ b/CBot/src/CBot/CBotEnums.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -100,6 +100,7 @@ enum TokenId
    ID_STATIC,
    ID_PROTECTED,
    ID_PRIVATE,
+    ID_REPEAT,
    ID_INT,
    ID_FLOAT,
    ID_BOOLEAN,
--- a/CBot/src/CBot/CBotExternalCall.cpp
+++ b/CBot/src/CBot/CBotExternalCall.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -82,19 +82,23 @@ int CBotExternalCallList::DoCall(CBotToken* token, CBotVar* thisVar, CBotVar** p

    CBotExternalCall* pt = m_list[token->GetString()].get();

-    if (pStack->IsCallFinished()) return true;
-    CBotStack* pile = pStack->AddStackExternalCall(pt);
+    if (thisVar == nullptr && pStack->IsCallFinished()) return true;  // only for non-method external call

-    // lists the parameters depending on the contents of the stack (pStackVar)
-    CBotVar* pVar = MakeListVars(ppVar, true);
+    // if this is a method call we need to use AddStack()
+    CBotStack* pile = (thisVar != nullptr) ? pStack->AddStack() : pStack->AddStackExternalCall(pt);

-    // creates a variable to the result
-    CBotVar* pResult = rettype.Eq(CBotTypVoid) ? nullptr : CBotVar::Create("", rettype);
+    if (pile->GetState() == 0) // the first time?
+    {
+        // lists the parameters depending on the contents of the stack
+        CBotVar* pVar = MakeListVars(ppVar, true);
+        pile->SetVar(pVar);

-    pile->SetVar(pVar);
-
-    CBotStack* pile2 = pile->AddStack();
-    pile2->SetVar(pResult);
+        CBotStack* pile2 = pile->AddStack();
+        // creates a variable to the result
+        CBotVar* pResult = rettype.Eq(CBotTypVoid) ? nullptr : CBotVar::Create("", rettype);
+        pile2->SetVar(pResult);
+        pile->IncState(); // increment state to mark this step done
+    }

    pile->SetError(CBotNoErr, token); // save token for the position in case of error
    return pt->Run(thisVar, pStack);
@ -107,7 +111,8 @@ bool CBotExternalCallList::RestoreCall(CBotToken* token, CBotVar* thisVar, CBotV

    CBotExternalCall* pt = m_list[token->GetString()].get();

-    CBotStack* pile = pStack->RestoreStackEOX(pt);
+    // if this is a method call we need to use RestoreStack()
+    CBotStack* pile = (thisVar != nullptr) ? pStack->RestoreStack() : pStack->RestoreStackEOX(pt);
    if (pile == nullptr) return true;

    pile->RestoreStack();
@ -163,8 +168,7 @@ bool CBotExternalCallDefault::Run(CBotVar* thisVar, CBotStack* pStack)
        return false;
    }

-    if (result != nullptr) pStack->SetCopyVar(result);
-
+    pStack->Return(pile2); // return 'result' and clear extra stack
    return true;
 }

@ -187,8 +191,8 @@ CBotTypResult CBotExternalCallClass::Compile(CBotVar* thisVar, CBotVar* args, vo

 bool CBotExternalCallClass::Run(CBotVar* thisVar, CBotStack* pStack)
 {
-    if (pStack->IsCallFinished()) return true;
-    CBotStack* pile = pStack->AddStackExternalCall(this);
+    assert(thisVar != nullptr);
+    CBotStack* pile = pStack->AddStack();
    CBotVar* args = pile->GetVar();

    CBotStack* pile2 = pile->AddStack();
@ -207,9 +211,8 @@ bool CBotExternalCallClass::Run(CBotVar* thisVar, CBotStack* pStack)
        return false;
    }

-    if (result != nullptr) pStack->SetCopyVar(result);
-
+    pStack->Return(pile2); // return 'result' and clear extra stack
    return true;
 }

-}
+} // namespace CBot
--- a/CBot/src/CBot/CBotExternalCall.h
+++ b/CBot/src/CBot/CBotExternalCall.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotFileUtils.cpp
+++ b/CBot/src/CBot/CBotFileUtils.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -59,7 +59,7 @@ static bool ReadBinary(std::istream &istr, T &value)
    while (true)        // unsigned LEB128
    {
        if (!istr.read(reinterpret_cast<char*>(&chr), 1)) return false;
-        if (shift < sizeof(T) * 8 - 1)
+        if (shift < sizeof(T) * 8)
            value |= static_cast<T>(chr & 0x7F) << shift;
        shift += 7;
        if ((chr & 0x80) == 0) break;
@ -183,42 +183,66 @@ bool ReadLong(std::istream &istr, long &l)

 bool WriteFloat(std::ostream &ostr, float f)
 {
-    union {float fValue; unsigned int iValue;} u;
+    union TypeConverter
+    {
+        float fValue;
+        uint32_t iValue;
+    };
+
+    TypeConverter u;
    u.fValue = 0.0f;
    u.iValue = 0;

    u.fValue = f;
-    return WriteBinary<unsigned int>(ostr, u.iValue);
+    return WriteBinary<uint32_t>(ostr, u.iValue);
 }

 bool ReadFloat(std::istream &istr, float &f)
 {
-    union {float fValue; unsigned int iValue;} u;
+    union TypeConverter
+    {
+        float fValue;
+        uint32_t iValue;
+    };
+
+    TypeConverter u;
    u.fValue = 0.0f;
    u.iValue = 0;

-    if (!ReadBinary<unsigned int>(istr, u.iValue)) return false;
+    if (!ReadBinary<uint32_t>(istr, u.iValue)) return false;
    f = u.fValue;
    return true;
 }

 bool WriteDouble(std::ostream &ostr, double d)
 {
-    union {double dValue; unsigned long iValue;} u;
+    union TypeConverter
+    {
+        double dValue;
+        uint64_t iValue;
+    };
+
+    TypeConverter u;
    u.dValue = 0.0;
    u.iValue = 0;

    u.dValue = d;
-    return WriteBinary<unsigned long>(ostr, u.iValue);
+    return WriteBinary<uint64_t>(ostr, u.iValue);
 }

 bool ReadDouble(std::istream &istr, double &d)
 {
-    union {double dValue; unsigned long iValue;} u;
+    union TypeConverter
+    {
+        double dValue;
+        uint64_t iValue;
+    };
+
+    TypeConverter u;
    u.dValue = 0.0;
    u.iValue = 0;

-    if (!ReadBinary<unsigned long>(istr, u.iValue)) return false;
+    if (!ReadBinary<uint64_t>(istr, u.iValue)) return false;
    d = u.dValue;
    return true;
 }
@ -318,7 +342,11 @@ bool WriteStream(std::ostream &ostr, std::istream& istr)
    if (!WriteLong(ostr, size)) return false;

    if (!istr.seekg(0, istr.beg)) return false;
-    if (!(ostr << istr.rdbuf())) return false;
+    while (size > 0)
+    {
+        size -= 1;
+        if (!ostr.put(istr.get())) return false;
+    }

    return true;
 }
@ -331,7 +359,7 @@ bool ReadStream(std::istream& istr, std::ostream &ostr)

    while (length-- > 0)
    {
-        if (!(ostr << istr.get())) return false;
+        if (!ostr.put(istr.get())) return false;
    }
    return true;
 }
--- a/CBot/src/CBot/CBotFileUtils.h
+++ b/CBot/src/CBot/CBotFileUtils.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -19,6 +19,7 @@

 #pragma once

+#include <cstdint>
 #include <iostream>
 #include <string>

--- a/CBot/src/CBot/CBotInstr/CBotBlock.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotBlock.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotBlock.h
+++ b/CBot/src/CBot/CBotInstr/CBotBlock.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotBoolExpr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotBoolExpr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotBoolExpr.h
+++ b/CBot/src/CBot/CBotInstr/CBotBoolExpr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotBreak.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotBreak.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotBreak.h
+++ b/CBot/src/CBot/CBotInstr/CBotBreak.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotCase.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotCase.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotCase.h
+++ b/CBot/src/CBot/CBotInstr/CBotCase.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotCatch.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotCatch.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotCatch.h
+++ b/CBot/src/CBot/CBotInstr/CBotCatch.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotCondition.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotCondition.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotCondition.h
+++ b/CBot/src/CBot/CBotInstr/CBotCondition.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefArray.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDefArray.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefArray.h
+++ b/CBot/src/CBot/CBotInstr/CBotDefArray.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefBoolean.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDefBoolean.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefBoolean.h
+++ b/CBot/src/CBot/CBotInstr/CBotDefBoolean.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefClass.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDefClass.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -135,7 +135,7 @@ CBotInstr* CBotDefClass::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* p
            // the constructor is there?
 //          std::string  noname;
            CBotTypResult r = pClass->CompileMethode(&token, var, ppVars, pStk, inst->m_nMethodeIdent);
-            delete pStk->TokenStack();                          // releases the supplement stack
+            pStk->DeleteNext();                                 // releases the supplement stack
            int typ = r.GetType();

            if (typ == CBotErrUndefCall)
@ -160,7 +160,7 @@ CBotInstr* CBotDefClass::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* p
            if (nullptr != (inst->m_exprRetVar = CBotExprRetVar::Compile(p, pStk, true)))
            {
                inst->m_exprRetVar->SetToken(vartoken);
-                delete pStk->TokenStack();
+                pStk->DeleteNext();
            }
            pStk->SetVar(nullptr);

@ -360,6 +360,7 @@ bool CBotDefClass::Execute(CBotStack* &pj)
            if ( p != nullptr) while ( true )
            {
                pile2 = pile2->AddStack();                      // place on the stack for the results
+                if (pile2->StackOver()) return pj->Return(pile2);
                if ( pile2->GetState() == 0 )
                {
                    if (!p->Execute(pile2)) return false;       // interrupted here?
--- a/CBot/src/CBot/CBotInstr/CBotDefClass.h
+++ b/CBot/src/CBot/CBotInstr/CBotDefClass.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefFloat.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDefFloat.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefFloat.h
+++ b/CBot/src/CBot/CBotInstr/CBotDefFloat.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefInt.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDefInt.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefInt.h
+++ b/CBot/src/CBot/CBotInstr/CBotDefInt.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefString.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDefString.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDefString.h
+++ b/CBot/src/CBot/CBotInstr/CBotDefString.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDo.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotDo.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotDo.h
+++ b/CBot/src/CBot/CBotInstr/CBotDo.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotEmpty.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotEmpty.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotEmpty.h
+++ b/CBot/src/CBot/CBotInstr/CBotEmpty.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitBool.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitBool.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitBool.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitBool.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitChar.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitChar.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitChar.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitChar.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -21,6 +21,8 @@

 #include "CBot/CBotInstr/CBotInstr.h"

+#include <cstdint>
+
 namespace CBot
 {

--- a/CBot/src/CBot/CBotInstr/CBotExprLitNan.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitNan.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -23,6 +23,8 @@

 #include "CBot/CBotVar/CBotVar.h"

+#include <cmath>
+
 namespace CBot
 {

@ -41,9 +43,9 @@ bool CBotExprLitNan::Execute(CBotStack* &pj)
    CBotStack*    pile = pj->AddStack(this);

    if (pile->IfStep()) return false;
-    CBotVar*    var = CBotVar::Create("", CBotTypInt);
+    CBotVar*    var = CBotVar::Create("", CBotTypFloat);

-    var->SetInit(CBotVar::InitType::IS_NAN);       // nan
+    var->SetValFloat(nanf(""));
    pile->SetVar(var);          // put on the stack
    return pj->Return(pile);    // forward below
 }
--- a/CBot/src/CBot/CBotInstr/CBotExprLitNan.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitNan.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitNull.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitNull.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitNull.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitNull.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitNum.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitNum.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprLitNum.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitNum.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -38,7 +38,9 @@ class CBotExprLitNum : public CBotInstr
 {

 public:
-    CBotExprLitNum(T val);
+    // To keep linter happy, instead of = delete (see https://stackoverflow.com/a/37593094)
+    CBotExprLitNum(T val) { static_assert(sizeof(T) == 0, "Only specializations of CBotExprLitNum can be used"); };
+
    ~CBotExprLitNum();

    /*!
--- a/CBot/src/CBot/CBotInstr/CBotExprLitString.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitString.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -24,6 +24,8 @@

 #include "CBot/CBotVar/CBotVar.h"

+#include <stdexcept>
+
 namespace CBot
 {

--- a/CBot/src/CBot/CBotInstr/CBotExprLitString.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprLitString.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprRetVar.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprRetVar.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprRetVar.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprRetVar.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprUnaire.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprUnaire.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprUnaire.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprUnaire.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprVar.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExprVar.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExprVar.h
+++ b/CBot/src/CBot/CBotInstr/CBotExprVar.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotExpression.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotExpression.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -206,12 +206,6 @@ bool CBotExpression::Execute(CBotStack* &pj)
        if (m_token.GetType() != ID_ASS)
        {
            pVar = pile1->GetVar();     // recovers if interrupted
-            initKind = pVar->GetInit();
-            if (initKind == CBotVar::InitType::IS_NAN)
-            {
-                pile2->SetError(CBotErrNan, m_leftop->GetToken());
-                return pj->Return(pile2);
-            }
            result = CBotVar::Create("", pVar->GetTypResult(CBotVar::GetTypeMode::CLASS_AS_INTRINSIC));
        }

--- a/CBot/src/CBot/CBotInstr/CBotExpression.h
+++ b/CBot/src/CBot/CBotInstr/CBotExpression.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotFieldExpr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotFieldExpr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotFieldExpr.h
+++ b/CBot/src/CBot/CBotInstr/CBotFieldExpr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotFor.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotFor.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotFor.h
+++ b/CBot/src/CBot/CBotInstr/CBotFor.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotFunction.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotFunction.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -76,6 +76,18 @@ bool CBotFunction::IsPublic()
    return m_bPublic;
 }

+////////////////////////////////////////////////////////////////////////////////
+bool CBotFunction::IsProtected() const
+{
+    return m_bProtect;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool CBotFunction::IsPrivate() const
+{
+    return m_bPrivate;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 bool CBotFunction::IsExtern()
 {
@ -129,21 +141,17 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
 {
    CBotToken*      pp;
    CBotFunction* func = finput;
-    if ( func == nullptr ) func = new CBotFunction();
+    assert(func != nullptr); // a pre-compiled function is required

    CBotCStack* pStk = pStack->TokenStack(p, bLocal);

-//  func->m_nFuncIdent = CBotVar::NextUniqNum();
-
    while (true)
    {
-        if ( IsOfType(p, ID_PUBLIC) )
-        {
-            func->m_bPublic = true;
-            continue;
-        }
+        if (IsOfType(p, ID_PRIVATE)) break;
+        if (IsOfType(p, ID_PROTECTED)) break;
+        if (IsOfType(p, ID_PUBLIC)) continue;
        pp = p;
-        if ( IsOfType(p, ID_EXTERN) )
+        if (IsOfType(p, ID_EXTERN))
        {
            func->m_extern = *pp;        // for the position of the word "extern"
            func->m_bExtern = true;
@ -183,10 +191,23 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
                    goto bad;
                }

-//              pp = p;
+                pp = p;
                func->m_token = *p;
                if (!IsOfType(p, TokenTypVar)) goto bad;
-
+                // check if the class has a method like this
+                if (pClass->CheckCall(pStack->GetProgram(), func->m_param, pp))
+                {
+                    pStk->SetStartError(func->m_classToken.GetStart());
+                    pStk->SetError(CBotErrRedefFunc, pp->GetEnd());
+                    goto bad;
+                }
+                // check if a constructor has return type void
+                if (func->GetName() == pClass->GetName() && !func->m_retTyp.Eq(CBotTypVoid))
+                {
+                    pp = &(func->m_retToken);
+                    pStk->SetError(CBotErrFuncNotVoid, pp);
+                    goto bad;
+                }
            }
            func->m_openpar = *p;
            delete func->m_param;
@ -198,28 +219,13 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct

                if (!func->m_MasterClass.empty())
                {
-                    // return "this" known
-                    CBotVar* pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, func->m_MasterClass ));
-                    pThis->SetInit(CBotVar::InitType::IS_POINTER);
-//                  pThis->SetUniqNum(func->m_nThisIdent = -2); //CBotVar::NextUniqNum() will not
-                    pThis->SetUniqNum(-2);
-                    pStk->AddVar(pThis);
+                    CBotClass* pClass = CBotClass::Find(func->m_MasterClass);

-                    // initialize variables acording to This
-                    // only saves the pointer to the first,
-                    // the rest is chained
-                    CBotVar* pv = pThis->GetItemList();
-//                  int num = 1;
-                    while (pv != nullptr)
-                    {
-                        CBotVar* pcopy = CBotVar::Create(pv);
-//                      pcopy->SetInit(2);
-                        pcopy->Copy(pv);
-                        pcopy->SetPrivate(pv->GetPrivate());
-//                      pcopy->SetUniqNum(pv->GetUniqNum()); //num++);
-                        pStk->AddVar(pcopy);
-                        pv = pv->GetNext();
-                    }
+                    pStk->CreateVarThis(pClass);
+                    pStk->CreateVarSuper(pClass->GetParent());
+
+                    bool bConstructor = (func->GetName() == func->m_MasterClass);
+                    pStk->CreateMemberVars(pClass, !bConstructor);
                }

                // and compiles the following instruction block
@ -242,7 +248,6 @@ bad:
        pStk->SetError(CBotErrNoFunc, p);
    }
    pStk->SetError(CBotErrNoType, p);
-    if ( finput == nullptr ) delete func;
    return pStack->ReturnFunc(nullptr, pStk);
 }

@ -254,14 +259,30 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas

    CBotCStack* pStk = pStack->TokenStack(p, true);

+    CBotToken* pPriv = p;
+
    while (true)
    {
-        if ( IsOfType(p, ID_PUBLIC) )
+        if (!func->m_bPublic) // don't repeat 'public'
        {
-        //  func->m_bPublic = true;     // will be done in two passes
-            continue;
+            pPriv = p;
+            if (IsOfType(p, ID_PRIVATE))
+            {
+                func->m_bPrivate = true;
+                break;
+            }
+            if (IsOfType(p, ID_PROTECTED))
+            {
+                func->m_bProtect = true;
+                break;
+            }
+            if (IsOfType(p, ID_PUBLIC))
+            {
+                func->m_bPublic = true;
+                continue;
+            }
        }
-        if ( IsOfType(p, ID_EXTERN) )
+        if (!func->m_bExtern && IsOfType(p, ID_EXTERN))
        {
            func->m_bExtern = true;
            continue;
@ -297,12 +318,21 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
                if (!IsOfType(p, TokenTypVar)) goto bad;

            }
+            else if (pClass == nullptr) // not method in a class ?
+            {
+                if (func->m_bPrivate || func->m_bProtect) // not allowed for regular functions
+                {
+                    pStk->SetError(CBotErrNoType, pPriv);
+                    goto bad;
+                }
+            }

            CBotToken* openPar = p;
            func->m_param = CBotDefParam::Compile(p, pStk); // compile parameters

            if (pStk->IsOk() && pClass != nullptr) // method in a class
            {
+                func->m_MasterClass = pClass->GetName();
                // check if a constructor has return type void
                if (func->GetName() == pClass->GetName() && !func->m_retTyp.Eq(CBotTypVoid))
                {
@ -331,7 +361,7 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
            {
                // looks if the function exists elsewhere
                pp = &(func->m_token);
-                if (( pClass != nullptr || !pStack->CheckCall(pp, func->m_param)) &&
+                if (( pClass != nullptr || !pStack->CheckCall(pp, func->m_param, func->m_MasterClass)) &&
                    ( pClass == nullptr || !pClass->CheckCall(pStack->GetProgram(), func->m_param, pp)) )
                {
                    if (IsOfType(p, ID_OPBLK))
@ -415,7 +445,7 @@ bool CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
        pile->IncState();
    }

-    if ( !m_block->Execute(pile) )
+    if (!pile->GetRetVar(m_block->Execute(pile)))
    {
        if ( pile->GetError() < 0 )
            pile->SetError( CBotNoErr );
@ -472,10 +502,10 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst
 }

 ////////////////////////////////////////////////////////////////////////////////
-CBotTypResult CBotFunction::CompileCall(const std::list<CBotFunction*>& localFunctionList, const std::string &name, CBotVar** ppVars, long &nIdent)
+CBotTypResult CBotFunction::CompileCall(const std::string &name, CBotVar** ppVars, long &nIdent, CBotProgram* program)
 {
    CBotTypResult type;
-    if (!FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type))
+    if (!FindLocalOrPublic(program->GetFunctions(), nIdent, name, ppVars, type, program))
    {
        // Reset the identifier to "not found" value
        nIdent = 0;
@ -485,7 +515,7 @@ CBotTypResult CBotFunction::CompileCall(const std::list<CBotFunction*>& localFun

 ////////////////////////////////////////////////////////////////////////////////
 CBotFunction* CBotFunction::FindLocalOrPublic(const std::list<CBotFunction*>& localFunctionList, long &nIdent, const std::string &name,
-                                              CBotVar** ppVars, CBotTypResult &TypeOrError, bool bPublic)
+                                              CBotVar** ppVars, CBotTypResult &TypeOrError, CBotProgram* baseProg)
 {
    TypeOrError.SetType(CBotErrUndefCall);      // no routine of the name

@ -515,10 +545,39 @@ CBotFunction* CBotFunction::FindLocalOrPublic(const std::list<CBotFunction*>& lo

    std::map<CBotFunction*, int> funcMap;

-    for (CBotFunction* pt : localFunctionList)
+    CBotFunction::SearchList(localFunctionList, name, ppVars, TypeOrError, funcMap);
+
+    CBotFunction::SearchPublic(name, ppVars, TypeOrError, funcMap);
+
+    if (baseProg != nullptr && baseProg->m_thisVar != nullptr)
+    {
+        // find object:: functions
+        CBotClass* pClass = baseProg->m_thisVar->GetClass();
+        CBotFunction::SearchList(localFunctionList, name, ppVars, TypeOrError, funcMap, pClass);
+        CBotFunction::SearchPublic(name, ppVars, TypeOrError, funcMap, pClass);
+    }
+
+    return CBotFunction::BestFunction(funcMap, nIdent, TypeOrError);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void CBotFunction::SearchList(const std::list<CBotFunction*>& functionList,
+                              const std::string& name, CBotVar** ppVars, CBotTypResult& TypeOrError,
+                              std::map<CBotFunction*, int>& funcMap, CBotClass* pClass)
+{
+    for (CBotFunction* pt : functionList)
    {
        if ( pt->m_token.GetString() == name )
        {
+            if (pClass != nullptr) // looking for a method ?
+            {
+                if (pt->m_MasterClass != pClass->GetName()) continue;
+            }
+            else                   // looking for a function
+            {
+                if (!pt->m_MasterClass.empty()) continue;
+            }
+
            int i = 0;
            int alpha = 0;                          // signature of parameters
            // parameters are compatible?
@ -575,13 +634,26 @@ CBotFunction* CBotFunction::FindLocalOrPublic(const std::list<CBotFunction*>& lo
            funcMap.insert( std::pair<CBotFunction*, int>(pt, alpha) );
        }
    }
+}

-    if ( bPublic )
+////////////////////////////////////////////////////////////////////////////////
+void CBotFunction::SearchPublic(const std::string& name, CBotVar** ppVars, CBotTypResult& TypeOrError,
+                                std::map<CBotFunction*, int>& funcMap, CBotClass* pClass)
+{
    {
        for (CBotFunction* pt : m_publicFunctions)
        {
            if ( pt->m_token.GetString() == name )
            {
+                if (pClass != nullptr) // looking for a method ?
+                {
+                    if (pt->m_MasterClass != pClass->GetName()) continue;
+                }
+                else                   // looking for a function
+                {
+                    if (!pt->m_MasterClass.empty()) continue;
+                }
+
                int i = 0;
                int alpha = 0;                          // signature of parameters
                // are parameters compatible ?
@ -639,7 +711,12 @@ CBotFunction* CBotFunction::FindLocalOrPublic(const std::list<CBotFunction*>& lo
            }
        }
    }
+}

+////////////////////////////////////////////////////////////////////////////////
+CBotFunction* CBotFunction::BestFunction(std::map<CBotFunction*, int>& funcMap,
+                                         long& nIdent, CBotTypResult& TypeOrError)
+{
    if ( !funcMap.empty() )
    {
        auto it = funcMap.begin();
@ -675,7 +752,7 @@ int CBotFunction::DoCall(CBotProgram* program, const std::list<CBotFunction*>& l
    CBotFunction*   pt = nullptr;
    CBotProgram*    baseProg = pStack->GetProgram(true);

-    pt = FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type);
+    pt = FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type, baseProg);

    if ( pt != nullptr )
    {
@ -766,7 +843,7 @@ void CBotFunction::RestoreCall(const std::list<CBotFunction*>& localFunctionList
    CBotStack*      pStk3;
    CBotProgram*    baseProg = pStack->GetProgram(true);

-    pt = FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type);
+    pt = FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type, baseProg);

    if ( pt != nullptr )
    {
@ -824,13 +901,121 @@ void CBotFunction::RestoreCall(const std::list<CBotFunction*>& localFunctionList
 }

 ////////////////////////////////////////////////////////////////////////////////
-int CBotFunction::DoCall(const std::list<CBotFunction*>& localFunctionList, long &nIdent, const std::string &name, CBotVar* pThis,
+CBotTypResult CBotFunction::CompileMethodCall(const std::string& name, CBotVar** ppVars,
+                                              long& nIdent, CBotCStack* pStack, CBotClass* pClass)
+{
+    nIdent = 0;
+    CBotTypResult type;
+
+    CBotFunction* pt = FindMethod(nIdent, name, ppVars, type, pClass, pStack->GetProgram());
+
+    if (pt != nullptr)
+    {
+        CBotToken token("this");
+        CBotVar* pThis = pStack->FindVar(token); // for 'this' context
+
+        if (pThis == nullptr || pThis->GetType() != CBotTypPointer) // called from inside a function
+        {
+            if (pt->IsPrivate() || pt->IsProtected())
+                type.SetType(CBotErrPrivate);
+        }
+        else     // called from inside a method
+        {
+            CBotClass* thisClass = pThis->GetClass(); // current class
+            CBotClass* funcClass = CBotClass::Find(pt->m_MasterClass); // class of the method
+
+            if (pt->IsPrivate() && thisClass != funcClass)
+                type.SetType(CBotErrPrivate);
+
+            if (pt->IsProtected() && !thisClass->IsChildOf(funcClass))
+                type.SetType(CBotErrPrivate);
+        }
+    }
+
+    return type;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+CBotFunction* CBotFunction::FindMethod(long& nIdent, const std::string& name,
+                                       CBotVar** ppVars, CBotTypResult& TypeOrError,
+                                       CBotClass* pClass, CBotProgram* program)
+{
+    TypeOrError.SetType(CBotErrUndefCall);      // no routine of the name
+
+    auto methods = pClass->GetFunctions();
+
+    if ( nIdent )
+    {
+        // search methods in the class
+        for (CBotFunction* pt : methods)
+        {
+            if ( pt->m_nFuncIdent == nIdent )
+            {
+                TypeOrError = pt->m_retTyp;
+                return pt;
+            }
+        }
+
+        bool skipPublic = false;
+        if (program != nullptr)
+        {
+            // search the current program
+            for (CBotFunction* pt : program->GetFunctions())
+            {
+                if ( pt->m_nFuncIdent == nIdent )
+                {
+                    // check if the method is inherited
+                    if ( pt->GetClassName() != pClass->GetName() )
+                    {
+                        skipPublic = true;
+                        break; // break in case there is an override
+                    }
+                    TypeOrError = pt->m_retTyp;
+                    return pt;
+                }
+            }
+        }
+
+        // search the list of public functions
+        if (!skipPublic)
+        {
+            for (CBotFunction* pt : m_publicFunctions)
+            {
+                if (pt->m_nFuncIdent == nIdent)
+                {
+                    // check if the method is inherited, break in case there is an override
+                    if ( pt->GetClassName() != pClass->GetName() ) break;
+                    TypeOrError = pt->m_retTyp;
+                    return pt;
+                }
+            }
+        }
+    }
+
+    if ( name.empty() ) return nullptr;
+
+    std::map<CBotFunction*, int> funcMap;
+
+    // search methods in the class
+    CBotFunction::SearchList(methods, name, ppVars, TypeOrError, funcMap, pClass);
+
+    // search the current program for methods
+    if (program != nullptr)
+        CBotFunction::SearchList(program->GetFunctions(), name, ppVars, TypeOrError, funcMap, pClass);
+
+    CBotFunction::SearchPublic(name, ppVars, TypeOrError, funcMap, pClass);
+
+    return CBotFunction::BestFunction(funcMap, nIdent, TypeOrError);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int CBotFunction::DoCall(long &nIdent, const std::string &name, CBotVar* pThis,
                         CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass)
 {
    CBotTypResult   type;
    CBotProgram*    pProgCurrent = pStack->GetProgram();

-    CBotFunction*   pt = FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type, false);
+    CBotFunction*   pt = FindMethod(nIdent, name, ppVars, type, pClass, pProgCurrent);

    if ( pt != nullptr )
    {
@ -925,11 +1110,11 @@ int CBotFunction::DoCall(const std::list<CBotFunction*>& localFunctionList, long
 }

 ////////////////////////////////////////////////////////////////////////////////
-bool CBotFunction::RestoreCall(const std::list<CBotFunction*>& localFunctionList, long &nIdent, const std::string &name, CBotVar* pThis,
+bool CBotFunction::RestoreCall(long &nIdent, const std::string &name, CBotVar* pThis,
                               CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass)
 {
    CBotTypResult   type;
-    CBotFunction*   pt = FindLocalOrPublic(localFunctionList, nIdent, name, ppVars, type);
+    CBotFunction*   pt = FindMethod(nIdent, name, ppVars, type, pClass, pStack->GetProgram());

    if ( pt != nullptr )
    {
@ -1020,6 +1205,12 @@ std::string CBotFunction::GetParams()
    return params;
 }

+////////////////////////////////////////////////////////////////////////////////
+const std::string& CBotFunction::GetClassName() const
+{
+    return m_MasterClass;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 void CBotFunction::AddPublic(CBotFunction* func)
 {
--- a/CBot/src/CBot/CBotInstr/CBotFunction.h
+++ b/CBot/src/CBot/CBotInstr/CBotFunction.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -105,21 +105,19 @@ public:
     *
     * See FindLocalOrPublic for more detailed explanation
     *
-     * \param localFunctionList Linked list of local functions to search in, can be null
     * \param name Name of the function
     * \param ppVars List of function arguments
     * \param nIdent[in, out] Unique identifier of the function
+     * \param program The current program, to search for functions.
     * \return Type returned by the function or error code
     * \see FindLocalOrPublic
     */
-    static CBotTypResult CompileCall(const std::list<CBotFunction*>& localFunctionList,
-                                     const std::string &name, CBotVar** ppVars, long &nIdent);
+    static CBotTypResult CompileCall(const std::string &name, CBotVar** ppVars,
+                                     long &nIdent, CBotProgram* program);

    /*!
     * \brief Finds a local or public function
     *
-     * <p>Finds a local or (if bPublic is true) public function to call
-     *
     * <p>First, it looks for a function according to its unique identifier.<br>
     * If the identifier is not found, looks by name and parameters.
     *
@ -128,11 +126,46 @@ public:
     * \param name Name of the function
     * \param ppVars List of function arguments
     * \param TypeOrError Type returned by the function or error code
-     * \param bPublic Whether to look in public functions or not
+     * \param baseProg Initial program, for context of the object/bot
     * \return Pointer to found CBotFunction instance, or nullptr in case of no match or ambiguity (see TypeOrError for error code)
     */
    static CBotFunction* FindLocalOrPublic(const std::list<CBotFunction*>& localFunctionList, long &nIdent, const std::string &name,
-                                           CBotVar** ppVars, CBotTypResult &TypeOrError, bool bPublic = true);
+                                           CBotVar** ppVars, CBotTypResult &TypeOrError, CBotProgram* baseProg);
+
+    /*!
+     * \brief Find all functions that match the name and arguments.
+     * \param functionList List of functions to search, can be empty.
+     * \param name Name of the function to find.
+     * \param ppVars Arguments to compare with parameters.
+     * \param TypeOrError Contains a CBotError when no useable function has been found.
+     * \param funcMap Container for suitable functions and their signature values.
+     * \param pClass Pointer to class when searching for methods.
+     */
+    static void SearchList(const std::list<CBotFunction*>& functionList,
+                           const std::string& name, CBotVar** ppVars, CBotTypResult& TypeOrError,
+                           std::map<CBotFunction*, int>& funcMap, CBotClass* pClass = nullptr);
+
+    /*!
+     * \brief Find all public functions that match the name and arguments.
+     * \param name Name of the function to find.
+     * \param ppVars Arguments to compare with parameters.
+     * \param TypeOrError Contains a CBotError when no useable function has been found.
+     * \param funcMap Container for suitable functions and their signature values.
+     * \param pClass Pointer to class when searching for methods.
+     */
+    static void SearchPublic(const std::string& name, CBotVar** ppVars, CBotTypResult& TypeOrError,
+                             std::map<CBotFunction*, int>& funcMap, CBotClass* pClass = nullptr);
+
+    /*!
+     * \brief Find the function with the lowest signature value. If there is more
+     * than one of the same signature value, TypeOrError is set to CBotErrAmbiguousCall.
+     * \param funcMap List of functions and their signature values, can be empty.
+     * \param[out] nIdent Unique identifier of the function.
+     * \param TypeOrError Type returned by the function or error code.
+     * \return Pointer to the function with the lowest signature or nullptr.
+     */
+    static CBotFunction* BestFunction(std::map<CBotFunction*, int>& funcMap,
+                                      long& nIdent, CBotTypResult& TypeOrError);

    /*!
     * \brief DoCall Fait un appel à une fonction.
@ -160,10 +193,34 @@ public:
    static void RestoreCall(const std::list<CBotFunction*>& localFunctionList,
                            long &nIdent, const std::string &name, CBotVar** ppVars, CBotStack* pStack);

+    /*!
+     * \brief Find a method matching the name and arguments.
+     * \param name Name of the method to find.
+     * \param ppVars Arguments to compare with parameters.
+     * \param[out] nIdent Unique identifier of the method.
+     * \param pStack Current compilation stack frame.
+     * \param pClass Pointer to the class.
+     * \return The return type for the method or a CBotError.
+     */
+    static CBotTypResult CompileMethodCall(const std::string& name, CBotVar** ppVars,
+                                           long& nIdent, CBotCStack* pStack, CBotClass* pClass);
+
+    /*!
+     * \brief Find a method by its unique identifier or by name and parameters.
+     * \param[in,out] nIdent Unique identifier of the method.
+     * \param name Name of the method to find.
+     * \param ppVars Arguments to compare with parameters.
+     * \param TypeOrError The return type for the method or a CBotError.
+     * \param pClass Pointer to the class.
+     * \param program The current program, to search for out-of-class methods.
+     * \return Pointer to the method that best matches the given arguments or nullptr.
+     */
+    static CBotFunction* FindMethod(long& nIdent, const std::string& name,
+                                    CBotVar** ppVars, CBotTypResult& TypeOrError,
+                                    CBotClass* pClass, CBotProgram* program);
+
    /*!
     * \brief DoCall Makes call of a method
-     * note: this is already on the stack, the pointer pThis is just to simplify.
-     * \param localFunctionList
     * \param nIdent
     * \param name
     * \param pThis
@ -173,12 +230,11 @@ public:
     * \param pClass
     * \return
     */
-    static int DoCall(const std::list<CBotFunction*>& localFunctionList, long &nIdent, const std::string &name, CBotVar* pThis,
+    static int DoCall(long &nIdent, const std::string &name, CBotVar* pThis,
                      CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass);

    /*!
     * \brief RestoreCall
-     * \param localFunctionList
     * \param nIdent
     * \param name
     * \param pThis
@ -187,7 +243,7 @@ public:
     * \param pClass
     * \return Returns true if the method call was restored.
     */
-    static bool RestoreCall(const std::list<CBotFunction*>& localFunctionList, long &nIdent, const std::string &name, CBotVar* pThis,
+    static bool RestoreCall(long &nIdent, const std::string &name, CBotVar* pThis,
                            CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass);

    /*!
@ -215,12 +271,30 @@ public:
     */
    std::string GetParams();

+    /*!
+     * \brief Get the name of the class for a method.
+     * \return The name of a class or empty string if it's not a method.
+     */
+    const std::string& GetClassName() const;
+
    /*!
     * \brief IsPublic
     * \return
     */
    bool IsPublic();

+    /*!
+     * \brief Check if a method is protected.
+     * \return true if a method was compiled with "protected" keyword.
+     */
+    bool IsProtected() const;
+
+    /*!
+     * \brief Check if a method is private.
+     * \return true if a method was compiled with "private" keyword.
+     */
+    bool IsPrivate() const;
+
    /*!
     * \brief IsExtern
     * \return
@ -266,6 +340,10 @@ private:
    CBotTypResult m_retTyp;
    //! Public function.
    bool m_bPublic;
+    //! Protected method.
+    bool m_bProtect = false;
+    //! Private method.
+    bool m_bPrivate = false;
    //! Extern function.
    bool m_bExtern;
    //! Name of the class we are part of
--- a/CBot/src/CBot/CBotInstr/CBotIf.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotIf.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotIf.h
+++ b/CBot/src/CBot/CBotInstr/CBotIf.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotIndexExpr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotIndexExpr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotIndexExpr.h
+++ b/CBot/src/CBot/CBotInstr/CBotIndexExpr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotInstr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotInstr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -30,6 +30,7 @@
 #include "CBot/CBotInstr/CBotExpression.h"
 #include "CBot/CBotInstr/CBotFor.h"
 #include "CBot/CBotInstr/CBotIf.h"
+#include "CBot/CBotInstr/CBotRepeat.h"
 #include "CBot/CBotInstr/CBotReturn.h"
 #include "CBot/CBotInstr/CBotSwitch.h"
 #include "CBot/CBotInstr/CBotThrow.h"
@ -176,7 +177,7 @@ CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack)
    {
         type = pp->GetType();
         // Allow only instructions that accept a label
-         if (!IsOfTypeList(pp, ID_WHILE, ID_FOR, ID_DO, 0))
+         if (!IsOfTypeList(pp, ID_WHILE, ID_FOR, ID_DO, ID_REPEAT, 0))
         {
             pStack->SetError(CBotErrLabel, pp->GetStart());
             return nullptr;
@ -195,6 +196,9 @@ CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack)
    case ID_DO:
        return CBotDo::Compile(p, pStack);

+    case ID_REPEAT:
+        return CBotRepeat::Compile(p, pStack);
+
    case ID_BREAK:
    case ID_CONTINUE:
        return CBotBreak::Compile(p, pStack);
--- a/CBot/src/CBot/CBotInstr/CBotInstr.h
+++ b/CBot/src/CBot/CBotInstr/CBotInstr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -38,7 +38,7 @@ class CBotDebug;
 * \endcode
 * the following structure is generated:
 * \dot
- * # Generated using the CBot_compile_graph tool
+ * # Generated using the CBot-CompileGraph tool
 * # and slightly modified
 * digraph {
 * start [label=<START> shape=box3d color=cyan]
--- a/CBot/src/CBot/CBotInstr/CBotInstrCall.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotInstrCall.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -78,12 +78,12 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
        {
 //          if (pVar2!=nullptr) pp = pVar2->RetToken();
            pStack->SetError( static_cast<CBotError>(inst->m_typRes.GetType()), pp );
-            delete pStack->TokenStack();
+            pStack->DeleteNext();
            delete inst;
            return nullptr;
        }

-        delete pStack->TokenStack();
+        pStack->DeleteNext();
        if ( inst->m_typRes.GetType() > 0 )
        {
            CBotVar* pRes = CBotVar::Create("", inst->m_typRes);
@ -94,7 +94,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
        if (nullptr != (inst->m_exprRetVar = CBotExprRetVar::Compile(p, pStack)))
        {
            inst->m_exprRetVar->SetToken(&inst->m_token);
-            delete pStack->TokenStack();
+            pStack->DeleteNext();
        }
        if ( !pStack->IsOk() )
        {
@ -105,7 +105,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
        return inst;
    }
    p = pp;
-    delete pStack->TokenStack();
+    pStack->DeleteNext();
    return nullptr;
 }

@ -138,6 +138,7 @@ bool CBotInstrCall::Execute(CBotStack* &pj)
    if ( p != nullptr) while ( true )
    {
        pile = pile->AddStack();                        // place on the stack for the results
+        if (pile->StackOver()) return pj->Return(pile);
        if ( pile->GetState() == 0 )
        {
            if (!p->Execute(pile)) return false;        // interrupted here?
--- a/CBot/src/CBot/CBotInstr/CBotInstrCall.h
+++ b/CBot/src/CBot/CBotInstr/CBotInstrCall.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotInstrMethode.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotInstrMethode.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -70,7 +70,7 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar*
            CBotClass* pClass = var->GetClass();    // pointer to the class
            inst->m_className = pClass->GetName();  // name of the class
            CBotTypResult r = pClass->CompileMethode(pp, var, ppVars, pStack, inst->m_MethodeIdent);
-            delete pStack->TokenStack();    // release parameters on the stack
+            pStack->DeleteNext();           // release parameters on the stack
            inst->m_typRes = r;

            if (inst->m_typRes.GetType() > 20)
@ -95,7 +95,7 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar*
            if (nullptr != (inst->m_exprRetVar = CBotExprRetVar::Compile(p, pStack, bMethodChain)))
            {
                inst->m_exprRetVar->SetToken(pp);
-                delete pStack->TokenStack();
+                pStack->DeleteNext();
            }

            if ( pStack->IsOk() )
@ -164,6 +164,7 @@ bool CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre
        }
        ppVars[i++] = pile2->GetVar();              // construct the list of pointers
        pile2 = pile2->AddStack();                  // space on the stack for the result
+        if (pile2->StackOver()) return pj->Return(pile2);
        p = p->GetNext();
        if ( p == nullptr) break;
    }
--- a/CBot/src/CBot/CBotInstr/CBotInstrMethode.h
+++ b/CBot/src/CBot/CBotInstr/CBotInstrMethode.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotInstrUtils.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotInstrUtils.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -65,7 +65,7 @@ CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars)
            {
                if (pile->GetTypResult().Eq(99))
                {
-                    delete pStack->TokenStack();
+                    pStack->DeleteNext();
                    pStack->SetError(CBotErrVoid, p->GetStart());
                    return nullptr;
                }
@ -78,7 +78,7 @@ CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars)
            }

            pStack->SetError(CBotErrClosePar, p->GetStart());
-            delete pStack->TokenStack();
+            pStack->DeleteNext();
            return nullptr;
        }
    }
--- a/CBot/src/CBot/CBotInstr/CBotInstrUtils.h
+++ b/CBot/src/CBot/CBotInstr/CBotInstrUtils.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotLeftExpr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotLeftExpr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotLeftExpr.h
+++ b/CBot/src/CBot/CBotInstr/CBotLeftExpr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotLeftExprVar.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotLeftExprVar.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotLeftExprVar.h
+++ b/CBot/src/CBot/CBotInstr/CBotLeftExprVar.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotListArray.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotListArray.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotListArray.h
+++ b/CBot/src/CBot/CBotInstr/CBotListArray.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotListExpression.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotListExpression.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotListExpression.h
+++ b/CBot/src/CBot/CBotInstr/CBotListExpression.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotListInstr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotListInstr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotListInstr.h
+++ b/CBot/src/CBot/CBotInstr/CBotListInstr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotLogicExpr.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotLogicExpr.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotLogicExpr.h
+++ b/CBot/src/CBot/CBotInstr/CBotLogicExpr.h
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
--- a/CBot/src/CBot/CBotInstr/CBotNew.cpp
+++ b/CBot/src/CBot/CBotInstr/CBotNew.cpp
@ -1,6 +1,6 @@
 /*
 * This file is part of the Colobot: Gold Edition source code
- * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
+ * Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
@ -87,7 +87,7 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack)

        // constructor exist?
        CBotTypResult r = pClass->CompileMethode(&inst->m_vartoken, pVar, ppVars, pStk, inst->m_nMethodeIdent);
-        delete pStk->TokenStack();  // release extra stack
+        pStk->DeleteNext(); // release extra stack
        int typ = r.GetType();

        // if there is no constructor, and no parameters either, it's ok
@ -115,7 +115,7 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack)
        if (nullptr != (inst->m_exprRetVar = CBotExprRetVar::Compile(p, pStk, true)))
        {
            inst->m_exprRetVar->SetToken(pp);
-            delete pStk->TokenStack();
+            pStk->DeleteNext();
        }

        if (pStack->IsOk())
@ -189,6 +189,7 @@ bool CBotNew::Execute(CBotStack* &pj)
        if (p != nullptr) while ( true)
        {
            pile2 = pile2->AddStack();  // space on the stack for the result
+            if (pile2->StackOver()) return pj->Return(pile2);
            if (pile2->GetState() == 0)
            {
                if (!p->Execute(pile2)) return false;   // interrupted here?
--- a/Show More
+++ b/Show More