GATE Framework

The GATE project is a private C library framework including a C++ high level layer to reclaim and preserve C and C++ software technologies from classic desktop application development and to unite it with modern target platforms.
It is also an interface study to test the integration of modern coding patterns into elder compilers and to find advantages and limits of direct bindings to platform specific APIs.

History

I have worked for several companies during the last 20 years as a software developer and did implement services and user interfaces running in different environments.
Frameworks have changed with the arrival of mobile devices and desktop machines are not the focus of software development anymore.
Documentation regarding classic coding is already vanishing from the internet due to company dissolutions and closed websites.

On the other hand we see divergent ABIs in different compilers on the same platform which brings barriers between software components. Especially C++ codes suffer from disagreement about what technology should be standard and what is removed from it.

Mission

The C programming language as the only light weighted utility to write code for every platform and to be consistent regarding code composition and binary compatibility.
We need to wrap platform details into stable C-function interfaces and utilize any other programming language with them to implement high-level easy-to-use application code.

The GATE project is:

• a C library (C90) to wrap platform details into a generic platform-independent interface.
• compatible with a great amount of current and ancient C compilers.
• specialized to run with different OS variants from the past 30 years.
• supporting static or dynamic (shared library) bindings.
• based on free open-source algorithms and public domain knowledge.
• bringing modern concepts (shared pointers, delegates, etc.) into the C world.

The GATE project is also (or will be):

• a thin C++03 wrapper library based on C based GATE code (without STL requirements).
• compatible with newer C++ language features when they are available (C++11).
• able to run with or without C++ exception semantics.
• a host for LUA and Python code execution.
• a collection of demo applications showing text, UI, 2D and 3D programming.

Building GATE code

The GATE framework was developed with CMAKE as its primary build environment generator. Meanwhile also CONAN and XMAKE are supported.

Prepare build environment

1. Clone the GATE project
   • git clone https://codeberg.org/GateNetwork/gate.git
   • cd gate
2. Run setup script for your host environment in the /scripts folder
   • cd scripts
   • sudo ./setup-debian.sh

Dependencies

The GATE project does not implement complex compression and encryption algorithms. Therefore those features are coming from external open source libraries.

External library dependencies

• ZLIB: GZ compression
• MINIZIP: ZIP compression
• BZIP2: BZ2 compression
• LZMA: XZ compression
• LIBJPEG: JPEG image file format
• GIFLIB: GIF image file format
• LIBPNG: PNG image file format
• OPENSSL: SSL/TLS communication and encryption
• LIBSSH2: SSH communication protocol
• LUA: The LUA scripting language
• QUIRC: QR code scanner
• LIBDMTX: Datamatrix code scanner

Initialize exlibs submodule

CMake builds require external libraries from the extlibs repository. Run following commands in the project'S root folder:

• git submodule init
• git submodule update

Target platform builds

Supported platforms

• Windows (WinAPI)
  • All MSVC compilers since 2003, MinGW, TinyCC, LLVM.
  • Windows NT 6+ (Vista to 11, Server 2008 to 2022)
    • All features are implemented.
  • Windows NT4 to XP/Server 2003
    • Some NT6+ features are not available or replaced by fallbacks.
  • Windows 95-ME
    • Only basic functionality is provided.
  • Windows 3.1 16 bit
    • Only some UI and graphics demos will be available.
• Universal Windows Platform
  • MSVC compilers since 2017.
  • Experimental support for UWP 10.
  • 2D and 3D graphics (DirectX) are supported.
• Windows CE 5.0 (ARMv4)
  • MSVC 2005 compiler.
  • An intersecting set with NT APIs is provided including some special implementations only available on Windows CE 5/Windows Mobile 6.x.
• POSIX
  • All GCC compilers since 4.8, TinyCC, LLVM
  • Generic POSIX platform features are covered.
  • X11 UI support on all POSIX platforms is available.
• Linux
  • All features are implemented
  • ProcFS and SysFS are improving the generic POSIX support.
• BSD
  • Some special FreeBSD, OpenBSD and NetBSD implementations are improving the generic POSIX support.
• Android
  • 2D and 3D graphics (OpenGL) are supported.
• DOS
  • Text mode and 2D graphics (Mode 13) apps are supported.
• EFI (x64)
  • Text mode and 2D graphics (GOP) apps are supported.
• WASM Emscripten Webassembly
  • Experimental support for libraries, possibly 2D/3D graphics.
• Arduino
  • Experimental support for Arduino-compatible micro controllers

Build with CONAN

1. Install Python and use PIP to install CONAN
   • pip install conan
2. Go to scripts directory
   • cd scripts
3. Setup CONAN default profile and settings by conan setup script:
   • ./setup-conan.sh
4. Run the conan build script from the /scripts folder
   • ./build-conan.sh
5. Find generated binaries in
   • /build/conan/deploy/bin

Build with CMAKE

• Generic standard platform (CMake)
  1. Run generic build script:
     • ./build.sh
  2. Find generated binaries in
     • /build/cmake/deploy/bin
• Linux (GCC) or BSD (Clang) via MAKE
  1. Go to scripts directory
     • cd scripts
  2. Run make build script
     • ./build-make.sh
  3. Find generated binaries in
     • /build/make/deploy/bin
• Windows (MSVC 2015+) via MSBUILD
  1. Go to scripts directory
     • cd scripts
  2. Run the desired target output script (win32/win64/arm32/arm64)
     • build-msbuild_win64.bat
  3. Find generated binaries in
     • \build\msbuild_win64\deploy\bin
• DOS (WATCOM)
  1. Go to scripts directory
     • cd scripts
  2. Run the WMAKE build script
     • build-wmake_dos.bat
     • ./build-wmake_dos.sh
  3. Find generated binaries in
     • \build\wmake_dos\deploy\bin
• WASM (Emscripten)
  1. Go to scripts directory
     • cd scripts
  2. Run the WASM build script
     • build-wasm.bat
     • ./build-wasm.sh
  3. Find generated binaries in
     • \build\wasm\deploy\bin

Build Arduino based microcontroller targets

1. Go to scripts directory
   • cd scripts
2. Run the build script of the desired MCU target
   • ./build-avr_atmega328p.sh
3. Find generated binaries in
   • /build/avr_atmega328p/deploy/bin
4. Upload .hex file to Arduino board with avrdude
   • avrdude -v -patmega328p -carduino -P /dev/ttyUSB0 -b115200 -D -Uflash:w:myproject.hex:i