8.0.0

.gitignore

@@ -37,17 +37,29 @@
 version-*
 JLink*.*
 
-cert/
+include/qs.hpp
+include/qs_pkg.hpp
+include/qxk.hpp
+src/qs/qs.cpp
+src/qs/qs_64bit.cpp
+src/qs/qs_fp.cpp
+src/qs/qs_rx.cpp
+src/qs/qutest.cpp
+src/qxk/qxk.cpp
+src/qxk/qxk_mutex.cpp
+src/qxk/qxk_sema.cpp
+src/qxk/qxk_xthr.cpp
+
+ports/posix-qutest/
+ports/win32-qutest/
+
+priv/
 html/
 latex/
-doxygen/gen/
-test_priv/
 dbg/
 rel/
 spy/
-build/
-build_rel/
-build_spy/
+build*/
 settings/
 .settings/
 targetConfigs/

LICENSES/License.txt

@@ -3,8 +3,8 @@ Quantum Leaps Dual-Licensing:
 The QP/C Real-Time Embedded Framework is dually-licensed under
 the following two alternatives:
 
-1. Open source GNU General Public License (GPL)
-version 3, or alternatively,
+1. Open source GNU General Public License (GPL) version 3,
+   or alternatively,
 
 2. One of the closed source Quantum Leaps commercial licenses.
 

LICENSES/LicenseRef-QL-dual.qlc

@@ -1,30 +1,28 @@
-Any user of the QP/C++ real-time embedded framework
+public
 qpcpp
 2025-12-31
-
-Copyright (C) 2005 Quantum Leaps, LLC <state-machine.com>.
+Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.
 
                    Q u a n t u m  L e a P s
                    ------------------------
                    Modern Embedded Software
 
 SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
 
-This software is dual-licensed under the terms of the open source GNU
-General Public License version 3 (or any later version), or alternatively,
-under the terms of one of the closed source Quantum Leaps commercial
-licenses.
-
-The terms of the open source GNU General Public License version 3
-can be found at: <www.gnu.org/licenses/gpl-3.0>
-
-The terms of the closed source Quantum Leaps commercial licenses
-can be found at: <www.state-machine.com/licensing>
+The QP/C++ software is dual-licensed under the terms of the open-source
+GNU General Public License (GPL) or under the terms of one of the closed-
+source Quantum Leaps commercial licenses.
 
 Redistributions in source code must retain this top-level comment block.
 Plagiarizing this software to sidestep the license obligations is illegal.
 
-Contact information:
+NOTE:
+The GPL does NOT permit the incorporation of this code into proprietary
+programs. Please contact Quantum Leaps for commercial licensing options,
+which expressly supersede the GPL and are designed explicitly for
+closed-source distribution.
+
+Quantum Leaps contact information:
 <www.state-machine.com/licensing>
 <[email protected]>
-#CEF384A62BD9270573AA82386A5BE6F6E36AD848
+#48B37CF39D4FD9DE279250B31FD388AFD0BE9B40

README.md

@@ -34,15 +34,15 @@ provides instructions on how to download, install, and get started with QP.
 - [AppNote: "Getting Started with QP Real-Time Embedded Frameworks"][AN]
 contains also a tutorial, in which you build a simple "Blinky" application.
 
