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

Fixes crash on startup - when logging FULL_NAME with %s - on Linux.

.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

.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

.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

.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

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()

CBot/README.txt

@@ -1,9 +1,10 @@
 /**
- * \dir src/CBot
+ * \dir CBot
  * \brief CBot library
  */
 
 /**
  * \namespace CBot
  * \brief CBot engine
- */
+ */
+ 

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

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
 {
 
-////////////////////////////////////////////////////////////////////////////////
+struct CBotCStack::Data
-CBotProgram* CBotCStack::m_prog    = nullptr;            // init the static variable
+{
-CBotError CBotCStack::m_error   = CBotNoErr;
+    //! The program currently being compiled
-int CBotCStack::m_end      = 0;
+    CBotProgram*  prog   = nullptr;
-CBotTypResult CBotCStack::m_retTyp  = CBotTypResult(0);
+    //! 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_data = new CBotCStack::Data;
-        m_start = 0;
+        m_errStart = 0;
-        m_end    = 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) delete m_data;
-    if (m_prev != nullptr) m_prev->m_next = nullptr;        // removes chain
-
-    delete m_var;
-    delete m_listVar;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 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.reset(new CBotCStack(this));
-    m_next = p;                                    // channel element
+    m_next->m_bBlock = bBlock;
-    p->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 = std::move(pfils->m_var);             // result transmitted
-    m_var = pfils->m_var;                        // result transmitted
-    pfils->m_var = nullptr;                        // not to destroy the variable
 
-    if (m_error)
+    if (m_data->error != CBotNoErr)
     {
-        m_start = pfils->m_start;                // retrieves the position of the error
+        m_errStart = pfils->m_errStart;          // retrieves the position of the error
-        m_end    = pfils->m_end;
     }
 
-    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 = std::move(pfils->m_var);             // result transmitted
-    m_var = pfils->m_var;                        // result transmitted
-    pfils->m_var = nullptr;                        // not to destroy the variable
 
-    if (m_error)
+    if (m_data->error != CBotNoErr)
     {
-        m_start = pfils->m_start;                // retrieves the position of the error
+        m_errStart = pfils->m_errStart;          // retrieves the position of the error
-        m_end    = pfils->m_end;
     }
 
-    delete pfils;
+    m_next.reset();
     return inst;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 CBotError CBotCStack::GetError(int& start, int& end)
 {
-    start = m_start;
+    start = m_errStart;
-    end      = m_end;
+    end = m_data->errEnd;
-    return m_error;
+    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;
+        if (p->m_bBlock) for (auto& var : p->m_listVar)
-        while ( pp != nullptr)
         {
-            if (name == pp->GetName())
+            if (name == var->GetName()) return var.get();
-            {
-                return pp;
-            }
-            pp = pp->m_next;
         }
         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
+    if (m_data->error != CBotNoErr) return; // does not change existing error
-    m_start = pos;
+    m_errStart = pos;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetError(CBotError n, int pos)
 {
-    if ( n!= 0 && m_error != 0) return;    // does not change existing error
+    if (n != CBotNoErr && m_data->error != CBotNoErr) return; // does not change existing error
-    m_error = n;
+    m_data->error = n;
-    m_end    = pos;
+    m_data->errEnd = pos;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::SetError(CBotError n, CBotToken* p)
 {
-    if (m_error) return;    // does not change existing error
+    if (m_data->error != CBotNoErr) return; // does not change existing error
-    m_error = n;
+    m_data->error = n;
-    m_start    = p->GetStart();
+    m_errStart = p->GetStart();
-    m_end    = p->GetEnd();
+    m_data->errEnd = p->GetEnd();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void CBotCStack::ResetError(CBotError n, int start, int end)
 {
-    m_error = n;
+    m_data->error = n;
-    m_start    = start;
+    m_errStart = start;
-    m_end    = end;
+    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.reset(var);
-    m_var = 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;
+    p->m_listVar.emplace_back(pVar);
-    while ( *pp != nullptr ) pp = &(*pp)->m_next;
+}
 
-    *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;
+        if (name == var->GetName()) return true;
-        while ( pp != nullptr)
-        {
-            if (name == pp->GetName())
-                return true;
-            pp = pp->m_next;
-        }
-        if ( p->m_bBlock ) return false;
-        p = p->m_prev;
     }
     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

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 pToken Token representing the name of a function.
-     * \param pParam
+     * \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;
+    int m_errStart = 0;
-    static int m_end;
+
-    int m_start;
+    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;
+    std::list<std::unique_ptr<CBotVar>> m_listVar;
-    //! List of compiled functions.
-    static CBotProgram* m_prog;
-    static CBotTypResult m_retTyp;
 };
 
 } // namespace CBot

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;
+                    pStack->DeleteNext();
-                    std::list<CBotFunction*>::iterator pfIter = std::find_if(m_pMethod.begin(), m_pMethod.end(), [&pp, &params](CBotFunction* x)
+                    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();

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

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];
+        std::array<char, 20> buffer;
-        sprintf(buffer, "instr%d", instructions[ptr]);
+        snprintf(buffer.data(), buffer.size(), "instr%d", instructions[ptr]);
-        return std::string(buffer);
+        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;");
+        replaceAll(data, "&", "&amp;");
-        boost::algorithm::replace_all(data, "<", "&lt;");
+        replaceAll(data, "<", "&lt;");
-        boost::algorithm::replace_all(data, ">", "&gt;");
+        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")

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

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; // end of arguments found
-
+            if (p->m_expr != nullptr) // has default expression ?
-            useDefault = true;
+            {
-
+                if (!p->m_expr->Execute(pile)) return false; // interupt here
-            if (!p->m_expr->Execute(pile)) return false; // interupt here
+                pVar = pile->GetVar();
-
+            }
-            pVar = pile->GetVar();
         }
         else
             pVar = ppVars[i];

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

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

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,

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;
+    if (thisVar == nullptr && pStack->IsCallFinished()) return true;  // only for non-method external call
-    CBotStack* pile = pStack->AddStackExternalCall(pt);
 
