Kicking it Olde Sküül! Burgerlib on Github Follow Olde Sküül on Twitter Burgerbecky on LinkedIn Burgerbecky on LinkedIn
Loading...
Searching...
No Matches
Macros
brtypes.cpp File Reference

Macros

#define _DEBUG
 Defined to enable the creation of debug code.
 
#define NDEBUG
 Defined to disable the creation of debug code.
 
#define BURGER_WATCOM   __WATCOMC__
 Define to determine if code is being built using Open Watcom compilers.
 
#define BURGER_MRC   __MRC__
 Define to determine if code is being built using Apple/Motorola MrC compiler.
 
#define BURGER_APPLE_SC   __SC__
 Define to determine if code is being built using Apple/Motorola SC compiler.
 
#define BURGER_BORLAND   __BORLANDC__
 Define to determine if code is being built using the Borland C compiler.
 
#define BURGER_DJGPP   ((__DJGPP__ * 100) + __DJGPP_MINOR__)
 Define to determine if code is being built using DJGPP compiler.
 
#define BURGER_SNSYSTEMS   __SN_VER__
 Define to determine if code is being built using Green Hills compiler.
 
#define BURGER_GHS   __GHS_VERSION_NUMBER
 Define to determine if code is being built using SN Systems compiler.
 
#define BURGER_INTEL_COMPILER    ((__INTEL_COMPILER * 10) + __INTEL_COMPILER_UPDATE)
 Define to determine if code is being built using Intel compiler.
 
#define BURGER_MINGW
 Define to determine if code is being built using MinGW compilers.
 
#define BURGER_CLANG    ((__clang_major__ * 10000) + (__clang_minor__ * 100) + __clang_patchlevel__)
 Define to determine if code is being built using the clang compiler.
 
#define BURGER_GNUC    ((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__)
 Define to determine if code is being built using the GNU C family of compilers.
 
#define BURGER_METROWERKS   __MWERKS__
 Define to determine if code is being built using Freescale/Metrowerks family of compilers.
 
#define BURGER_ARM_COMPILER   __ARMCC_VERSION
 Define to determine if code is being built using Advanced RISC Machines family of compilers.
 
#define BURGER_MSVC   _MSC_FULL_VER
 Define to determine if code is being built using Microsoft Visual C family of compilers.
 
#define BURGER_COMPILER_NAME   "The name of the compiler"
 String of the name of the C++ compiler.
 
#define BURGER_COMPILER_VERSION   1234
 Integer of the version of the current compiler.
 
#define BURGER_X86
 Define to determine if code is being built for 32 bit Intel processors.
 
#define BURGER_AMD64
 Define to determine if code is being built for AMD64 (Intel 64 bit) compatible processors.
 
#define BURGER_ITANIUM
 Define to determine if code is being built for Intel Itanium compatible processors.
 
#define BURGER_ARM32
 Define to determine if code is being built for 32 bit Advanced RISC Machine processors.
 
#define BURGER_ARM64
 Define to determine if code is being built for 64 bit Advanced RISC Machine processors.
 
#define BURGER_MIPS32
 Define to determine if code is being built for MIPS 32 bit processors.
 
#define BURGER_MIPS64
 Define to determine if code is being built for MIPS 64 bit processors.
 
#define BURGER_POWERPC
 Define to determine if code is being built for 32 bit PowerPC processors.
 
#define BURGER_POWERPC64
 Define to determine if code is being built for 64 bit PowerPC processors.
 
#define BURGER_68K
 Define to determine if code is being built for Motorola 680x0 processors.
 
#define BURGER_RISCV
 Define to determine if code is being built for 32 bit RISC-V processors.
 
#define BURGER_AVR
 Define to determine if code is being built for 32 bit Atmel AVR processors.
 
#define BURGER_MSP430
 Define to determine if code is being built for 16 bit MSP430 processors from Texas Instruments.
 
#define BURGER_SPARC32
 Define to determine if code is being built for 32 bit Sparc processors from Sun.
 
#define BURGER_SPARC64
 Define to determine if code is being built for 64 bit Sparc processors from Sun.
 
#define BURGER_NANOMIPS32
 Define to determine if code is being built for 32 bit nanoMIPS processors from Sun.
 
#define BURGER_SH32
 Define to determine if code is being built for 32 bit SuperH processors from HItachi.
 
#define BURGER_S390
 Define to determine if code is being built for 64 bit IBM System/390 processors.
 
#define BURGER_KVX
 Define to determine if code is being built for 32 bit Kalray KVX processor.
 
#define BURGER_CPU_NAME   "The name of the CPU"
 String of the name of the CPU.
 
#define BURGER_3DNOW
 Define to determine if code is being built for AMD 3D Now! instruction set extensions.
 
#define BURGER_XBOX
 Define to determine if code is being built for the Microsoft XBox.
 
#define BURGER_XBOX360
 Define to determine if code is being built for the Microsoft XBox 360.
 
#define BURGER_XBOXONE
 Define to determine if code is being built for the Microsoft XBox One.
 
#define BURGER_MSDOS
 Define to determine if code is being built for Microsoft MS-DOS.
 
#define BURGER_DOS4G
 Define to determine if MS-DOS code is being built with the DOS4G DOS extender.
 
#define BURGER_X32
 Define to determine if MS-DOS code is being built with the X32 DOS extender.
 
#define BURGER_WIN32
 Define to determine if code is being built for Microsoft 32 bit Windows.
 
#define BURGER_WIN64
 Define to determine if code is being built for Microsoft 64 bit Windows.
 
#define BURGER_PS1
 Define to determine if code is being built for the Sony Playstation.
 
#define BURGER_PS2
 Define to determine if code is being built for the Emotion Engine CPU for a PS2.
 
#define BURGER_PS3
 Define to determine if code is being built for the PS3.
 
#define BURGER_PS4
 Define to determine if code is being built for the PS4.
 
#define BURGER_PS5
 Define to determine if code is being built for the PS5.
 