-## Licensing
-The QP frameworks (QP/C and QP/C++) are licensed under the
+# Licensing
+The QP/C++ real-time embedded framework is licensed under the
 [dual licensing model](https://www.state-machine.com/licensing), with
 the following licensing options:
 
 1. [Open-source licensing](https://www.state-machine.com/licensing#Open) under the
 [GNU General Public License (GPLv3)](https://www.gnu.org/licenses/gpl-3.0.en.html).
 
-> NOTE: GPL requires that all modifications to the original code
+> NOTE: The GPL requires that all modifications to the original code
 as well as your application code (Derivative Works as defined in the
 Copyright Law) must also be released under the terms of the GPL
 open source license.
@@ -56,13 +56,26 @@ proprietary status of their code.
 all QP frameworks can be licensed commercially, in which case you don't use
 any open source license and you do not violate your policy.
 
+## Files Removed from the QP/C++ Open Source GPL Distribution
+Due to the widespread non-compliance with the GPL, as well as infringement on the
+[dual-licensing model of QP frameworks][Lic], the following QP/C++ components
+have been **removed from the open-source GPL distribution**:
+- QS target-resident software tracing component
+- QXK dual-mode kernel
+
+> NOTE: These components are available to the [commercial licensees][Cust] with
+the active Support Term. Please contact [Quantum Leaps technical support][Sup]
+to get the complete QP/C++ framework distribution.
+
+> NOTE: To request **evaluation** of the complete QP/C++ framework, please contact
+Quantum Leaps at: https://www.state-machine.com/contact
 
 # About QP/C++
 QP/C++ (Quantum Platform in C++) is a lightweight, open source
 [Real-Time Embedded Framework (RTEF)][RTEF] for building modern embedded
 software as systems of asynchronous, event-driven [Active Objects][Active]
 (actors). The [QP/C++] framework is a member of a [QP] family consisting of
-[QP/C] and [QP/C++] frameworks, which are strictly quality controlled,
+[QP/C++] and [QP/C] frameworks, which are strictly quality controlled,
 thoroughly documented, and [commercially licensable][Lic].
 
 ## Safer Model of Concurrency
@@ -103,7 +116,7 @@ without any traditional RTOS. The framework contains a selection of
 the [preemptive non-blocking QK kernel][QK], and the preemptive,
 [dual-mode QXK kernel][QXK] that provides all the features you might expect
 from a traditional RTOS. Native QP ports and ready-to-use examples are provided
-for major CPUs, such as ARM Cortex-M (M0/M0+/M3/M4/M7/M23/M33/M85).
+for major CPUs, such as ARM Cortex-M (M0/M0+/M3/M4/M7/M23/M33/...).
 
 ## Traditional RTOS/OS
 QP/C++ can also work with a traditional RTOS, such as ThreadX, embOS, FreeRTOS,
@@ -138,12 +151,18 @@ in your web browser.
 # How to Help this Project?
 If you like this project, please give it a star (in the upper-right corner of your browser window):
 
-![GitHub star](https://www.state-machine.com/img/github-star.jpg)
+<p align="center">
+<img src="https://www.state-machine.com/img/github-star.jpg"/><br>
+</p>
 
    [RTEF]:   <https://www.state-machine.com/rtef>
    [QP]:     <https://www.state-machine.com/products/qp>
    [QP/C]:   <https://github.com/QuantumLeaps/qpc>
    [QP/C++]: <https://github.com/QuantumLeaps/qpcpp>
+   [QS/C++]: <https://www.state-machine.com/qpcpp/srs-qp_qs.html>
+   [QV]:     <https://www.state-machine.com/qpcpp/srs-qp_qv.html>
+   [QK]:     <https://www.state-machine.com/qpcpp/srs-qp_qk.html>
+   [QXK]:    <https://www.state-machine.com/qpcpp/srs-qp_qxk.html>
    [QM]:     <https://github.com/QuantumLeaps/qm>
    [QTools]: <https://github.com/QuantumLeaps/qtools>
    [QP-Rel]: <https://github.com/QuantumLeaps/qpcpp/releases>
@@ -153,6 +172,7 @@ If you like this project, please give it a star (in the upper-right corner of yo
    [HSM]:    <https://www.state-machine.com/qpcpp/srs-qp_sm.html>
    [Lic]:    <https://www.state-machine.com/licensing>
    [Cust]:   <https://www.state-machine.com/customers>
+   [Sup]:    <mailto:[email protected]>
    [AN]:     <https://www.state-machine.com/doc/AN_Getting_Started_with_QP.pdf>
    [Tutorial]: <https://www.state-machine.com/qpcpp/gs_tut.html>
    [Video]:  <https://youtu.be/O7ER6_VqIH0>

cmakeSupport.md

@@ -38,6 +38,10 @@ set(QPCPP_PROJECT qpcPrj)
 set(QPCPP_CFG_KERNEL QV)
 set(QPCPP_CFG_GUI TRUE)
 set(QPCPP_CFG_PORT win32)
+# QP/CPP 8.0.0: to include a local 'qp_config.hpp' add the related include path
+# to the qpcpp build settings. Replace "${CMAKE_CURRENT_LIST_DIR}/include" by
+# your project specific path!
+set(QPCPP_CFG_QPCONFIG_H_INCLUDE_PATH ${CMAKE_CURRENT_LIST_DIR}/include)
 qpcpp_sdk_init()
 
 target_link_libraries(qpcppApp PRIVATE qpcpp)
@@ -78,6 +82,9 @@ This file is situated in the root directory of qpcpp. It performs a pre-initiali
 * `QPCPP-CFG-GUI` - BOOL: set this Boolean variable to ON/TRUE, if GUI support (win32) shall be compiled in. Default: OFF
 * `QPCPP_CFG_UNIT_TEST` - BOOL: set this to ON/TRUE to support qutest, if build configuration `Spy` is active. Default: OFF
 * `QPCPP_CFG_VERBOSE` - BOOL: set this to enable more verbosity in message output. Default: OFF
+* `QPCPP_CFG_QPCONFIG_H_INCLUDE_PATH`: - STRING (PATH): (`QP/CPP 8.0.0`) set this to have the build of QP/CPP use your project specific `qp_config.hpp`.
+  Default: `${QPCPP_SDK_PATH}/ports/config`
+
 
 ### General usage hints
 1. Set `QPCPP_SDK_PATH` or `QPCPP_FETCH_FROM_GIT` either in your `CMakeLists.txt` file or as an environment variable.
@@ -87,7 +94,7 @@ This file is situated in the root directory of qpcpp. It performs a pre-initiali
 5. Define the cmake target (executable or library)
 6. Include `qpcpp_sdk_init.cmake`
 7. configure the qpc SDK
-8. call `qpcpp_sdk_init`
+8. call `qpcpp_sdk_init()`
 9. Add the qpcpp library to your cmake target:
    `target_link_libraries(<target>> PRIVATE qpcpp)`
 
@@ -102,53 +109,23 @@ Generate and build your cmake project
   Refer to the [CMakePresets.json manual](https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html) for further details.
   Then you generate with `cmake --preset=<preset> .` from your project directory. The build then can be started with `cmake --build --preset=<preset>`.
 
-### QPC configurations support
+### QPCPP configurations support
 Many `qpcpp` examples provide 3 build configurations:
 * `Debug` - build with debug support and debug symbols. Most optimizations are turned off
 * `Release` - build without debug support. Activate optimizations instead
 * `Spy` - build like `Debug`. Additionally activate support for `QSpy`.
 
 These configurations are also supported by qpcpp with cmake. Different possibilities exist to activate those.
 
-### `qp_config.h` support
-Some build configurations require the inclusion of `qp_config.h`. To achieve this, the QPC macro `QP_CONFIG` should be set, when compiling the
-`qpcpp` source files. The include search paths also needs to be set accordingly in order for the preprocessor to be able to find the correct include
-file.
+### `qp_config.hpp` support
+With the release of QP/C++ V8.0.0 the inclusion of `qp_config.hpp` is mandatory.
+The `cmake` build system of qpc addresses this by providing the configuration variable `QPCPP_CFG_QPCONFIG_H_INCLUDE_PATH`. Set this to the path of your local project's `qp_config.hpp` and this will automatically be found by the build system. Do this in your main `CMakeLists.txt` file __before__ calling `qpcpp_sdk_init()`.
 
-As `qp_config.hpp` is a project related file, which - in most cases - resides outside the `qpcpp` source code tree, the decision is to handle the
-above mentioned topic within the root project's `CMakeLists.txt` file instead of integrating this topic into a rather complicated configuration
-of `qpcpp` itself.
+You do not need to set this variable, should the qpcpp default settings be sufficient for your project. In this case the build system uses the `qp_config.hpp` file, as it can be found in the directory `${QPCPP_SDK_PATH}/src/ports/config`.
 
 An example can be found in the [cmake dpp example](https://github.com/QuantumLeaps/qpcpp-examples/tree/main/posix-win32-cmake/dpp). Have a look into
 the example's [CMakeLists.txt](https://github.com/QuantumLeaps/qpcpp-examples/blob/main/posix-win32-cmake/dpp/CMakeLists.txt).
 
-You will find the reference to the `qpc` library, followed by the project's specific setup for `qp_config.h` like this:
-```
-# set up qpcpp library
-target_link_libraries(dpp
-    PRIVATE
-        qpcpp
-)
-# should a 'qp_config.h' configuration file be used and is it available
-# edit the HINTS in the 'find_file()' call according to your project settings
-if(USE_QP_CONFIG)
-    find_file(QP_CONFIG qp_config.h HINTS ${CMAKE_CURRENT_SOURCE_DIR}) # try to identify 'qp_config.h'
-    if(QP_CONFIG) # found 'qp_config.h'
-        cmake_path(GET QP_CONFIG PARENT_PATH QP_CONFIG_DIR) # extract the path from the FQFN
-        target_compile_definitions(qpcpp # add -DQP_CONFIG to the qpcpp build
-            PUBLIC
-                QP_CONFIG
-        )
-        target_include_directories(qpcpp # add the path to 'qp_config.h' to the list of include paths for qpcpp
-            PUBLIC
-                ${QP_CONFIG_DIR}
-        )
-    else() # 'qp_config.h' requested but not find - try to configure and build anyways
-        message(WARNING "File 'qp_config.h' not found!")
-    endif()
-endif()
-```
-
 ### Multi configuration generators
 The most easy way to make use of the different configurations is to use a multi config generator like `Ninja Multi-Config` or `MS Visual Studio`.
 Using one of such generators enables to generate the build system using `cmake` and afterwards simply selecting the desired build configuration like

include/README.md

@@ -0,0 +1,45 @@
+# Files Missing from the QP/C++ GPL Distribution
+Due to the widespread non-compliance with the GPL, as well as infringement
+on the [dual-licensing model of QP frameworks][Lic], the following files
+have been **removed from the open-source GPL distribution**:
+
+```
+qpcpp
+|
++---include
+|       qs.hpp
+|       qs_pkg.hpp
+|       qxk.hpp
+|
+\---src
+    |
+    +---qs
+    |       qs.cpp
+    |       qs_64bit.cpp
+    |       qs_fp.cpp
+    |       qs_rx.cpp
+    |       qutest.cpp
+    |
+    \---qxk
+            qxk.cpp
+            qxk_mutex.cpp
+            qxk_sema.cpp
+            qxk_xthr.cpp
+```
+
+> NOTE: These files are available to the [commercial licensees][Cust] with
+the active Support Term. Please contact [Quantum Leaps technical support][Sup]
+to get the complete QP/C++ framework distribution.
+
+# QP/C++ Framework Evaluation
+To request **evaluation** of the complete QP/C++ framework, please contact
+Quantum Leaps at:
+- https://www.state-machine.com/contact
+
+# Quantum Leaps Licensing:
+To learn more about the open source and commercial licensing options:
+- https://www.state-machine.com/licensing
+
+   [Lic]:    <https://www.state-machine.com/licensing>
+   [Cust]:   <https://www.state-machine.com/customers>
+   [Sup]:    <mailto:[email protected]>