-    // lists the parameters depending on the contents of the stack (pStackVar)
+    // if this is a method call we need to use AddStack()
-    CBotVar* pVar = MakeListVars(ppVar, true);
+    CBotStack* pile = (thisVar != nullptr) ? pStack->AddStack() : pStack->AddStackExternalCall(pt);
 
-    // creates a variable to the result
+    if (pile->GetState() == 0) // the first time?
-    CBotVar* pResult = rettype.Eq(CBotTypVoid) ? nullptr : CBotVar::Create("", rettype);
+    {
+        // 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();
-
+        // creates a variable to the result
-    CBotStack* pile2 = pile->AddStack();
+        CBotVar* pResult = rettype.Eq(CBotTypVoid) ? nullptr : CBotVar::Create("", rettype);
-    pile2->SetVar(pResult);
+        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;
+    assert(thisVar != nullptr);
-    CBotStack* pile = pStack->AddStackExternalCall(this);
+    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

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

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;
 }

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>
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
 {
 

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
 }

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

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

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

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

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();
 
     /*!

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
 {
 

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

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

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

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

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

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

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

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));
         }
 

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

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

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

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

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

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) )
+        if (IsOfType(p, ID_PRIVATE)) break;
-        {
+        if (IsOfType(p, ID_PROTECTED)) break;
-            func->m_bPublic = true;
+        if (IsOfType(p, ID_PUBLIC)) continue;
-            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
+                    CBotClass* pClass = CBotClass::Find(func->m_MasterClass);
-                    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);
 
-                    // initialize variables acording to This
+                    pStk->CreateVarThis(pClass);
-                    // only saves the pointer to the first,
+                    pStk->CreateVarSuper(pClass->GetParent());
-                    // the rest is chained
+
-                    CBotVar* pv = pThis->GetItemList();
+                    bool bConstructor = (func->GetName() == func->m_MasterClass);
-//                  int num = 1;
+                    pStk->CreateMemberVars(pClass, !bConstructor);
-                    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();
-                    }
                 }
 
                 // 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
+            pPriv = p;
-            continue;
+            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)
 {

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,
+    static CBotTypResult CompileCall(const std::string &name, CBotVar** ppVars,
-                                     const std::string &name, CBotVar** ppVars, long &nIdent);
+                                     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

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

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

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

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

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);

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]

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?

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

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;
     }

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

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;
         }
     }

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

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

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

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

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

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

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

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

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

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

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

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

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

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?