#define BURGER_PSP
 Define to determine if code is being built for the Sony PSP.
 
#define BURGER_VITA
 Define to determine if code is being built for the Sony VITA.
 
#define BURGER_ANDROID
 Define to determine if code is being built for Google Android devices.
 
#define BURGER_STADIA
 Define to determine if code is being built for Google Stadia.
 
#define BURGER_SHIELD
 Define to determine if code is being built for nVidia SHIELD devices.
 
#define BURGER_OUYA
 Define to determine if code is being built for the OUYA.
 
#define BURGER_GBA
 Define to determine if code is being built for the Nintendo Gameboy Advanced.
 
#define BURGER_DS
 Define to determine if code is being built for the Nintendo DS.
 
#define BURGER_3DS
 Define to determine if code is being built for the Nintendo 3DS.
 
#define BURGER_GAMECUBE
 Define to determine if code is being built for the Nintendo GameCube.
 
#define BURGER_WII
 Define to determine if code is being built for the Nintendo Wii.
 
#define BURGER_WIIU
 Define to determine if code is being built for the Nintendo WiiU.
 
#define BURGER_SWITCH
 Define to determine if code is being built for the Nintendo Switch.
 
#define BURGER_BEOS
 Define to determine if code is being built for Be OS.
 
#define BURGER_SYMBIAN
 Define to determine if code is being built for the Symbian OS.
 
#define BURGER_NGAGE
 Define to determine if code is being built for the Nokia Ngage.
 
#define BURGER_AMIGA
 Define to determine if code is being built for the Commodore Amiga.
 
#define BURGER_MAC
 Define to determine if code is being built for Apple Mac OS 8.6 through 9.2.
 
#define BURGER_CFM
 Define to determine if Mac OS 9 code is being built in Code Fragment Manger format.
 
#define BURGER_MACCLASSIC
 Define to determine if code is being built exclusively for Apple Mac OS9.
 
#define BURGER_MACCARBON
 Define to determine if code is being built for both Apple Mac OS9 and MacOS X.
 
#define TARGET_API_MAC_CARBON   1
 Define to determine if Mac OS 9 code is being built with the Carbon libraries.
 
#define BURGER_IOS
 Define to determine if code is being built for Apple iOS devices.
 
#define BURGER_MACOSX
 Define to determine if code is being built exclusively for Apple Mac OS X.
 
#define BURGER_LINUX
 Define to determine if code is being built for Linux.
 
#define BURGER_ARDUINO
 
#define BURGER_STEAM
 Define for the presence of Valve's Steam platform.
 
#define BURGER_PLATFORM_NAME   "Name of operating system"
 String with the operating system's name.
 
#define BURGER_LITTLEENDIAN
 Define to flag code running on a little endian machine.
 
#define BURGER_FASTCALLENABLED
 Flag for determining Intel assembly generation.
 
#define BURGER_STRUCT_ALIGN
 Defined if the compiler uses Macintosh style data alignment commands.
 
#define BURGER_STRUCT_PACK
 Defined if the compiler uses GNU style data alignment commands.
 
#define BURGER_STRUCT_PACKPUSH
 Defined if the compiler uses Microsoft style data alignment commands.
 
#define BURGER_NO_ALIGN
 Per object alignment is not supported.
 
#define nullptr   0
 Defined to nothing if the feature is not available.
 
#define __underlying_type(x)   int
 Defined if __underlying_type is not available.
 
#define BURGER_INT_NOT_IN_STDINT
 Is int used in stdint.h.
 

Macro Definition Documentation

◆ __underlying_type

#define __underlying_type (   x)    int

Defined if __underlying_type is not available.


If the feature __underlying_type isn't supported by the compiler, this macro will be defined to int to allow code to compile on older compilers.

See also
BURGER_CPP11, nullptr or BURGER_CONSTEXPR

◆ _DEBUG

#define _DEBUG

Defined to enable the creation of debug code.


If this define exists, you can assume that you're compiling a debug build. This is used to flag whether debug code is to be included in the build and/or BURGER_ASSERT is to operate. Only _DEBUG or NDEBUG can exist at a time. Specifying both or neither is considered a fatal compile error. This define is not supplied by Burgerlib, it must be defined by the build project.

Note
This flag is not used to determine if optimizations have been disabled. It's only used to enable the generation of debugging code.
#if defined(_DEBUG)
CheckMemoryHeap();
#endif

◆ BURGER_3DNOW

#define BURGER_3DNOW

Define to determine if code is being built for AMD 3D Now! instruction set extensions.


If this define exists, then you are creating code that runs on the AMD line of processors with 3D Now! instructions.

Click here to read the 3D Now! instruction set

See also
BURGER_SSE, BURGER_SSE2, BURGER_AVX, BURGER_AVX2, BURGER_INTEL, BURGER_X86, or BURGER_AMD64

◆ BURGER_3DS

#define BURGER_3DS

Define to determine if code is being built for the Nintendo 3DS.


If this define exists, then you are creating code that runs on the Nintendo 3DS.

Note
In addition to defining NDEBUG or _DEBUG, you need to define SDK_DEBUG in your project if you wish for the Nintendo 3DS SDK to generate debugging information
See also
BURGER_ARM32, BURGER_DS or BURGER_GBA

◆ BURGER_68K

#define BURGER_68K

Define to determine if code is being built for Motorola 680x0 processors.


If this define exists, then you are creating code that runs on the Motorola 680x0 line of processors. The classic Macintosh and certain PDAs will have this define present.

See also
BURGER_CPU_NAME, BURGER_68881, BURGER_MAC or BURGER_CFM

◆ BURGER_AMD64

#define BURGER_AMD64

Define to determine if code is being built for AMD64 (Intel 64 bit) compatible processors.


If this define exists, then you are creating code that runs on the AMD 64 and other compatible processors. The Microsoft Win64 and Mac OSX 64 platforms which are running on Pentium and AMD CPUs in 64 bit mode will have this define present.

See also
BURGER_CPU_NAME, BURGER_INTEL, BURGER_WIN64, BURGER_MACOSX, BURGER_XBOXONE, BURGER_PS4, BURGER_PS5, or BURGER_X86

◆ BURGER_AMIGA

#define BURGER_AMIGA

Define to determine if code is being built for the Commodore Amiga.


If this define exists, then you are creating code that runs on the Amiga for 68K or PowerPC.

See also
BURGER_POWERPC or BURGER_68K

◆ BURGER_ANDROID

#define BURGER_ANDROID

Define to determine if code is being built for Google Android devices.


If this define exists, then you are creating code that runs on Google Android devices.

See also
BURGER_IOS, BURGER_SHIELD, BURGER_OUYA, BURGER_ARM32 or BURGER_MACOSX

◆ BURGER_APPLE_SC

#define BURGER_APPLE_SC   __SC__

Define to determine if code is being built using Apple/Motorola SC compiler.


If this define exists, then you are creating code with the [Apple SC compiler] (https://staticky.com/mirrors/ftp.apple.com/developer/Tool_Chest/Core_Mac_OS_Tools/MPW_Website_Downloads/ "Apple SC Compiler download page")

Known issues with the Apple SC compiler.

  1. Templates are poorly supported. Do not use templates.
See also
BURGER_GNUC, BURGER_METROWERKS, BURGER_MRC and BURGER_68K

◆ BURGER_ARDUINO

#define BURGER_ARDUINO

◆ BURGER_ARM32

#define BURGER_ARM32

Define to determine if code is being built for 32 bit Advanced RISC Machine processors.


If this define exists, then you are creating code that runs on the Advanced RISC Machines 32 bit line of processors. The Gameboy Advanced, Nintendo DS, Nokia NGage, Apple iPad/iPhone/iPod and certain cell phones will have this define present.

See also
BURGER_CPU_NAME, BURGER_ARM64, BURGER_ARM, BURGER_GBA, BURGER_ANDROID, BURGER_SHIELD, BURGER_OUYA, BURGER_DS, BURGER_3DS, BURGER_IOS, BURGER_NGAGE, or BURGER_SYMBIAN

◆ BURGER_ARM64

#define BURGER_ARM64

Define to determine if code is being built for 64 bit Advanced RISC Machine processors.


If this define exists, then you are creating code that runs on the Advanced RISC Machines 64 bit line of processors. Apple iPad/iPhone/iPod and certain cell phones will have this define present.

See also
BURGER_CPU_NAME, BURGER_ARM32, BURGER_ARM, BURGER_ANDROID or BURGER_IOS

◆ BURGER_ARM_COMPILER

#define BURGER_ARM_COMPILER   __ARMCC_VERSION

Define to determine if code is being built using Advanced RISC Machines family of compilers.


If this define exists, then you are creating code with the [ARM compiler] (https://developer.arm.com/products/software-development-tools/compilers/arm-compiler")

See also
BURGER_MRC, BURGER_POWERPC, BURGER_MIPS32 and BURGER_X86

◆ BURGER_AVR

#define BURGER_AVR

Define to determine if code is being built for 32 bit Atmel AVR processors.


If this define exists, then you are creating code that runs on the Atmel AVR line of processors. Micro controllers will have this define present.

See also
BURGER_CPU_NAME, BURGER_ARM64, BURGER_ARM32 or BURGER_RISCV

◆ BURGER_BEOS

#define BURGER_BEOS

Define to determine if code is being built for Be OS.


If this define exists, then you are creating code that runs on Be OS for Intel or PowerPC.

See also
BURGER_POWERPC or BURGER_X86

◆ BURGER_BORLAND

#define BURGER_BORLAND   __BORLANDC__

Define to determine if code is being built using the Borland C compiler.


If this define exists, then you are creating code with the [Borland C compiler] (https://www.embarcadero.com/free-tools/ccompiler "Borland C free version download")

See also
BURGER_MSDOS, or BURGER_X86

◆ BURGER_CFM

#define BURGER_CFM

Define to determine if Mac OS 9 code is being built in Code Fragment Manger format.


If this define exists, then you are creating code in which the final binary is in PEF format for use with the Code Fragment Manager. All Power PC code for Classic or Carbon is in this format and 68k also can be compiled this way.

Note
To be able to use DrawSprocket in 68k code, you must build your application using CFM. The classic format can't link to DrawSprocket 68k.
Power PC code can be built in Mach-O format, but if that is the case, then the code can only run in Mac OS X.
See also
BURGER_MAC, BURGER_68K or BURGER_MACOSX

◆ BURGER_CLANG

#define BURGER_CLANG    ((__clang_major__ * 10000) + (__clang_minor__ * 100) + __clang_patchlevel__)

Define to determine if code is being built using the clang compiler.


If this define exists, then you are creating code with the [clang compiler] (https://clang.llvm.org/ "Clang home page")

See also
BURGER_GNUC, BURGER_METROWERKS, BURGER_POWERPC, BURGER_ARM32, BURGER_AMD64 and BURGER_X86

◆ BURGER_COMPILER_NAME

#define BURGER_COMPILER_NAME   "The name of the compiler"

String of the name of the C++ compiler.


This define is of a string naming the compiler.

See also
BURGER_COMPILER_VERSION, BURGER_INTEL_COMPILER, BURGER_MSVC, BURGER_WATCOM, BURGER_CLANG, BURGER_GNUC, or BURGER_METROWERKS

◆ BURGER_COMPILER_VERSION

#define BURGER_COMPILER_VERSION   1234

Integer of the version of the current compiler.


This define is of an integer for the version of the compiler.

The value is compiler specific, and must be checked for the specific compiler before testing this number against a constant.

See also
BURGER_COMPILER_NAME, BURGER_INTEL_COMPILER, BURGER_MSVC, BURGER_WATCOM, BURGER_CLANG, BURGER_GNUC, or BURGER_METROWERKS

◆ BURGER_CPU_NAME

#define BURGER_CPU_NAME   "The name of the CPU"

String of the name of the CPU.


"C" string of the name of the CPU.

See also
BURGER_X86, BURGER_AMD64, BURGER_ARM32, or BURGER_SPARC32

◆ BURGER_DJGPP

#define BURGER_DJGPP   ((__DJGPP__ * 100) + __DJGPP_MINOR__)

Define to determine if code is being built using DJGPP compiler.


If this define exists, then you are creating code with the [DJGPP compiler] (http://www.delorie.com/djgpp/ "DJGPP Compiler home page")

See also
BURGER_MSDOS, or BURGER_X86

◆ BURGER_DOS4G

#define BURGER_DOS4G

Define to determine if MS-DOS code is being built with the DOS4G DOS extender.


If this define exists, then you are creating code that runs under classic MS-DOS with the DOS4G DOS extender.

This define is declared by the project, not by Burgerlib. Either BURGER_DOS4G or BURGER_X32 must be present.

See also
BURGER_MSDOS or BURGER_X32

◆ BURGER_DS

#define BURGER_DS

Define to determine if code is being built for the Nintendo DS.


If this define exists, then you are creating code that runs on the Nintendo DS.

Note
In addition to defining NDEBUG or _DEBUG, you need to define SDK_DEBUG in your project if you wish for the Nintendo DS SDK to generate debugging information
See also
BURGER_ARM32, BURGER_3DS or BURGER_GBA

◆ BURGER_FASTCALLENABLED

#define BURGER_FASTCALLENABLED

Flag for determining Intel assembly generation.


This flag is defined only if the target platform is Intel and the parameter passing is in the "__fastcall" format.

Some targets require parameters to be passed in the __cdecl format, so this will allow the selection of the proper assembly header and footer without having to create complicated #ifdefs

See also
BURGER_API, BURGER_ANSIAPI or BURGER_DECLSPECNAKED

◆ BURGER_GAMECUBE

#define BURGER_GAMECUBE

Define to determine if code is being built for the Nintendo GameCube.


If this define exists, then you are creating code that runs on the Gekko processor for a Nintendo GameCube.

See also
BURGER_POWERPC, BURGER_WII or BURGER_WIIU

◆ BURGER_GBA

#define BURGER_GBA

Define to determine if code is being built for the Nintendo Gameboy Advanced.


If this define exists, then you are creating code that runs on the Nintendo Gameboy Advanced.

Note
In addition to defining NDEBUG or _DEBUG, you need to define SDK_DEBUG in your project if you wish for the Nintendo GBA SDK to generate debugging information
See also
BURGER_ARM32, BURGER_DS or BURGER_3DS

◆ BURGER_GHS

#define BURGER_GHS   __GHS_VERSION_NUMBER

Define to determine if code is being built using SN Systems compiler.


If this define exists, then you are creating code with the Green Hills Software compiler

See also
BURGER_METROWERKS, BURGER_POWERPC, BURGER_WIIU and BURGER_WII

◆ BURGER_GNUC

#define BURGER_GNUC    ((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__)

Define to determine if code is being built using the GNU C family of compilers.


If this define exists, then you are creating code with the [GNUC compiler] (https://gcc.gnu.org/ "GCC home page")

See also
BURGER_CLANG, BURGER_METROWERKS, BURGER_POWERPC, BURGER_ARM32, BURGER_AMD64 and BURGER_X86

◆ BURGER_INT_NOT_IN_STDINT

#define BURGER_INT_NOT_IN_STDINT

Is int used in stdint.h.


If this define is present, int isn't used in the int32_t family of data types, so if a series of functions wish to allow a function to be automatically called using int as a parameter, a function specifically using int as an input must be declared.

See also
BURGER_LONG_NOT_IN_STDINT

◆ BURGER_INTEL_COMPILER

#define BURGER_INTEL_COMPILER    ((__INTEL_COMPILER * 10) + __INTEL_COMPILER_UPDATE)

Define to determine if code is being built using Intel compiler.


If this define exists, then you are creating code with the Intel compiler

See also
BURGER_MSVC, BURGER_METROWERKS, BURGER_AMD64 and BURGER_X86

◆ BURGER_IOS

#define BURGER_IOS

Define to determine if code is being built for Apple iOS devices.


If this define exists, then you are creating code that runs on Apple iOS devices.

See also
BURGER_ANDROID, BURGER_ARM, BURGER_DARWIN or BURGER_MACOSX

◆ BURGER_ITANIUM

#define BURGER_ITANIUM

Define to determine if code is being built for Intel Itanium compatible processors.


If this define exists, then you are creating code that runs on the Intel Itanium compatible processors. The Microsoft Win64 and Linux which are running on Itanium compatible processors will have this define present.

See also
BURGER_CPU_NAME, BURGER_WIN64 or BURGER_LINUX

◆ BURGER_KVX

#define BURGER_KVX

Define to determine if code is being built for 32 bit Kalray KVX processor.


If this define exists, then you are creating code that runs on the KVX line of 32 bit processors from Kalray.

See also
BURGER_CPU_NAME, or BURGER_LINUX

◆ BURGER_LINUX

#define BURGER_LINUX

Define to determine if code is being built for Linux.


If this define exists, then you are creating code that runs on Linux.

See also
BURGER_POWERPC, BURGER_AMD64 or BURGER_X86

◆ BURGER_LITTLEENDIAN

#define BURGER_LITTLEENDIAN

Define to flag code running on a little endian machine.


This define or BURGER_BIGENDIAN will be present to allow the programmer to create code that can properly parse endian specific data. Only one macro will be defined.

If this macro is present, the machine the code is being built for is little endian.

See also
BURGER_BIGENDIAN, BURGER_ENDIANINDEX_LOW or BURGER_ENDIANINDEX_HIGH

◆ BURGER_MAC

#define BURGER_MAC

Define to determine if code is being built for Apple Mac OS 8.6 through 9.2.


If this define exists, then you are creating code that runs under Apple MacOS version 8.6 through 9.2. Since MacOS runs on the 680x0 or the PowerPC architectures, you may need to check BURGER_68K or BURGER_POWERPC for any CPU specific code or features. Also, on 680x0 platforms, you may be compiling under the Code Fragment Manager format, and to detect that, check for the presence of BURGER_CFM.

Note
To compile for Carbon under a PowerPC CPU, your project must define TARGET_API_MAC_CARBON so the MacOS headers will properly be adjusted for Carbon. If you are using Burgerlib for Carbon, you have access to MacOS X features if your application is running on a MacOS X system.
// Include this define in your CodeWarrior C/C++ Preprocessor preferences
// settings to build for MacOS 9 Carbon.
#define TARGET_API_MAC_CARBON 1
See also
BURGER_MACOS, BURGER_MACOSX, BURGER_MACCLASSIC, BURGER_MACCARBON, BURGER_68K, BURGER_POWERPC or TARGET_API_MAC_CARBON

◆ BURGER_MACCARBON

#define BURGER_MACCARBON

Define to determine if code is being built for both Apple Mac OS9 and MacOS X.


If this define exists, then you are creating code that runs under Apple MacOS 9 and for Apple MacOS X. Only the PowerPC is supported. Since MacOS Carbon support is enabled, accessing the low memory operating system variables is NOT allowed.

See also
BURGER_POWERPC, BURGER_MACOSX, BURGER_MACOS or BURGER_MAC

◆ BURGER_MACCLASSIC

#define BURGER_MACCLASSIC

Define to determine if code is being built exclusively for Apple Mac OS9.


If this define exists, then you are creating code that runs under Apple MacOS 9 for either PowerPC or 68K. There is no support for MacOS X operating systems under this build target. The CPU can be either BURGER_POWERPC or BURGER_68K for this platform, so no CPU specific code should be written without checking for the CPU type. Since no MacOS Carbon support is enabled, accessing the low memory operating system variables is allowed.

See also
BURGER_POWERPC, BURGER_68K, BURGER_MACOS or BURGER_MAC

◆ BURGER_MACOSX

#define BURGER_MACOSX

Define to determine if code is being built exclusively for Apple Mac OS X.


If this define exists, then you are creating code that runs under Apple MacOS X using Mach-O. There is no support for pre-MacOS X operating systems under this build target. The CPU can be either BURGER_POWERPC, BURGER_AMD64 or BURGER_X86 for this platform, so no CPU specific code should be written without checking for the CPU type.

See also
BURGER_POWERPC, BURGER_AMD64, BURGER_X86, BURGER_MACOS, BURGER_DARWIN or BURGER_MAC

◆ BURGER_METROWERKS

#define BURGER_METROWERKS   __MWERKS__

Define to determine if code is being built using Freescale/Metrowerks family of compilers.


If this define exists, then you are creating code with the [Freescale / Metrowerks compiler] (https://www.nxp.com/support/developer-resources/software-development-tools/codewarrior-development-tools:CW_HOME)

See also
BURGER_MRC, BURGER_POWERPC, BURGER_MIPS32 and BURGER_X86

◆ BURGER_MINGW

#define BURGER_MINGW

Define to determine if code is being built using MinGW compilers.


If this define exists, then you are creating code with the [MinGW compiler] (http://www.mingw.org/ "MinGW home page")

See also
BURGER_WATCOM, BURGER_INTEL_COMPILER, BURGER_METROWERKS, BURGER_MSVC and BURGER_X86

◆ BURGER_MIPS32

#define BURGER_MIPS32

Define to determine if code is being built for MIPS 32 bit processors.


If this define exists, then you are creating code that runs on the MIPS 32 bit line of processors. R5900 (PS2), R3300 (PS1) and R4400 (PSP) all will have this define present.

See also
BURGER_CPU_NAME, BURGER_MIPS64, BURGER_PS2, BURGER_PSP, BURGER_PS1 or BURGER_MIPS

◆ BURGER_MIPS64

#define BURGER_MIPS64

Define to determine if code is being built for MIPS 64 bit processors.


If this define exists, then you are creating code that runs on the MIPS 64 bit line of 64 bit processors.

See also
BURGER_CPU_NAME, BURGER_MIPS32, BURGER_MIPS

◆ BURGER_MRC

#define BURGER_MRC   __MRC__

Define to determine if code is being built using Apple/Motorola MrC compiler.


If this define exists, then you are creating code with the [MrC compiler] (https://staticky.com/mirrors/ftp.apple.com/developer/Tool_Chest/Core_Mac_OS_Tools/MPW_Website_Downloads/ "MrC Compiler download page")

Known issues with the Apple MrC compiler.

  1. Templates are poorly supported. Do not use templates.
See also
BURGER_GNUC, BURGER_METROWERKS, BURGER_APPLE_SC and BURGER_POWERPC

◆ BURGER_MSDOS

#define BURGER_MSDOS

Define to determine if code is being built for Microsoft MS-DOS.


If this define exists, then you are creating code that runs under classic MS-DOS.

Check for the defines BURGER_X32 or BURGER_DOS4G if you wish to determine which dos extender you are using.

See also
BURGER_X86

◆ BURGER_MSP430

#define BURGER_MSP430

Define to determine if code is being built for 16 bit MSP430 processors from Texas Instruments.


If this define exists, then you are creating code that runs on the MSP430 line of 16 bit processors. Micro controllers will have this define present.

See also
BURGER_CPU_NAME, BURGER_RISCV, BURGER_ARM32 or BURGER_AVR

◆ BURGER_MSVC

#define BURGER_MSVC   _MSC_FULL_VER

Define to determine if code is being built using Microsoft Visual C family of compilers.


If this define exists, then you are creating code with the Microsoft Visual C compiler.

See also
BURGER_INTEL_COMPILER, BURGER_METROWERKS, BURGER_ARM32, BURGER_AMD64 and BURGER_X86

◆ BURGER_NANOMIPS32

#define BURGER_NANOMIPS32

Define to determine if code is being built for 32 bit nanoMIPS processors from Sun.


If this define exists, then you are creating code that runs on the nanoMIPS line of 32 bit processors.

See also
BURGER_CPU_NAME, BURGER_LINUX, or BURGER_RISCV

◆ BURGER_NGAGE

#define BURGER_NGAGE

Define to determine if code is being built for the Nokia Ngage.


If this define exists, then you are creating code that runs on the Nokia NGage.

Note
There is no floating point support on this platform.
See also
BURGER_ARM32, or BURGER_SYMBIAN

◆ BURGER_NO_ALIGN

#define BURGER_NO_ALIGN

Per object alignment is not supported.


On older compilers, the ability to set the alignment of individual object is not supported. This macro exists on those compilers to alert code to be written to handle this case.

See also
BURGER_PREALIGN, BURGER_POSTALIGN and BURGER_ALIGN

◆ BURGER_OUYA

#define BURGER_OUYA

Define to determine if code is being built for the OUYA.


If this define exists, then you are creating code that runs on OUYA Android devices.

See also
BURGER_IOS, BURGER_ANDROID, BURGER_SHIELD, BURGER_ARM32 or BURGER_MACOSX

◆ BURGER_PLATFORM_NAME

#define BURGER_PLATFORM_NAME   "Name of operating system"

String with the operating system's name.


This string is of the operating system the code is being compiled for.

See also
BURGER_WINDOWS, BURGER_LINUX or BURGER_MACOS

◆ BURGER_POWERPC

#define BURGER_POWERPC

Define to determine if code is being built for 32 bit PowerPC processors.


If this define exists, then you are creating code that runs on a 32 bit PowerPC processor. The Nintendo GameCube, Power Macintosh and the Nintendo Wii all will have this define present.

See also
BURGER_CPU_NAME, BURGER_PPC, BURGER_WIIU, BURGER_WII, BURGER_MAC, BURGER_MACOSX, BURGER_BEOS or BURGER_GAMECUBE

◆ BURGER_POWERPC64

#define BURGER_POWERPC64

Define to determine if code is being built for 64 bit PowerPC processors.


If this define exists, then you are creating code that runs on a 64 bit PowerPC processor. The G5 Power Macintosh, Sony Playstation 3 and Microsoft XBox 360 all will have this define present.

See also
BURGER_CPU_NAME, BURGER_PPC, BURGER_XBOX360, BURGER_PS3 or BURGER_MACOSX

◆ BURGER_PS1

#define BURGER_PS1

Define to determine if code is being built for the Sony Playstation.


If this define exists, then you are creating code that runs on the Sony Playstation.

Note
There is no floating point support on this platform.
See also
BURGER_MIPS32, BURGER_PS2, BURGER_PS3, BURGER_PS4, or BURGER_PS5

◆ BURGER_PS2

#define BURGER_PS2

Define to determine if code is being built for the Emotion Engine CPU for a PS2.


If this define exists, then you are creating code that runs on the main processor for a Sony Playstation 2.

See also
BURGER_MIPS32, BURGER_PS1, BURGER_PS3, BURGER_PS4, or BURGER_PS5

◆ BURGER_PS3

#define BURGER_PS3

Define to determine if code is being built for the PS3.


If this define exists, then you are creating code that runs on the main processor for a Sony Playstation 3.

Note
This define is only present for compiling code on the primary CPU. Code targeted for the cell units must be written and compiled separately.
See also
BURGER_POWERPC, BURGER_PS1, BURGER_PS2, BURGER_PS4, or BURGER_PS5

◆ BURGER_PS4

#define BURGER_PS4

Define to determine if code is being built for the PS4.


If this define exists, then you are creating code that runs on the main processor for a Sony Playstation 4.

See also
BURGER_AMD64, BURGER_PS1, BURGER_PS2, BURGER_PS3, or BURGER_PS5

◆ BURGER_PS5

#define BURGER_PS5

Define to determine if code is being built for the PS5.


If this define exists, then you are creating code that runs on the main processor for a Sony Playstation 5.

See also
BURGER_AMD64, BURGER_PS1, BURGER_PS2, BURGER_PS3, or BURGER_PS4

◆ BURGER_PSP

#define BURGER_PSP

Define to determine if code is being built for the Sony PSP.


If this define exists, then you are creating code that runs on the Sony Playstation Portable (PSP).

See also
BURGER_MIPS32, BURGER_VITA, BURGER_PS1, BURGER_PS2, BURGER_PS3, or BURGER_PS4

◆ BURGER_RISCV

#define BURGER_RISCV

Define to determine if code is being built for 32 bit RISC-V processors.


If this define exists, then you are creating code that runs on the RISC-V line of processors. Micro controllers will have this define present.

See also
BURGER_CPU_NAME, BURGER_MSP430, BURGER_ARM64, BURGER_ARM32 or BURGER_AVR

◆ BURGER_S390

#define BURGER_S390

Define to determine if code is being built for 64 bit IBM System/390 processors.


If this define exists, then you are creating code that runs on the IBM Systemp/390 line of 64 bit processors. IBM servers will have this define present.

See also
BURGER_CPU_NAME, BURGER_LINUX, or BURGER_AMD64

◆ BURGER_SH32

#define BURGER_SH32

Define to determine if code is being built for 32 bit SuperH processors from HItachi.


If this define exists, then you are creating code that runs on the SuperH line of 32 bit processors. Used by the Sega Dreamcast

See also
BURGER_CPU_NAME, or BURGER_LINUX

◆ BURGER_SHIELD

#define BURGER_SHIELD

Define to determine if code is being built for nVidia SHIELD devices.


If this define exists, then you are creating code that runs on nVidia SHIELD Android devices.

See also
BURGER_IOS, BURGER_ANDROID, BURGER_OUYA, BURGER_ARM32 or BURGER_MACOSX

◆ BURGER_SNSYSTEMS

#define BURGER_SNSYSTEMS   __SN_VER__

Define to determine if code is being built using Green Hills compiler.


If this define exists, then you are creating code with the SN Systems compiler

See also
BURGER_METROWERKS, BURGER_POWERPC, BURGER_MIPS32 and BURGER_AMD64

◆ BURGER_SPARC32

#define BURGER_SPARC32

Define to determine if code is being built for 32 bit Sparc processors from Sun.


If this define exists, then you are creating code that runs on the Sparc line of 32 bit processors. Sun servers will have this define present.

See also
BURGER_CPU_NAME, BURGER_LINUX, or BURGER_SPARC64

◆ BURGER_SPARC64

#define BURGER_SPARC64

Define to determine if code is being built for 64 bit Sparc processors from Sun.


If this define exists, then you are creating code that runs on the Sparc line of 64 bit processors. Sun servers will have this define present.

See also
BURGER_CPU_NAME, BURGER_LINUX, or BURGER_SPARC32

◆ BURGER_STADIA

#define BURGER_STADIA

Define to determine if code is being built for Google Stadia.


If this define exists, then you are creating code that runs on Google Stadia streaming console.

Note
As of 2023, Stadia has been shut down, so this target exists only for archive purposes only.
See also
BURGER_UNIX, BURGER_LINUX, BURGER_ANDROID, or BURGER_AMD64

◆ BURGER_STEAM

#define BURGER_STEAM

Define for the presence of Valve's Steam platform.


If this define exists, then the Steam platform is supported. TCP/IP can be assumed to be available with this define present.

Note
Steam is not available on PowerPC MacOSX and old Windows compilers
See also
BURGER_TCPIP, BURGER_APPLETALK, BURGER_IPX, or BURGER_XBOXLIVE

◆ BURGER_STRUCT_ALIGN

#define BURGER_STRUCT_ALIGN

Defined if the compiler uses Macintosh style data alignment commands.


Compilers can be set to change the default alignment of data structures. If alignment for a specific header needs to be set, you will need to insert this code as a prefix and a postfix to make sure that the compiler settings are overridden.

This is useful for data structures that are mapped to the contents of a loaded file.

Note
Care must be exercised when changing alignment to byte or short. Some CPUs will generate a page fault if a 32 bit value is not 4 byte aligned.
// Prefix for 4 byte alignment
#if defined(BURGER_STRUCT_ALIGN)
#pragma options align=power
#elif defined(BURGER_STRUCT_PACKPUSH)
#pragma pack(push,4)
#elif defined(BURGER_STRUCT_PACK)
#pragma pack(4)
#endif
// Postfix to restore compiler setting alignment
#if defined(BURGER_STRUCT_ALIGN)
#pragma options align=reset
#elif defined(BURGER_STRUCT_PACKPUSH)
#pragma pack(pop)
#elif defined(BURGER_STRUCT_PACK)
#pragma pack()
#endif
See also
BURGER_STRUCT_PACK or BURGER_STRUCT_PACKPUSH

◆ BURGER_STRUCT_PACK

#define BURGER_STRUCT_PACK

Defined if the compiler uses GNU style data alignment commands.


Compilers can be set to change the default alignment of data structures. If alignment for a specific header needs to be set, you will need to insert this code as a prefix and a postfix to make sure that the compiler settings are overridden.

This is useful for data structures that are mapped to the contents of a loaded file.

Note
Care must be exercised when changing alignment to byte or short. Some CPUs will generate a page fault if a 32 bit value is not 4 byte aligned.
// Prefix for 4 byte alignment
#if defined(BURGER_STRUCT_ALIGN)
#pragma options align=power
#elif defined(BURGER_STRUCT_PACKPUSH)
#pragma pack(push,4)
#elif defined(BURGER_STRUCT_PACK)
#pragma pack(4)
#endif
// Postfix to restore compiler setting alignment
#if defined(BURGER_STRUCT_ALIGN)
#pragma options align=reset
#elif defined(BURGER_STRUCT_PACKPUSH)
#pragma pack(pop)
#elif defined(BURGER_STRUCT_PACK)
#pragma pack()
#endif
See also
BURGER_STRUCT_ALIGN or BURGER_STRUCT_PACKPUSH

◆ BURGER_STRUCT_PACKPUSH

#define BURGER_STRUCT_PACKPUSH

Defined if the compiler uses Microsoft style data alignment commands.


Compilers can be set to change the default alignment of data structures. If alignment for a specific header needs to be set, you will need to insert this code as a prefix and a postfix to make sure that the compiler settings are overridden.

This is useful for data structures that are mapped to the contents of a loaded file.

Note
Care must be exercised when changing alignment to byte or short. Some CPUs will generate a page fault if a 32 bit value is not 4 byte aligned.
// Prefix for 4 byte alignment
#if defined(BURGER_STRUCT_ALIGN)
#pragma options align=power
#elif defined(BURGER_STRUCT_PACKPUSH)
#pragma pack(push,4)
#elif defined(BURGER_STRUCT_PACK)
#pragma pack(4)
#endif
// Postfix to restore compiler setting alignment
#if defined(BURGER_STRUCT_ALIGN)
#pragma options align=reset
#elif defined(BURGER_STRUCT_PACKPUSH)
#pragma pack(pop)
#elif defined(BURGER_STRUCT_PACK)
#pragma pack()
#endif
See also
BURGER_STRUCT_ALIGN or BURGER_STRUCT_PACK

◆ BURGER_SWITCH

#define BURGER_SWITCH

Define to determine if code is being built for the Nintendo Switch.


If this define exists, then you are creating code that runs on the Arm64 processor for a Nintendo Switch.

See also
BURGER_ARM64, BURGER_WII, BURGER_WII or BURGER_3DS

◆ BURGER_SYMBIAN

#define BURGER_SYMBIAN

Define to determine if code is being built for the Symbian OS.


If this define exists, then you are creating code that runs under the Symbian OS, usually Nokia brand cell phones and PDAs.

Note
There is no floating point support on this platform.
See also
BURGER_ARM32, or BURGER_NGAGE

◆ BURGER_VITA

#define BURGER_VITA

Define to determine if code is being built for the Sony VITA.


If this define exists, then you are creating code that runs on the Sony Playstation Portable 2 (PSP2 / Vita).

See also
BURGER_ARM32, BURGER_PSP, BURGER_PS1, BURGER_PS2, BURGER_PS3, or BURGER_PS4

◆ BURGER_WATCOM

#define BURGER_WATCOM   __WATCOMC__

Define to determine if code is being built using Open Watcom compilers.


If this define exists, then you are creating code with the Open Watcom compiler

Known issues with the Watcom Compiler version 1.9.

  1. Multicharacter ASCII such as 'RSRC' or 'ABCD' are not supported. Any use of this data type will have the compiler generate an ASCII character of the first letter found and ignore the rest and assume a data type of char.
  2. Templates are not fully supported. So several high level templates are not available. Look to the documentation of the Burgerlib templates to determine if it is supported on Watcom.
See also
BURGER_INTEL_COMPILER, BURGER_METROWERKS, BURGER_MSVC and BURGER_X86

◆ BURGER_WII

#define BURGER_WII

Define to determine if code is being built for the Nintendo Wii.


If this define exists, then you are creating code that runs on the Broadway processor for a Nintendo Wii.

See also
BURGER_SWITCH, BURGER_POWERPC, BURGER_WIIU or BURGER_GAMECUBE

◆ BURGER_WIIU

#define BURGER_WIIU

Define to determine if code is being built for the Nintendo WiiU.


If this define exists, then you are creating code that runs on the Broadway processor for a Nintendo WiiU.

See also
BURGER_SWITCH, BURGER_POWERPC, BURGER_WII or BURGER_GAMECUBE

◆ BURGER_WIN32

#define BURGER_WIN32

Define to determine if code is being built for Microsoft 32 bit Windows.


If this define exists, then you are creating code that runs on Microsoft Windows for 32 bit CPUs.

Note
You may need to check the processor define, since future versions of Windows may be running on non-Pentium type processors.
See also
BURGER_WINDOWS,BURGER_WIN64, BURGER_MSDOS and BURGER_X86

◆ BURGER_WIN64

#define BURGER_WIN64

Define to determine if code is being built for Microsoft 64 bit Windows.


If this define exists, then you are creating code that runs on Microsoft Windows for 64 bit CPUs.

Note
You may need to check the processor define, since future versions of Windows may be running on non-Pentium type processors.
See also
BURGER_WINDOWS, BURGER_WIN32, BURGER_MSDOS and BURGER_AMD64

◆ BURGER_X32

#define BURGER_X32

Define to determine if MS-DOS code is being built with the X32 DOS extender.


If this define exists, then you are creating code that runs under classic MS-DOS with the X32 DOS extender.

This define is declared by the project, not by Burgerlib. Either BURGER_X32 or BURGER_DOS4G must be present.

See also
BURGER_MSDOS or BURGER_DOS4G

◆ BURGER_X86

#define BURGER_X86

Define to determine if code is being built for 32 bit Intel processors.


If this define exists, then you are creating code that runs on the Intel, AMD and other compatible processors. The Microsoft XBox, Mac OSX Intel and Win32 platforms which are running on Pentium, 386, 486, and AMD CPUs will have this define present.

See also
BURGER_CPU_NAME, BURGER_INTEL, BURGER_AMD64, BURGER_WIN32, BURGER_BEOS, BURGER_MSDOS, BURGER_MACOSX or BURGER_XBOX

◆ BURGER_XBOX

#define BURGER_XBOX

Define to determine if code is being built for the Microsoft XBox.


If this define exists, then you are creating code that runs on the Intel Celeron for a Microsoft XBox.

See also
BURGER_X86, BURGER_XBOX360, or BURGER_XBOXONE

◆ BURGER_XBOX360

#define BURGER_XBOX360

Define to determine if code is being built for the Microsoft XBox 360.


If this define exists, then you are creating code that runs on the Microsoft XBox360.

Note
You can use Burgerlib functions from any thread, but caution should be exercised to prevent thread stalls and multi threading problems. Burgerlib's higher level classes may not be reentrant. See the documentation for higher level classes to determine multi-threading safety.
See also
BURGER_POWERPC, BURGER_XBOX, or BURGER_XBOXONE

◆ BURGER_XBOXONE

#define BURGER_XBOXONE

Define to determine if code is being built for the Microsoft XBox One.


If this define exists, then you are creating code that runs on the Microsoft XBox One.

Note
You can use Burgerlib functions from any thread, but caution should be exercised to prevent thread stalls and multi threading problems. Burgerlib's higher level classes may not be reentrant. See the documentation for higher level classes to determine multi-threading safety.
See also
BURGER_AMD64, BURGER_XBOX, or BURGER_XBOX360

◆ NDEBUG

#define NDEBUG

Defined to disable the creation of debug code.


If this define exists, then you are creating a release build. This is only present to force BURGER_ASSERT to vanish. Only _DEBUG or NDEBUG can exist at a time. Specifying both or neither is considered a fatal compile error. This define is not supplied by Burgerlib, it must be defined by the build project.

Note
This flag is not used to determine if optimizations have been enabled. It's only used to disable the generation of debugging code.
#if defined(NDEBUG)
CrashGameIfDataNotFound();
#endif
See also
_DEBUG

◆ nullptr

#define nullptr   0

Defined to nothing if the feature is not available.


On compilers that support nullptr, this macro does not exist. To support this feature on older compilers, this macro exists to simulate the feature

See also
BURGER_CPP11, BURGER_OVERRIDE or BURGER_CONSTEXPR

◆ TARGET_API_MAC_CARBON

#define TARGET_API_MAC_CARBON   1

Define to determine if Mac OS 9 code is being built with the Carbon libraries.


If this define exists, then you are creating code that runs under classic Mac OS with the Carbon libraries.

This define is declared by the project, not by Burgerlib. If this define is missing, the code will default to classic MacOS 8.6 - 9.2.

See also
BURGER_MAC, BURGER_CFM or BURGER_MACOSX