Showing preview only (2,261K chars total). Download the full file or copy to clipboard to get everything.
Repository: scemino/engge
Branch: master
Commit: 641208858f4a
Files: 470
Total size: 2.1 MB
Directory structure:
gitextract_57u15zkm/
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ └── feature_request.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ └── Build.yml
├── .gitignore
├── .gitmodules
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── README.MD
├── appInfo.cmake
├── extlibs/
│ ├── spdlog/
│ │ ├── include/
│ │ │ └── spdlog/
│ │ │ ├── async.h
│ │ │ ├── async_logger-inl.h
│ │ │ ├── async_logger.h
│ │ │ ├── common-inl.h
│ │ │ ├── common.h
│ │ │ ├── details/
│ │ │ │ ├── circular_q.h
│ │ │ │ ├── console_globals.h
│ │ │ │ ├── file_helper-inl.h
│ │ │ │ ├── file_helper.h
│ │ │ │ ├── fmt_helper.h
│ │ │ │ ├── log_msg-inl.h
│ │ │ │ ├── log_msg.h
│ │ │ │ ├── mpmc_blocking_q.h
│ │ │ │ ├── null_mutex.h
│ │ │ │ ├── os-inl.h
│ │ │ │ ├── os.h
│ │ │ │ ├── pattern_formatter-inl.h
│ │ │ │ ├── pattern_formatter.h
│ │ │ │ ├── periodic_worker-inl.h
│ │ │ │ ├── periodic_worker.h
│ │ │ │ ├── registry-inl.h
│ │ │ │ ├── registry.h
│ │ │ │ ├── synchronous_factory.h
│ │ │ │ ├── thread_pool-inl.h
│ │ │ │ └── thread_pool.h
│ │ │ ├── fmt/
│ │ │ │ ├── bin_to_hex.h
│ │ │ │ ├── bundled/
│ │ │ │ │ ├── LICENSE.rst
│ │ │ │ │ ├── chrono.h
│ │ │ │ │ ├── color.h
│ │ │ │ │ ├── core.h
│ │ │ │ │ ├── format-inl.h
│ │ │ │ │ ├── format.h
│ │ │ │ │ ├── locale.h
│ │ │ │ │ ├── ostream.h
│ │ │ │ │ ├── posix.h
│ │ │ │ │ ├── printf.h
│ │ │ │ │ ├── ranges.h
│ │ │ │ │ └── time.h
│ │ │ │ ├── fmt.h
│ │ │ │ └── ostr.h
│ │ │ ├── formatter.h
│ │ │ ├── logger-inl.h
│ │ │ ├── logger.h
│ │ │ ├── sinks/
│ │ │ │ ├── android_sink.h
│ │ │ │ ├── ansicolor_sink-inl.h
│ │ │ │ ├── ansicolor_sink.h
│ │ │ │ ├── base_sink-inl.h
│ │ │ │ ├── base_sink.h
│ │ │ │ ├── basic_file_sink-inl.h
│ │ │ │ ├── basic_file_sink.h
│ │ │ │ ├── daily_file_sink.h
│ │ │ │ ├── dist_sink.h
│ │ │ │ ├── dup_filter_sink.h
│ │ │ │ ├── msvc_sink.h
│ │ │ │ ├── null_sink.h
│ │ │ │ ├── ostream_sink.h
│ │ │ │ ├── rotating_file_sink-inl.h
│ │ │ │ ├── rotating_file_sink.h
│ │ │ │ ├── sink-inl.h
│ │ │ │ ├── sink.h
│ │ │ │ ├── stdout_color_sinks-inl.h
│ │ │ │ ├── stdout_color_sinks.h
│ │ │ │ ├── stdout_sinks-inl.h
│ │ │ │ ├── stdout_sinks.h
│ │ │ │ ├── syslog_sink.h
│ │ │ │ ├── systemd_sink.h
│ │ │ │ ├── wincolor_sink-inl.h
│ │ │ │ └── wincolor_sink.h
│ │ │ ├── spdlog-inl.h
│ │ │ ├── spdlog.h
│ │ │ ├── tweakme.h
│ │ │ └── version.h
│ │ └── src/
│ │ └── spdlog.cpp
│ └── squirrel/
│ ├── .gitignore
│ ├── .travis.yml
│ ├── CMakeLists.txt
│ ├── COMPILE
│ ├── COPYRIGHT
│ ├── HISTORY
│ ├── Makefile
│ ├── README
│ ├── appveyor.yml
│ ├── doc/
│ │ ├── Makefile
│ │ ├── make.bat
│ │ └── source/
│ │ ├── conf.py
│ │ ├── index.rst
│ │ ├── reference/
│ │ │ ├── api/
│ │ │ │ ├── bytecode_serialization.rst
│ │ │ │ ├── calls.rst
│ │ │ │ ├── compiler.rst
│ │ │ │ ├── debug_interface.rst
│ │ │ │ ├── garbage_collector.rst
│ │ │ │ ├── object_creation_and_handling.rst
│ │ │ │ ├── object_manipulation.rst
│ │ │ │ ├── raw_object_handling.rst
│ │ │ │ ├── stack_operations.rst
│ │ │ │ └── virtual_machine.rst
│ │ │ ├── api_reference.rst
│ │ │ ├── embedding/
│ │ │ │ ├── build_configuration.rst
│ │ │ │ ├── calling_a_function.rst
│ │ │ │ ├── compiling_a_script.rst
│ │ │ │ ├── creating_a_c_function.rst
│ │ │ │ ├── debug_interface.rst
│ │ │ │ ├── error_conventions.rst
│ │ │ │ ├── memory_management.rst
│ │ │ │ ├── references_from_c.rst
│ │ │ │ ├── runtime_error_handling.rst
│ │ │ │ ├── tables_and_arrays_manipulation.rst
│ │ │ │ ├── the_registry_table.rst
│ │ │ │ ├── the_stack.rst
│ │ │ │ ├── userdata_and_userpointers.rst
│ │ │ │ └── vm_initialization.rst
│ │ │ ├── embedding_squirrel.rst
│ │ │ ├── index.rst
│ │ │ ├── introduction.rst
│ │ │ ├── language/
│ │ │ │ ├── arrays.rst
│ │ │ │ ├── builtin_functions.rst
│ │ │ │ ├── classes.rst
│ │ │ │ ├── constants_and_enumerations.rst
│ │ │ │ ├── datatypes.rst
│ │ │ │ ├── delegation.rst
│ │ │ │ ├── execution_context.rst
│ │ │ │ ├── expressions.rst
│ │ │ │ ├── functions.rst
│ │ │ │ ├── generators.rst
│ │ │ │ ├── lexical_structure.rst
│ │ │ │ ├── metamethods.rst
│ │ │ │ ├── statements.rst
│ │ │ │ ├── tables.rst
│ │ │ │ ├── threads.rst
│ │ │ │ └── weak_references.rst
│ │ │ └── language.rst
│ │ └── stdlib/
│ │ ├── index.rst
│ │ ├── introduction.rst
│ │ ├── stdauxlib.rst
│ │ ├── stdbloblib.rst
│ │ ├── stdiolib.rst
│ │ ├── stdmathlib.rst
│ │ ├── stdstringlib.rst
│ │ └── stdsystemlib.rst
│ ├── etc/
│ │ ├── minimal.c
│ │ └── test.nut
│ ├── include/
│ │ ├── sqconfig.h
│ │ ├── sqstdaux.h
│ │ ├── sqstdblob.h
│ │ ├── sqstdio.h
│ │ ├── sqstdmath.h
│ │ ├── sqstdstring.h
│ │ ├── sqstdsystem.h
│ │ └── squirrel.h
│ ├── samples/
│ │ ├── ackermann.nut
│ │ ├── array.nut
│ │ ├── class.nut
│ │ ├── classattributes.nut
│ │ ├── coroutines.nut
│ │ ├── delegation.nut
│ │ ├── fibonacci.nut
│ │ ├── flow.nut
│ │ ├── generators.nut
│ │ ├── hello.nut
│ │ ├── list.nut
│ │ ├── loops.nut
│ │ ├── matrix.nut
│ │ ├── metamethods.nut
│ │ ├── methcall.nut
│ │ ├── regex.nut
│ │ └── tailstate.nut
│ ├── sq/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile
│ │ ├── sq.c
│ │ └── sq.dsp
│ ├── sqstdlib/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile
│ │ ├── sqstdaux.cpp
│ │ ├── sqstdblob.cpp
│ │ ├── sqstdblobimpl.h
│ │ ├── sqstdio.cpp
│ │ ├── sqstdlib.dsp
│ │ ├── sqstdmath.cpp
│ │ ├── sqstdrex.cpp
│ │ ├── sqstdstream.cpp
│ │ ├── sqstdstream.h
│ │ ├── sqstdstring.cpp
│ │ └── sqstdsystem.cpp
│ ├── squirrel/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile
│ │ ├── sqapi.cpp
│ │ ├── sqarray.h
│ │ ├── sqbaselib.cpp
│ │ ├── sqclass.cpp
│ │ ├── sqclass.h
│ │ ├── sqclosure.h
│ │ ├── sqcompiler.cpp
│ │ ├── sqcompiler.h
│ │ ├── sqdebug.cpp
│ │ ├── sqfuncproto.h
│ │ ├── sqfuncstate.cpp
│ │ ├── sqfuncstate.h
│ │ ├── sqlexer.cpp
│ │ ├── sqlexer.h
│ │ ├── sqmem.cpp
│ │ ├── sqobject.cpp
│ │ ├── sqobject.h
│ │ ├── sqopcodes.h
│ │ ├── sqpcheader.h
│ │ ├── sqstate.cpp
│ │ ├── sqstate.h
│ │ ├── sqstring.h
│ │ ├── sqtable.cpp
│ │ ├── sqtable.h
│ │ ├── squirrel.dsp
│ │ ├── squserdata.h
│ │ ├── squtils.h
│ │ ├── sqvm.cpp
│ │ └── sqvm.h
│ └── squirrel.dsw
├── include/
│ └── engge/
│ ├── Audio/
│ │ ├── SoundCategory.hpp
│ │ ├── SoundDefinition.hpp
│ │ ├── SoundId.hpp
│ │ ├── SoundManager.hpp
│ │ └── SoundTrigger.hpp
│ ├── Dialog/
│ │ ├── ConditionVisitor.hpp
│ │ ├── DialogConditionAbstract.hpp
│ │ ├── DialogContextAbstract.hpp
│ │ ├── DialogManager.hpp
│ │ ├── DialogPlayer.hpp
│ │ ├── DialogScriptAbstract.hpp
│ │ ├── EngineDialogScript.hpp
│ │ └── ExpressionVisitor.hpp
│ ├── EnggeApplication.hpp
│ ├── Engine/
│ │ ├── ActorIconSlot.hpp
│ │ ├── ActorIcons.hpp
│ │ ├── Callback.hpp
│ │ ├── Camera.hpp
│ │ ├── ChangeProperty.hpp
│ │ ├── Cutscene.hpp
│ │ ├── Engine.hpp
│ │ ├── EngineCommands.hpp
│ │ ├── EngineSettings.hpp
│ │ ├── EntityManager.hpp
│ │ ├── ExCommandConstants.hpp
│ │ ├── Function.hpp
│ │ ├── Hud.hpp
│ │ ├── InputStateConstants.hpp
│ │ ├── Interpolations.hpp
│ │ ├── Inventory.hpp
│ │ ├── Light.hpp
│ │ ├── Preferences.hpp
│ │ ├── RoomEffect.hpp
│ │ ├── SavegameSlot.hpp
│ │ ├── Sentence.hpp
│ │ ├── TextDatabase.hpp
│ │ ├── Thread.hpp
│ │ ├── ThreadBase.hpp
│ │ ├── TimeFunction.hpp
│ │ ├── Trigger.hpp
│ │ └── Verb.hpp
│ ├── Entities/
│ │ ├── Actor.hpp
│ │ ├── AnimationLoader.hpp
│ │ ├── BlinkState.hpp
│ │ ├── Costume.hpp
│ │ ├── DirectionConstants.hpp
│ │ ├── Entity.hpp
│ │ ├── Facing.hpp
│ │ ├── Object.hpp
│ │ ├── TextObject.hpp
│ │ └── UseDirection.hpp
│ ├── Graphics/
│ │ ├── AnimControl.hpp
│ │ ├── AnimDrawable.hpp
│ │ ├── AnimState.hpp
│ │ ├── Animation.hpp
│ │ ├── GGFont.hpp
│ │ ├── LightingShader.h
│ │ ├── ResourceManager.hpp
│ │ ├── Screen.hpp
│ │ ├── SpriteSheet.hpp
│ │ ├── SpriteSheetItem.h
│ │ └── Text.hpp
│ ├── Input/
│ │ ├── CommandManager.hpp
│ │ ├── InputConstants.hpp
│ │ └── InputMappings.hpp
│ ├── Parsers/
│ │ ├── GGPackBufferStream.hpp
│ │ ├── GGPackStream.hpp
│ │ ├── Lip.hpp
│ │ ├── SavegameManager.hpp
│ │ ├── YackParser.hpp
│ │ └── YackTokenReader.hpp
│ ├── Room/
│ │ ├── Room.hpp
│ │ ├── RoomLayer.hpp
│ │ └── RoomScaling.hpp
│ ├── Scripting/
│ │ ├── ScriptEngine.hpp
│ │ ├── ScriptExecute.hpp
│ │ ├── ScriptObject.hpp
│ │ └── VerbExecute.hpp
│ ├── System/
│ │ ├── Locator.hpp
│ │ ├── Logger.hpp
│ │ ├── NonCopyable.hpp
│ │ └── Services.hpp
│ ├── UI/
│ │ ├── OptionsDialog.hpp
│ │ ├── QuitDialog.hpp
│ │ ├── SaveLoadDialog.hpp
│ │ └── StartScreenDialog.hpp
│ └── Util/
│ ├── BTEACrypto.hpp
│ └── RandomNumberGenerator.hpp
└── src/
├── Audio/
│ ├── SoundDefinition.cpp
│ ├── SoundId.cpp
│ ├── SoundManager.cpp
│ └── SoundTrigger.cpp
├── CMakeLists.txt
├── Dialog/
│ ├── Ast.cpp
│ ├── AstDump.hpp
│ ├── ConditionVisitor.cpp
│ ├── DialogManager.cpp
│ ├── DialogPlayer.cpp
│ ├── EngineDialogScript.cpp
│ └── ExpressionVisitor.cpp
├── EnggeApplication.cpp
├── Engine/
│ ├── AchievementManager.cpp
│ ├── AchievementManager.hpp
│ ├── ActorIcons.cpp
│ ├── Callback.cpp
│ ├── Camera.cpp
│ ├── Cutscene.cpp
│ ├── DebugFeatures.hpp
│ ├── Engine.cpp
│ ├── EngineImpl.cpp
│ ├── EngineImpl.hpp
│ ├── EngineSettings.cpp
│ ├── EntityManager.cpp
│ ├── Hud.cpp
│ ├── Inventory.cpp
│ ├── Light.cpp
│ ├── Preferences.cpp
│ ├── Sentence.cpp
│ ├── Shaders.cpp
│ ├── Shaders.hpp
│ ├── TextDatabase.cpp
│ ├── Thread.cpp
│ ├── ThreadBase.cpp
│ ├── TimeFunction.cpp
│ └── Trigger.cpp
├── Entities/
│ ├── Actor.cpp
│ ├── AnimationLoader.cpp
│ ├── BlinkState.cpp
│ ├── Costume.cpp
│ ├── Entity.cpp
│ ├── JiggleFunction.cpp
│ ├── JiggleFunction.hpp
│ ├── LipAnimation.cpp
│ ├── LipAnimation.hpp
│ ├── Object.cpp
│ ├── ShakeFunction.cpp
│ ├── ShakeFunction.hpp
│ ├── TalkingState.cpp
│ ├── TalkingState.hpp
│ ├── TextObject.cpp
│ ├── WalkingState.cpp
│ └── WalkingState.hpp
├── Graphics/
│ ├── AnimControl.cpp
│ ├── AnimDrawable.cpp
│ ├── GGFont.cpp
│ ├── GraphDrawable.cpp
│ ├── GraphDrawable.hpp
│ ├── LightingShader.cpp
│ ├── PathDrawable.cpp
│ ├── PathDrawable.hpp
│ ├── ResourceManager.cpp
│ ├── SpriteSheet.cpp
│ ├── Text.cpp
│ ├── WalkboxDrawable.cpp
│ └── WalkboxDrawable.hpp
├── Input/
│ ├── CommandManager.cpp
│ └── InputMappings.cpp
├── Parsers/
│ ├── GGPackBufferStream.cpp
│ ├── Lip.cpp
│ ├── SavegameManager.cpp
│ ├── YackParser.cpp
│ └── YackTokenReader.cpp
├── Room/
│ ├── Room.cpp
│ ├── RoomLayer.cpp
│ ├── RoomScaling.cpp
│ ├── RoomTrigger.cpp
│ ├── RoomTrigger.hpp
│ ├── RoomTriggerThread.cpp
│ └── RoomTriggerThread.hpp
├── Scripting/
│ ├── ActorPack.hpp
│ ├── ActorWalk.cpp
│ ├── ActorWalk.hpp
│ ├── BnutPass.hpp
│ ├── DefaultScriptExecute.cpp
│ ├── DefaultScriptExecute.hpp
│ ├── DefaultVerbExecute.cpp
│ ├── DefaultVerbExecute.hpp
│ ├── GeneralPack.hpp
│ ├── ObjectPack.hpp
│ ├── PostWalk.cpp
│ ├── PostWalk.hpp
│ ├── ReachAnim.cpp
│ ├── ReachAnim.hpp
│ ├── RoomPack.hpp
│ ├── ScriptEngine.cpp
│ ├── ScriptEngine.inl
│ ├── SetDefaultVerb.cpp
│ ├── SetDefaultVerb.hpp
│ ├── SoundPack.hpp
│ ├── SystemPack.hpp
│ ├── VerbExecuteFunction.cpp
│ └── VerbExecuteFunction.hpp
├── System/
│ ├── DebugTools/
│ │ ├── ActorTools.cpp
│ │ ├── ActorTools.hpp
│ │ ├── CameraTools.cpp
│ │ ├── CameraTools.hpp
│ │ ├── Console.cpp
│ │ ├── Console.hpp
│ │ ├── ConsoleTools.cpp
│ │ ├── ConsoleTools.hpp
│ │ ├── DebugControls.cpp
│ │ ├── DebugControls.hpp
│ │ ├── DebugTools.cpp
│ │ ├── DebugTools.hpp
│ │ ├── GeneralTools.cpp
│ │ ├── GeneralTools.hpp
│ │ ├── ObjectTools.cpp
│ │ ├── ObjectTools.hpp
│ │ ├── PreferencesTools.cpp
│ │ ├── PreferencesTools.hpp
│ │ ├── RoomTools.cpp
│ │ ├── RoomTools.hpp
│ │ ├── SoundTools.cpp
│ │ ├── SoundTools.hpp
│ │ ├── TextureTools.cpp
│ │ ├── TextureTools.hpp
│ │ ├── ThreadTools.cpp
│ │ └── ThreadTools.hpp
│ └── Logger.cpp
├── UI/
│ ├── Button.cpp
│ ├── Button.hpp
│ ├── Checkbox.cpp
│ ├── Checkbox.hpp
│ ├── Control.cpp
│ ├── Control.hpp
│ ├── ControlConstants.hpp
│ ├── HelpDialog.cpp
│ ├── HelpDialog.hpp
│ ├── OptionsDialog.cpp
│ ├── QuitDialog.cpp
│ ├── SaveLoadDialog.cpp
│ ├── Slider.cpp
│ ├── Slider.hpp
│ ├── StartScreenDialog.cpp
│ ├── SwitchButton.cpp
│ └── SwitchButton.hpp
├── Util/
│ ├── BTEACrypto.cpp
│ ├── Dumper.hpp
│ ├── RandomNumberGenerator.cpp
│ ├── Util.cpp
│ └── Util.hpp
└── main.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
# Auto detect text files and perform LF normalization
* text=auto
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Desktop (please complete the following information):**
- OS: [e.g. macOS]
- Version [e.g. Mojave 10.14.1]
**Additional context**
Add any other context about the problem here.
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
# Pull Request Template
## Description
Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
Fixes #(issue)
## Type of change
Please delete options that are not relevant.
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] This change requires a documentation update
## How Has This Been Tested?
Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration
- [ ] Test A
- [ ] Test B
**Test Configuration**:
* Operating system:
## Checklist:
- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my own code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my feature works
- [ ] Any dependent changes have been merged and published in downstream modules
================================================
FILE: .github/workflows/Build.yml
================================================
name: Build
on:
push:
pull_request:
env:
BUILD_TYPE: Release
jobs:
linux:
runs-on: ubuntu-20.04
name: 🐧 Ubuntu 20.04
steps:
- name: 🧰 Checkout
uses: actions/checkout@v2
with:
fetch-depth: 0
submodules: true
- name: ⬇️ Install dependencies
run: |
sudo apt-get update
sudo apt-get install -y \
build-essential \
gcc-10 \
g++-10 \
libglew-dev \
libsdl2-dev \
libsdl2-mixer-dev \
libglm-dev
- name: Create Build Environment
run: cmake -E make_directory ${{runner.workspace}}/build
- name: Configure CMake
shell: bash
env:
CC: gcc-10
CXX: g++-10
working-directory: ${{runner.workspace}}/build
run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
- name: Build
working-directory: ${{runner.workspace}}/build
shell: bash
env:
CC: gcc-10
CXX: g++-10
run: cmake --build . --config $BUILD_TYPE --target package
- name: 📦 Upload Ubuntu package to release
uses: svenstaro/upload-release-action@v2
if: startsWith(github.ref, 'refs/tags/v')
with:
repo_token: ${{ secrets.GITHUB_TOKEN }}
file: ${{runner.workspace}}/build/*.zip
tag: ${{ github.ref }}
overwrite: true
file_glob: true
- name: 📦 Upload Ubuntu package
uses: actions/upload-artifact@v2
with:
name: engge-linux
path: ${{runner.workspace}}/build/*.zip
win:
runs-on: windows-latest
name: 🟦 Windows x64
steps:
- name: 🧰 Checkout
uses: actions/checkout@v2
with:
fetch-depth: 0
submodules: true
- name: ⬇️ Install dependencies
run: vcpkg install freetype:x64-windows glew:x64-windows sdl2:x64-windows sdl2-mixer:x64-windows glm:x64-windows
- name: Create Build Environment
run: cmake -E make_directory ${{runner.workspace}}/build
- name: Configure CMake Windows
shell: bash
working-directory: ${{runner.workspace}}/build
run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" -DVCPKG_BIN_DIR="c:/vcpkg/installed/x64-windows/bin"
- name: Build
working-directory: ${{runner.workspace}}/build
shell: bash
run: cmake --build . --config $BUILD_TYPE --target package
- name: 📦 Upload Windows package to release
uses: svenstaro/upload-release-action@v2
if: startsWith(github.ref, 'refs/tags/v')
with:
repo_token: ${{ secrets.GITHUB_TOKEN }}
file: ${{runner.workspace}}/build/*.zip
tag: ${{ github.ref }}
overwrite: true
file_glob: true
- name: 📦 Upload Portable ZIP
uses: actions/upload-artifact@v2
with:
name: engge-win
path: ${{runner.workspace}}/build/*.zip
macos-build:
runs-on: macos-11.0
name: 🍎 macOS 11.0
steps:
- name: 🧰 Checkout
uses: actions/checkout@v2
with:
fetch-depth: 0
submodules: true
- name: ⬇️ Install dependencies
run: brew install glew sdl2 sdl2_mixer glm
- name: Create Build Environment
run: cmake -E make_directory ${{runner.workspace}}/build
- name: Configure CMake
shell: bash
working-directory: ${{runner.workspace}}/build
run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
- name: Build
working-directory: ${{runner.workspace}}/build
shell: bash
run: |
cmake --build . --config $BUILD_TYPE --target package
- name: 📦 Upload macOS package to release
uses: svenstaro/upload-release-action@v2
if: startsWith(github.ref, 'refs/tags/v')
with:
repo_token: ${{ secrets.GITHUB_TOKEN }}
file: ${{runner.workspace}}/build/*.zip
tag: ${{ github.ref }}
overwrite: true
file_glob: true
- name: 📦 Upload Portable ZIP
uses: actions/upload-artifact@v2
with:
name: engge-macOS
path: ${{runner.workspace}}/build/*.zip
================================================
FILE: .gitignore
================================================
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
.idea/*
.vscode/*
build/**
cmake-build-*/**
resources/**
extlibs/squirrel/build/**
ThimbleweedPark.ggpack1
ThimbleweedPark.ggpack2
log.txt
imgui.ini
.DS_Store
extlibs/ngf/**
================================================
FILE: .gitmodules
================================================
[submodule "extlibs/ngf"]
path = extlibs/ngf
url = https://github.com/scemino/EnggeFramework
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.5)
include(appInfo.cmake)
project("${appName}" LANGUAGES CXX)
# Compiler flags
set (SQ_DISABLE_INSTALLER ON)
set (NGF_BUILD_DEMOS OFF)
set (NGF_BUILD_EXAMPLES OFF)
set (NGF_BUILD_TESTS OFF)
set (NGF_BUILD_DOCUMENTATION OFF)
# Sources
add_subdirectory(src)
add_subdirectory(extlibs/squirrel)
add_subdirectory(extlibs/ngf/)
# Install misc. files
install(FILES LICENSE DESTINATION .)
# Copy dependencies
if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
install(FILES "${VCPKG_BIN_DIR}/glew32.dll" DESTINATION "bin/")
install(FILES "${VCPKG_BIN_DIR}/SDL2.dll" DESTINATION "bin/")
endif()
target_compile_features("${appName}" PRIVATE cxx_std_17)
set_target_properties("${appName}" PROPERTIES CXX_EXTENSIONS OFF)
if (MSVC)
# TODO: warning level 4 and all warnings as errors
# target_compile_options("${appName}" PRIVATE /W4 /WX)
else()
# lots of warnings and all warnings as errors
# TODO: treat warnings as errors: -Werror
# -pedantic-errors reports error library {fmt}
target_compile_options("${appName}" PRIVATE -Wall -Wextra)
endif()
# Configure CPack
function(get_short_system_name variable)
if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
set(${variable} "OSX" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
set(${variable} "Win64" PARENT_SCOPE)
else()
set(${variable} "${CMAKE_SYSTEM_NAME}" PARENT_SCOPE)
endif()
endfunction()
set(CPACK_PACKAGE_NAME ${appName})
string(REPLACE " " "-" CPACK_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
get_short_system_name(CPACK_SYSTEM_NAME)
set(CPACK_PACKAGE_VERSION_MAJOR ${appVersionMajor})
set(CPACK_PACKAGE_VERSION_MINOR ${appVersionMinor})
set(CPACK_PACKAGE_VERSION_PATCH ${appVersionPatch})
set(CPACK_PACKAGE_VERSION ${appVersion})
set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_SYSTEM_NAME}")
string(TOLOWER "${CPACK_PACKAGE_FILE_NAME}" CPACK_PACKAGE_FILE_NAME)
set(CPACK_GENERATOR ZIP)
# Run CPack
include(CPack)
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, sex characteristics, gender identity and expression,
level of experience, education, socio-economic status, nationality, personal
appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment
include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community include using an official project e-mail
address, posting via an official social media account, or acting as an appointed
representative at an online or offline event. Representation of a project may be
further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team at scemino74@gmail.com. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see
https://www.contributor-covenant.org/faq
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing
I really appreciate every contribution and suggestion, it can be code, documentation.
By the way, if anyone is interested to propose me a logo, don't hesitate to contact me.
Feel free to ask questions as well.
## Issues and suggestions
If you experience an issue or want to suggest a feature, [create an issue](https://github.com/scemino/engge/issues/new/choose)
to let others know. If you want to fix the issue by yourself, open a pull request instead.
## Contributing code
Try to match the coding style that's already present. I will try to create a .clang-format file that respect the current coding style.
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2018 scemino
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.MD
================================================
# engge
[](https://github.com/scemino/engge/actions)
[](https://www.codefactor.io/repository/github/scemino/engge)
[](https://twitter.com/engge_the_game)
:warning: This project is not supported anymore, but no worries I created a new project [engge2](https://github.com/scemino/engge2) :warning:
engge is an adventure game engine able to run Thimbleweed Park.
It's an open source remake of Thimbleweed Park's engine.
The game is playable. What does it mean? Yes, it means you can play the game and you should be able to finish it. No, it doesn't mean that you won't face any bug.
It's still a project in active development, and there are a lot of issues, don't hesitate to contribute or to fill out a [bug report](https://github.com/scemino/engge/issues/new/choose).
[](https://www.youtube.com/watch?v=09VEPoX5SZk&t=1s)
## Download
You can download the prebuilt binaries for Window, Linux and macOS [here](https://github.com/scemino/engge/releases).
Look at the assets 😉
## Prerequisites
* Buy [Thimbleweed park](https://thimbleweedpark.com)
* Go to your installation folder and copy these files: **ThimbleweedPark.ggpack1** and **ThimbleweedPark.ggpack2** to **engge** directory
* **engge** has these following dependencies
* [ngf](https://github.com/scemino/EnggeFramework/): Engge Framework is a C++ framework based on **SDL2**.
* [squirrel](http://www.squirrel-lang.org/): programming language Squirrel, this repository contains a modified version of the official squirrel library in *extlibs/squirrel*
* [spdlog](https://github.com/gabime/spdlog): Fast C++ logging library.
## Building
Have a look to this [page](https://github.com/scemino/engge/wiki/Build-instructions).
## Running
Just type `./build/src/engge`, don't forget the prerequisites.
---
[JetBrains](https://www.jetbrains.com/) have been kind enough to supply me with a free Open Source license of [CLion](https://www.jetbrains.com/clion).
================================================
FILE: appInfo.cmake
================================================
set(appName "engge")
set(appVersionMajor 0)
set(appVersionMinor 8)
set(appVersionPatch 0)
set(appVersionSuffix "beta")
set(appVersion "${appVersionMajor}.${appVersionMinor}.${appVersionPatch}-${appVersionSuffix}")
================================================
FILE: extlibs/spdlog/include/spdlog/async.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
//
// Async logging using global thread pool
// All loggers created here share same global thread pool.
// Each log message is pushed to a queue along withe a shared pointer to the
// logger.
// If a logger deleted while having pending messages in the queue, it's actual
// destruction will defer
// until all its messages are processed by the thread pool.
// This is because each message in the queue holds a shared_ptr to the
// originating logger.
#include "spdlog/async_logger.h"
#include "spdlog/details/registry.h"
#include "spdlog/details/thread_pool.h"
#include <memory>
#include <mutex>
#include <functional>
namespace spdlog {
namespace details {
static const size_t default_async_q_size = 8192;
}
// async logger factory - creates async loggers backed with thread pool.
// if a global thread pool doesn't already exist, create it with default queue
// size of 8192 items and single thread.
template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl
{
template<typename Sink, typename... SinkArgs>
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
{
auto ®istry_inst = details::registry::instance();
// create global thread pool if not already exists..
std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
auto tp = registry_inst.get_tp();
if (tp == nullptr)
{
tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1);
registry_inst.set_tp(tp);
}
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
registry_inst.initialize_logger(new_logger);
return new_logger;
}
};
using async_factory = async_factory_impl<async_overflow_policy::block>;
using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
{
return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
}
template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
{
return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
}
// set global thread pool.
inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
{
auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start);
details::registry::instance().set_tp(std::move(tp));
}
// set global thread pool.
inline void init_thread_pool(size_t q_size, size_t thread_count)
{
init_thread_pool(q_size, thread_count, [] {});
}
// get the global thread pool.
inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
{
return details::registry::instance().get_tp();
}
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/async_logger-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/async_logger.h"
#endif
#include "spdlog/sinks/sink.h"
#include "spdlog/details/thread_pool.h"
#include <chrono>
#include <memory>
#include <string>
SPDLOG_INLINE spdlog::async_logger::async_logger(
std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
: async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
{}
SPDLOG_INLINE spdlog::async_logger::async_logger(
std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
: async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
{}
// send the log message to the thread pool
SPDLOG_INLINE void spdlog::async_logger::sink_it_(details::log_msg &msg)
{
if (auto pool_ptr = thread_pool_.lock())
{
pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
}
else
{
throw spdlog_ex("async log: thread pool doesn't exist anymore");
}
}
// send flush request to the thread pool
SPDLOG_INLINE void spdlog::async_logger::flush_()
{
if (auto pool_ptr = thread_pool_.lock())
{
pool_ptr->post_flush(shared_from_this(), overflow_policy_);
}
else
{
throw spdlog_ex("async flush: thread pool doesn't exist anymore");
}
}
//
// backend functions - called from the thread pool to do the actual job
//
SPDLOG_INLINE void spdlog::async_logger::backend_log_(const details::log_msg &incoming_log_msg)
{
try
{
for (auto &s : sinks_)
{
if (s->should_log(incoming_log_msg.level))
{
s->log(incoming_log_msg);
}
}
}
SPDLOG_LOGGER_CATCH()
if (should_flush_(incoming_log_msg))
{
backend_flush_();
}
}
SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
{
try
{
for (auto &sink : sinks_)
{
sink->flush();
}
}
SPDLOG_LOGGER_CATCH()
}
SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
{
auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_, overflow_policy_);
cloned->set_level(this->level());
cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->custom_err_handler_);
return cloned;
}
================================================
FILE: extlibs/spdlog/include/spdlog/async_logger.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
// Fast asynchronous logger.
// Uses pre allocated queue.
// Creates a single back thread to pop messages from the queue and log them.
//
// Upon each log write the logger:
// 1. Checks if its log level is enough to log the message
// 2. Push a new copy of the message to a queue (or block the caller until
// space is available in the queue)
// Upon destruction, logs all remaining messages in the queue before
// destructing..
#include "spdlog/logger.h"
namespace spdlog {
// Async overflow policy - block by default.
enum class async_overflow_policy
{
block, // Block until message can be enqueued
overrun_oldest // Discard oldest message in the queue if full when trying to
// add new item.
};
namespace details {
class thread_pool;
}
class async_logger final : public std::enable_shared_from_this<async_logger>, public logger
{
friend class details::thread_pool;
public:
template<typename It>
async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block)
: logger(std::move(logger_name), begin, end)
, thread_pool_(std::move(tp))
, overflow_policy_(overflow_policy)
{}
async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
std::shared_ptr<logger> clone(std::string new_name) override;
protected:
void sink_it_(details::log_msg &msg) override;
void flush_() override;
void backend_log_(const details::log_msg &incoming_log_msg);
void backend_flush_();
private:
std::weak_ptr<details::thread_pool> thread_pool_;
async_overflow_policy overflow_policy_;
};
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "async_logger-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/common-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/common.h"
#endif
namespace spdlog {
namespace level {
static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;
SPDLOG_INLINE string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
{
return level_string_views[l];
}
SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
{
return short_level_names[l];
}
SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT
{
int level = 0;
for (const auto &level_str : level_string_views)
{
if (level_str == name)
{
return static_cast<level::level_enum>(level);
}
level++;
}
return level::off;
}
} // namespace level
SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
: msg_(std::move(msg))
{}
SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
{
fmt::memory_buffer outbuf;
fmt::format_system_error(outbuf, last_errno, msg);
msg_ = fmt::to_string(outbuf);
}
SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT
{
return msg_.c_str();
}
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/common.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/tweakme.h"
#include <atomic>
#include <chrono>
#include <initializer_list>
#include <memory>
#include <exception>
#include <string>
#include <type_traits>
#include <functional>
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX // prevent windows redefining min/max
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#endif //_WIN32
#ifdef SPDLOG_COMPILED_LIB
#undef SPDLOG_HEADER_ONLY
#define SPDLOG_INLINE
#else
#define SPDLOG_HEADER_ONLY
#define SPDLOG_INLINE inline
#endif
#include "spdlog/fmt/fmt.h"
// visual studio upto 2013 does not support noexcept nor constexpr
#if defined(_MSC_VER) && (_MSC_VER < 1900)
#define SPDLOG_NOEXCEPT throw()
#define SPDLOG_CONSTEXPR
#else
#define SPDLOG_NOEXCEPT noexcept
#define SPDLOG_CONSTEXPR constexpr
#endif
#if defined(__GNUC__) || defined(__clang__)
#define SPDLOG_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define SPDLOG_DEPRECATED __declspec(deprecated)
#else
#define SPDLOG_DEPRECATED
#endif
// disable thread local on msvc 2013
#ifndef SPDLOG_NO_TLS
#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
#define SPDLOG_NO_TLS 1
#endif
#endif
#ifndef SPDLOG_FUNCTION
#define SPDLOG_FUNCTION __FUNCTION__
#endif
namespace spdlog {
class formatter;
namespace sinks {
class sink;
}
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
using filename_t = std::wstring;
#define SPDLOG_FILENAME_T(s) L##s
#else
using filename_t = std::string;
#define SPDLOG_FILENAME_T(s) s
#endif
using log_clock = std::chrono::system_clock;
using sink_ptr = std::shared_ptr<sinks::sink>;
using sinks_init_list = std::initializer_list<sink_ptr>;
using err_handler = std::function<void(const std::string &err_msg)>;
template<typename T>
using basic_string_view_t = fmt::basic_string_view<T>;
using string_view_t = basic_string_view_t<char>;
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
#ifndef _WIN32
#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
#else
using wstring_view_t = basic_string_view_t<wchar_t>;
template<typename T>
struct is_convertible_to_wstring_view : std::is_convertible<T, wstring_view_t> { };
#endif // _WIN32
#else
template<typename>
struct is_convertible_to_wstring_view : std::false_type { };
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
#if defined(SPDLOG_NO_ATOMIC_LEVELS)
using level_t = details::null_atomic_int;
#else
using level_t = std::atomic<int>;
#endif
#define SPDLOG_LEVEL_TRACE 0
#define SPDLOG_LEVEL_DEBUG 1
#define SPDLOG_LEVEL_INFO 2
#define SPDLOG_LEVEL_WARN 3
#define SPDLOG_LEVEL_ERROR 4
#define SPDLOG_LEVEL_CRITICAL 5
#define SPDLOG_LEVEL_OFF 6
#if !defined(SPDLOG_ACTIVE_LEVEL)
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
#endif
// Log level enum
namespace level {
enum level_enum
{
trace = SPDLOG_LEVEL_TRACE,
debug = SPDLOG_LEVEL_DEBUG,
info = SPDLOG_LEVEL_INFO,
warn = SPDLOG_LEVEL_WARN,
err = SPDLOG_LEVEL_ERROR,
critical = SPDLOG_LEVEL_CRITICAL,
off = SPDLOG_LEVEL_OFF,
};
#if !defined(SPDLOG_LEVEL_NAMES)
#define SPDLOG_LEVEL_NAMES \
{ \
"trace", "debug", "info", "warning", "error", "critical", "off" \
}
#endif
#if !defined(SPDLOG_SHORT_LEVEL_NAMES)
#define SPDLOG_SHORT_LEVEL_NAMES \
{ \
"T", "D", "I", "W", "E", "C", "O" \
}
#endif
string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
using level_hasher = std::hash<int>;
} // namespace level
//
// Color mode used by sinks with color support.
//
enum class color_mode
{
always,
automatic,
never
};
//
// Pattern time - specific time getting to use for pattern_formatter.
// local time by default
//
enum class pattern_time_type
{
local, // log localtime
utc // log utc
};
//
// Log exception
//
class spdlog_ex : public std::exception
{
public:
explicit spdlog_ex(std::string msg);
spdlog_ex(const std::string &msg, int last_errno);
const char *what() const SPDLOG_NOEXCEPT override;
private:
std::string msg_;
};
struct source_loc
{
SPDLOG_CONSTEXPR source_loc() = default;
SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)
: filename{filename_in}
, line{line_in}
, funcname{funcname_in}
{}
SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
{
return line == 0;
}
const char *filename{nullptr};
int line{0};
const char *funcname{nullptr};
};
namespace details {
// make_unique support for pre c++14
#if __cplusplus >= 201402L // C++14 and beyond
using std::make_unique;
#else
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
static_assert(!std::is_array<T>::value, "arrays not supported");
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
#endif
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "common-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/circular_q.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
// cirucal q view of std::vector.
#pragma once
#include <vector>
namespace spdlog {
namespace details {
template<typename T>
class circular_q
{
public:
using item_type = T;
explicit circular_q(size_t max_items)
: max_items_(max_items + 1) // one item is reserved as marker for full q
, v_(max_items_)
{}
// push back, overrun (oldest) item if no room left
void push_back(T &&item)
{
v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_;
if (tail_ == head_) // overrun last item if full
{
head_ = (head_ + 1) % max_items_;
++overrun_counter_;
}
}
// Pop item from front.
// If there are no elements in the container, the behavior is undefined.
void pop_front(T &popped_item)
{
popped_item = std::move(v_[head_]);
head_ = (head_ + 1) % max_items_;
}
bool empty()
{
return tail_ == head_;
}
bool full()
{
// head is ahead of the tail by 1
return ((tail_ + 1) % max_items_) == head_;
}
size_t overrun_counter() const
{
return overrun_counter_;
}
private:
size_t max_items_;
typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0;
std::vector<T> v_;
size_t overrun_counter_ = 0;
};
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/console_globals.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/details/null_mutex.h"
#include <mutex>
namespace spdlog {
namespace details {
struct console_mutex
{
using mutex_t = std::mutex;
static mutex_t &mutex()
{
static mutex_t s_mutex;
return s_mutex;
}
};
struct console_nullmutex
{
using mutex_t = null_mutex;
static mutex_t &mutex()
{
static mutex_t s_mutex;
return s_mutex;
}
};
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/file_helper-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/file_helper.h"
#endif
#include "spdlog/details/os.h"
#include <cerrno>
#include <chrono>
#include <cstdio>
#include <string>
#include <thread>
#include <tuple>
namespace spdlog {
namespace details {
SPDLOG_INLINE file_helper::~file_helper()
{
close();
}
SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
{
close();
auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
_filename = fname;
for (int tries = 0; tries < open_tries; ++tries)
{
if (!os::fopen_s(&fd_, fname, mode))
{
return;
}
details::os::sleep_for_millis(open_interval);
}
throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
}
SPDLOG_INLINE void file_helper::reopen(bool truncate)
{
if (_filename.empty())
{
throw spdlog_ex("Failed re opening file - was not opened before");
}
open(_filename, truncate);
}
SPDLOG_INLINE void file_helper::flush()
{
std::fflush(fd_);
}
SPDLOG_INLINE void file_helper::close()
{
if (fd_ != nullptr)
{
std::fclose(fd_);
fd_ = nullptr;
}
}
SPDLOG_INLINE void file_helper::write(const fmt::memory_buffer &buf)
{
size_t msg_size = buf.size();
auto data = buf.data();
if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
{
throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
}
}
SPDLOG_INLINE size_t file_helper::size() const
{
if (fd_ == nullptr)
{
throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
}
return os::filesize(fd_);
}
SPDLOG_INLINE const filename_t &file_helper::filename() const
{
return _filename;
}
SPDLOG_INLINE bool file_helper::file_exists(const filename_t &fname)
{
return os::file_exists(fname);
}
//
// return file path and its extension:
//
// "mylog.txt" => ("mylog", ".txt")
// "mylog" => ("mylog", "")
// "mylog." => ("mylog.", "")
// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
//
// the starting dot in filenames is ignored (hidden files):
//
// ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
{
auto ext_index = fname.rfind('.');
// no valid extension found - return whole path and empty string as
// extension
if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
{
return std::make_tuple(fname, filename_t());
}
// treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
auto folder_index = fname.rfind(details::os::folder_sep);
if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
{
return std::make_tuple(fname, filename_t());
}
// finally - return a valid base and extension tuple
return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
}
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/file_helper.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/common.h"
#include <tuple>
namespace spdlog {
namespace details {
// Helper class for file sinks.
// When failing to open a file, retry several times(5) with a delay interval(10 ms).
// Throw spdlog_ex exception on errors.
class file_helper
{
public:
explicit file_helper() = default;
file_helper(const file_helper &) = delete;
file_helper &operator=(const file_helper &) = delete;
~file_helper();
void open(const filename_t &fname, bool truncate = false);
void reopen(bool truncate);
void flush();
void close();
void write(const fmt::memory_buffer &buf);
size_t size() const;
const filename_t &filename() const;
static bool file_exists(const filename_t &fname);
//
// return file path and its extension:
//
// "mylog.txt" => ("mylog", ".txt")
// "mylog" => ("mylog", "")
// "mylog." => ("mylog.", "")
// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
//
// the starting dot in filenames is ignored (hidden files):
//
// ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname);
private:
const int open_tries = 5;
const int open_interval = 10;
std::FILE *fd_{nullptr};
filename_t _filename;
};
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "file_helper-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/fmt_helper.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include <chrono>
#include <type_traits>
#include "spdlog/fmt/fmt.h"
#include "spdlog/common.h"
// Some fmt helpers to efficiently format and pad ints and strings
namespace spdlog {
namespace details {
namespace fmt_helper {
template<size_t Buffer_Size>
inline spdlog::string_view_t to_string_view(const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT
{
return spdlog::string_view_t(buf.data(), buf.size());
}
template<size_t Buffer_Size1, size_t Buffer_Size2>
inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf, fmt::basic_memory_buffer<char, Buffer_Size2> &dest)
{
auto *buf_ptr = buf.data();
dest.append(buf_ptr, buf_ptr + buf.size());
}
template<size_t Buffer_Size>
inline void append_string_view(spdlog::string_view_t view, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
auto *buf_ptr = view.data();
if (buf_ptr != nullptr)
{
dest.append(buf_ptr, buf_ptr + view.size());
}
}
template<typename T, size_t Buffer_Size>
inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
fmt::format_int i(n);
dest.append(i.data(), i.data() + i.size());
}
template<typename T>
inline unsigned count_digits(T n)
{
using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
return static_cast<unsigned>(fmt::internal::count_digits(static_cast<count_type>(n)));
}
template<size_t Buffer_Size>
inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
if (n > 99)
{
append_int(n, dest);
}
else if (n > 9) // 10-99
{
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
}
else if (n >= 0) // 0-9
{
dest.push_back('0');
dest.push_back(static_cast<char>('0' + n));
}
else // negatives (unlikely, but just in case, let fmt deal with it)
{
fmt::format_to(dest, "{:02}", n);
}
}
template<typename T, size_t Buffer_Size>
inline void pad_uint(T n, unsigned int width, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
auto digits = count_digits(n);
if (width > digits)
{
const char *zeroes = "0000000000000000000";
dest.append(zeroes, zeroes + width - digits);
}
append_int(n, dest);
}
template<typename T, size_t Buffer_Size>
inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
pad_uint(n, 3, dest);
}
template<typename T, size_t Buffer_Size>
inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
pad_uint(n, 6, dest);
}
template<typename T, size_t Buffer_Size>
inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
pad_uint(n, 9, dest);
}
// return fraction of a second of the given time_point.
// e.g.
// fraction<std::milliseconds>(tp) -> will return the millis part of the second
template<typename ToDuration>
inline ToDuration time_fraction(log_clock::time_point tp)
{
using std::chrono::duration_cast;
using std::chrono::seconds;
auto duration = tp.time_since_epoch();
auto secs = duration_cast<seconds>(duration);
return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
}
} // namespace fmt_helper
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/log_msg-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/log_msg.h"
#endif
#include "spdlog/details/os.h"
namespace spdlog {
namespace details {
SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc, string_view_t logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
: logger_name(logger_name)
, level(lvl)
#ifndef SPDLOG_NO_DATETIME
, time(os::now())
#endif
#ifndef SPDLOG_NO_THREAD_ID
, thread_id(os::thread_id())
#endif
, source(loc)
, payload(msg)
{}
SPDLOG_INLINE log_msg::log_msg(string_view_t logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
: log_msg(source_loc{}, logger_name, lvl, msg)
{}
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/log_msg.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/common.h"
#include <string>
namespace spdlog {
namespace details {
struct log_msg
{
log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
log_msg(const log_msg &other) = default;
const string_view_t logger_name;
level::level_enum level{level::off};
log_clock::time_point time;
size_t thread_id{0};
// wrapping the formatted text with color (updated by pattern_formatter).
mutable size_t color_range_start{0};
mutable size_t color_range_end{0};
source_loc source;
const string_view_t payload;
};
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "log_msg-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/mpmc_blocking_q.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
// multi producer-multi consumer blocking queue.
// enqueue(..) - will block until room found to put the new message.
// enqueue_nowait(..) - will return immediately with false if no room left in
// the queue.
// dequeue_for(..) - will block until the queue is not empty or timeout have
// passed.
#include "spdlog/details/circular_q.h"
#include <condition_variable>
#include <mutex>
namespace spdlog {
namespace details {
template<typename T>
class mpmc_blocking_queue
{
public:
using item_type = T;
explicit mpmc_blocking_queue(size_t max_items)
: q_(max_items)
{}
#ifndef __MINGW32__
// try to enqueue and block if no room left
void enqueue(T &&item)
{
{
std::unique_lock<std::mutex> lock(queue_mutex_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); });
q_.push_back(std::move(item));
}
push_cv_.notify_one();
}
// enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item)
{
{
std::unique_lock<std::mutex> lock(queue_mutex_);
q_.push_back(std::move(item));
}
push_cv_.notify_one();
}
// try to dequeue item. if no item found. wait upto timeout and try again
// Return true, if succeeded dequeue item, false otherwise
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
{
{
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
return false;
}
q_.pop_front(popped_item);
}
pop_cv_.notify_one();
return true;
}
#else
// apparently mingw deadlocks if the mutex is released before cv.notify_one(),
// so release the mutex at the very end each function.
// try to enqueue and block if no room left
void enqueue(T &&item)
{
std::unique_lock<std::mutex> lock(queue_mutex_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); });
q_.push_back(std::move(item));
push_cv_.notify_one();
}
// enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item)
{
std::unique_lock<std::mutex> lock(queue_mutex_);
q_.push_back(std::move(item));
push_cv_.notify_one();
}
// try to dequeue item. if no item found. wait upto timeout and try again
// Return true, if succeeded dequeue item, false otherwise
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
{
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
return false;
}
q_.pop_front(popped_item);
pop_cv_.notify_one();
return true;
}
#endif
size_t overrun_counter()
{
std::unique_lock<std::mutex> lock(queue_mutex_);
return q_.overrun_counter();
}
private:
std::mutex queue_mutex_;
std::condition_variable push_cv_;
std::condition_variable pop_cv_;
spdlog::details::circular_q<T> q_;
};
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/null_mutex.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include <atomic>
// null, no cost dummy "mutex" and dummy "atomic" int
namespace spdlog {
namespace details {
struct null_mutex
{
void lock() {}
void unlock() {}
bool try_lock()
{
return true;
}
};
struct null_atomic_int
{
int value;
null_atomic_int() = default;
explicit null_atomic_int(int val)
: value(val)
{}
int load(std::memory_order) const
{
return value;
}
void store(int val)
{
value = val;
}
};
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/os-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/os.h"
#endif
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <string>
#include <thread>
#include <array>
#include <sys/stat.h>
#include <sys/types.h>
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX // prevent windows redefining min/max
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <io.h> // _get_osfhandle and _isatty support
#include <process.h> // _get_pid support
#include <windows.h>
#ifdef __MINGW32__
#include <share.h>
#endif
#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
#include <limits>
#endif
#else // unix
#include <fcntl.h>
#include <unistd.h>
#ifdef __linux__
#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
#elif __FreeBSD__
#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
#endif
#endif // unix
#ifndef __has_feature // Clang - feature checking macros.
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
namespace spdlog {
namespace details {
namespace os {
SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
{
#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
timespec ts;
::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
return std::chrono::time_point<log_clock, typename log_clock::duration>(
std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
#else
return log_clock::now();
#endif
}
SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
{
#ifdef _WIN32
std::tm tm;
localtime_s(&tm, &time_tt);
#else
std::tm tm;
localtime_r(&time_tt, &tm);
#endif
return tm;
}
SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT
{
std::time_t now_t = time(nullptr);
return localtime(now_t);
}
SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
{
#ifdef _WIN32
std::tm tm;
gmtime_s(&tm, &time_tt);
#else
std::tm tm;
gmtime_r(&time_tt, &tm);
#endif
return tm;
}
SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT
{
std::time_t now_t = time(nullptr);
return gmtime(now_t);
}
SPDLOG_INLINE void prevent_child_fd(FILE *f)
{
#ifdef _WIN32
#if !defined(__cplusplus_winrt)
auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(f)));
if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
throw spdlog_ex("SetHandleInformation failed", errno);
#endif
#else
auto fd = fileno(f);
if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
{
throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
}
#endif
}
// fopen_s on non windows for writing
SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
{
#ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES
*fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#else
*fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#endif
#else // unix
*fp = fopen((filename.c_str()), mode.c_str());
#endif
#ifdef SPDLOG_PREVENT_CHILD_FD
if (*fp != nullptr)
{
prevent_child_fd(*fp);
}
#endif
return *fp == nullptr;
}
SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
{
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return _wremove(filename.c_str());
#else
return std::remove(filename.c_str());
#endif
}
SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
{
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return _wrename(filename1.c_str(), filename2.c_str());
#else
return std::rename(filename1.c_str(), filename2.c_str());
#endif
}
// Return if file exists
SPDLOG_INLINE bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT
{
#ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES
auto attribs = GetFileAttributesW(filename.c_str());
#else
auto attribs = GetFileAttributesA(filename.c_str());
#endif
return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
#else // common linux/unix all have the stat system call
struct stat buffer;
return (::stat(filename.c_str(), &buffer) == 0);
#endif
}
// Return file size according to open FILE* object
SPDLOG_INLINE size_t filesize(FILE *f)
{
if (f == nullptr)
{
throw spdlog_ex("Failed getting file size. fd is null");
}
#if defined(_WIN32) && !defined(__CYGWIN__)
int fd = _fileno(f);
#if _WIN64 // 64 bits
__int64 ret = _filelengthi64(fd);
if (ret >= 0)
{
return static_cast<size_t>(ret);
}
#else // windows 32 bits
long ret = _filelength(fd);
if (ret >= 0)
{
return static_cast<size_t>(ret);
}
#endif
#else // unix
int fd = fileno(f);
// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
struct stat64 st;
if (fstat64(fd, &st) == 0)
{
return static_cast<size_t>(st.st_size);
}
#else // unix 32 bits or cygwin
struct stat st;
if (::fstat(fd, &st) == 0)
{
return static_cast<size_t>(st.st_size);
}
#endif
#endif
throw spdlog_ex("Failed getting file size from fd", errno);
}
// Return utc offset in minutes or throw spdlog_ex on failure
SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
{
#ifdef _WIN32
#if _WIN32_WINNT < _WIN32_WINNT_WS08
TIME_ZONE_INFORMATION tzinfo;
auto rv = GetTimeZoneInformation(&tzinfo);
#else
DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
auto rv = GetDynamicTimeZoneInformation(&tzinfo);
#endif
if (rv == TIME_ZONE_ID_INVALID)
throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
int offset = -tzinfo.Bias;
if (tm.tm_isdst)
{
offset -= tzinfo.DaylightBias;
}
else
{
offset -= tzinfo.StandardBias;
}
return offset;
#else
#if defined(sun) || defined(__sun) || defined(_AIX)
// 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
struct helper
{
static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
{
int local_year = localtm.tm_year + (1900 - 1);
int gmt_year = gmtm.tm_year + (1900 - 1);
long int days = (
// difference in day of year
localtm.tm_yday -
gmtm.tm_yday
// + intervening leap days
+ ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
// + difference in years * 365 */
+ (long int)(local_year - gmt_year) * 365);
long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
return secs;
}
};
auto offset_seconds = helper::calculate_gmt_offset(tm);
#else
auto offset_seconds = tm.tm_gmtoff;
#endif
return static_cast<int>(offset_seconds / 60);
#endif
}
// Return current thread id as size_t
// It exists because the std::this_thread::get_id() is much slower(especially
// under VS 2013)
SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
{
#ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId());
#elif __linux__
#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
#define SYS_gettid __NR_gettid
#endif
return static_cast<size_t>(syscall(SYS_gettid));
#elif __FreeBSD__
long tid;
thr_self(&tid);
return static_cast<size_t>(tid);
#elif __APPLE__
uint64_t tid;
pthread_threadid_np(nullptr, &tid);
return static_cast<size_t>(tid);
#else // Default to standard C++11 (other Unix)
return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
#endif
}
// Return current thread id as size_t (from thread local storage)
SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
{
#if defined(SPDLOG_NO_TLS)
return _thread_id();
#else // cache thread id in tls
static thread_local const size_t tid = _thread_id();
return tid;
#endif
}
// This is avoid msvc issue in sleep_for that happens if the clock changes.
// See https://github.com/gabime/spdlog/issues/609
SPDLOG_INLINE void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
{
#if defined(_WIN32)
::Sleep(milliseconds);
#else
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
#endif
}
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
{
fmt::memory_buffer buf;
wstr_to_utf8buf(filename, buf);
return fmt::to_string(buf);
}
#else
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
{
return filename;
}
#endif
SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
{
#ifdef _WIN32
return static_cast<int>(::GetCurrentProcessId());
#else
return static_cast<int>(::getpid());
#endif
}
// Determine if the terminal supports colors
// Source: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
{
#ifdef _WIN32
return true;
#else
static constexpr std::array<const char *, 14> Terms = {
"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"};
const char *env_p = std::getenv("TERM");
if (env_p == nullptr)
{
return false;
}
static const bool result =
std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
return result;
#endif
}
// Detrmine if the terminal attached
// Source: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
{
#ifdef _WIN32
return _isatty(_fileno(file)) != 0;
#else
return isatty(fileno(file)) != 0;
#endif
}
#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
SPDLOG_INLINE void wstr_to_utf8buf(basic_string_view_t<wchar_t> wstr, fmt::memory_buffer &target)
{
if (wstr.size() > static_cast<size_t>(std::numeric_limits<int>::max()))
{
throw spdlog::spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
}
int wstr_size = static_cast<int>(wstr.size());
if (wstr_size == 0)
{
target.resize(0);
return;
}
int result_size = static_cast<int>(target.capacity());
if ((wstr_size + 1) * 2 > result_size)
{
result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
}
if (result_size > 0)
{
target.resize(result_size);
result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
if (result_size > 0)
{
target.resize(result_size);
return;
}
}
throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
}
#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
} // namespace os
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/os.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/common.h"
#include <ctime> // std::time_t
namespace spdlog {
namespace details {
namespace os {
spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;
std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
std::tm localtime() SPDLOG_NOEXCEPT;
std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
std::tm gmtime() SPDLOG_NOEXCEPT;
// eol definition
#if !defined(SPDLOG_EOL)
#ifdef _WIN32
#define SPDLOG_EOL "\r\n"
#else
#define SPDLOG_EOL "\n"
#endif
#endif
SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
// folder separator
#ifdef _WIN32
const char folder_sep = '\\';
#else
SPDLOG_CONSTEXPR static const char folder_sep = '/';
#endif
void prevent_child_fd(FILE *f);
// fopen_s on non windows for writing
bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
int remove(const filename_t &filename) SPDLOG_NOEXCEPT;
int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;
// Return if file exists
bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
// Return file size according to open FILE* object
size_t filesize(FILE *f);
// Return utc offset in minutes or throw spdlog_ex on failure
int utc_minutes_offset(const std::tm &tm = details::os::localtime());
// Return current thread id as size_t
// It exists because the std::this_thread::get_id() is much slower(especially
// under VS 2013)
size_t _thread_id() SPDLOG_NOEXCEPT;
// Return current thread id as size_t (from thread local storage)
size_t thread_id() SPDLOG_NOEXCEPT;
// This is avoid msvc issue in sleep_for that happens if the clock changes.
// See https://github.com/gabime/spdlog/issues/609
void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT;
std::string filename_to_str(const filename_t &filename);
int pid() SPDLOG_NOEXCEPT;
// Determine if the terminal supports colors
// Source: https://github.com/agauniyal/rang/
bool is_color_terminal() SPDLOG_NOEXCEPT;
// Detrmine if the terminal attached
// Source: https://github.com/agauniyal/rang/
bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;
#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
void wstr_to_utf8buf(basic_string_view_t<wchar_t> wstr, fmt::memory_buffer &target);
#endif
} // namespace os
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "os-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/pattern_formatter-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/pattern_formatter.h"
#endif
#include "spdlog/details/fmt_helper.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
#include "spdlog/fmt/fmt.h"
#include "spdlog/formatter.h"
#include <array>
#include <chrono>
#include <ctime>
#include <cctype>
#include <cstring>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <utility>
#include <vector>
namespace spdlog {
namespace details {
///////////////////////////////////////////////////////////////////////
// name & level pattern appender
///////////////////////////////////////////////////////////////////////
class scoped_padder
{
public:
scoped_padder(size_t wrapped_size, const padding_info &padinfo, fmt::memory_buffer &dest)
: padinfo_(padinfo)
, dest_(dest)
{
if (padinfo_.width_ <= wrapped_size)
{
total_pad_ = 0;
return;
}
total_pad_ = padinfo.width_ - wrapped_size;
if (padinfo_.side_ == padding_info::left)
{
pad_it(total_pad_);
total_pad_ = 0;
}
else if (padinfo_.side_ == padding_info::center)
{
auto half_pad = total_pad_ / 2;
auto reminder = total_pad_ & 1;
pad_it(half_pad);
total_pad_ = half_pad + reminder; // for the right side
}
}
~scoped_padder()
{
if (total_pad_)
{
pad_it(total_pad_);
}
}
private:
void pad_it(size_t count)
{
// count = std::min(count, spaces_.size());
assert(count <= spaces_.size());
fmt_helper::append_string_view(string_view_t(spaces_.data(), count), dest_);
}
const padding_info &padinfo_;
fmt::memory_buffer &dest_;
size_t total_pad_;
string_view_t spaces_{" ", 64};
};
struct null_scoped_padder
{
null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, fmt::memory_buffer & /*dest*/) {}
};
template<typename ScopedPadder>
class name_formatter : public flag_formatter
{
public:
explicit name_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
ScopedPadder p(msg.logger_name.size(), padinfo_, dest);
fmt_helper::append_string_view(msg.logger_name, dest);
}
};
// log level appender
template<typename ScopedPadder>
class level_formatter : public flag_formatter
{
public:
explicit level_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
string_view_t &level_name = level::to_string_view(msg.level);
ScopedPadder p(level_name.size(), padinfo_, dest);
fmt_helper::append_string_view(level_name, dest);
}
};
// short log level appender
template<typename ScopedPadder>
class short_level_formatter : public flag_formatter
{
public:
explicit short_level_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
string_view_t level_name{level::to_short_c_str(msg.level)};
ScopedPadder p(level_name.size(), padinfo_, dest);
fmt_helper::append_string_view(level_name, dest);
}
};
///////////////////////////////////////////////////////////////////////
// Date time pattern appenders
///////////////////////////////////////////////////////////////////////
static const char *ampm(const tm &t)
{
return t.tm_hour >= 12 ? "PM" : "AM";
}
static int to12h(const tm &t)
{
return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
}
// Abbreviated weekday name
static std::array<const char *, 7> days{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
template<typename ScopedPadder>
class a_formatter : public flag_formatter
{
public:
explicit a_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{days[static_cast<size_t>(tm_time.tm_wday)]};
ScopedPadder p(field_value.size(), padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
}
};
// Full weekday name
static std::array<const char *, 7> full_days{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
template<typename ScopedPadder>
class A_formatter : public flag_formatter
{
public:
explicit A_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{full_days[static_cast<size_t>(tm_time.tm_wday)]};
ScopedPadder p(field_value.size(), padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
}
};
// Abbreviated month
static const std::array<const char *, 12> months{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"};
template<typename ScopedPadder>
class b_formatter : public flag_formatter
{
public:
explicit b_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{months[static_cast<size_t>(tm_time.tm_mon)]};
ScopedPadder p(field_value.size(), padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
}
};
// Full month name
static const std::array<const char *, 12> full_months{
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
template<typename ScopedPadder>
class B_formatter : public flag_formatter
{
public:
explicit B_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{full_months[static_cast<size_t>(tm_time.tm_mon)]};
ScopedPadder p(field_value.size(), padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
}
};
// Date and time representation (Thu Aug 23 15:35:46 2014)
template<typename ScopedPadder>
class c_formatter final : public flag_formatter
{
public:
explicit c_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 24;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_string_view(days[static_cast<size_t>(tm_time.tm_wday)], dest);
dest.push_back(' ');
fmt_helper::append_string_view(months[static_cast<size_t>(tm_time.tm_mon)], dest);
dest.push_back(' ');
fmt_helper::append_int(tm_time.tm_mday, dest);
dest.push_back(' ');
// time
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, dest);
dest.push_back(' ');
fmt_helper::append_int(tm_time.tm_year + 1900, dest);
}
};
// year - 2 digit
template<typename ScopedPadder>
class C_formatter final : public flag_formatter
{
public:
explicit C_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_year % 100, dest);
}
};
// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
template<typename ScopedPadder>
class D_formatter final : public flag_formatter
{
public:
explicit D_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 10;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mon + 1, dest);
dest.push_back('/');
fmt_helper::pad2(tm_time.tm_mday, dest);
dest.push_back('/');
fmt_helper::pad2(tm_time.tm_year % 100, dest);
}
};
// year - 4 digit
template<typename ScopedPadder>
class Y_formatter final : public flag_formatter
{
public:
explicit Y_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 4;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(tm_time.tm_year + 1900, dest);
}
};
// month 1-12
template<typename ScopedPadder>
class m_formatter final : public flag_formatter
{
public:
explicit m_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mon + 1, dest);
}
};
// day of month 1-31
template<typename ScopedPadder>
class d_formatter final : public flag_formatter
{
public:
explicit d_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mday, dest);
}
};
// hours in 24 format 0-23
template<typename ScopedPadder>
class H_formatter final : public flag_formatter
{
public:
explicit H_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
}
};
// hours in 12 format 1-12
template<typename ScopedPadder>
class I_formatter final : public flag_formatter
{
public:
explicit I_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(to12h(tm_time), dest);
}
};
// minutes 0-59
template<typename ScopedPadder>
class M_formatter final : public flag_formatter
{
public:
explicit M_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_min, dest);
}
};
// seconds 0-59
template<typename ScopedPadder>
class S_formatter final : public flag_formatter
{
public:
explicit S_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_sec, dest);
}
};
// milliseconds
template<typename ScopedPadder>
class e_formatter final : public flag_formatter
{
public:
explicit e_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
const size_t field_size = 3;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
}
};
// microseconds
template<typename ScopedPadder>
class f_formatter final : public flag_formatter
{
public:
explicit f_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
const size_t field_size = 6;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
}
};
// nanoseconds
template<typename ScopedPadder>
class F_formatter final : public flag_formatter
{
public:
explicit F_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
const size_t field_size = 9;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad9(static_cast<size_t>(ns.count()), dest);
}
};
// seconds since epoch
template<typename ScopedPadder>
class E_formatter final : public flag_formatter
{
public:
explicit E_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
const size_t field_size = 10;
ScopedPadder p(field_size, padinfo_, dest);
auto duration = msg.time.time_since_epoch();
auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
fmt_helper::append_int(seconds, dest);
}
};
// AM/PM
template<typename ScopedPadder>
class p_formatter final : public flag_formatter
{
public:
explicit p_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_string_view(ampm(tm_time), dest);
}
};
// 12 hour clock 02:55:02 pm
template<typename ScopedPadder>
class r_formatter final : public flag_formatter
{
public:
explicit r_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 11;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(to12h(tm_time), dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, dest);
dest.push_back(' ');
fmt_helper::append_string_view(ampm(tm_time), dest);
}
};
// 24-hour HH:MM time, equivalent to %H:%M
template<typename ScopedPadder>
class R_formatter final : public flag_formatter
{
public:
explicit R_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 5;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
}
};
// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
template<typename ScopedPadder>
class T_formatter final : public flag_formatter
{
public:
explicit T_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 8;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, dest);
}
};
// ISO 8601 offset from UTC in timezone (+-HH:MM)
template<typename ScopedPadder>
class z_formatter final : public flag_formatter
{
public:
explicit z_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
z_formatter() = default;
z_formatter(const z_formatter &) = delete;
z_formatter &operator=(const z_formatter &) = delete;
void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 6;
ScopedPadder p(field_size, padinfo_, dest);
#ifdef _WIN32
int total_minutes = get_cached_offset(msg, tm_time);
#else
// No need to chache under gcc,
// it is very fast (already stored in tm.tm_gmtoff)
(void)(msg);
int total_minutes = os::utc_minutes_offset(tm_time);
#endif
bool is_negative = total_minutes < 0;
if (is_negative)
{
total_minutes = -total_minutes;
dest.push_back('-');
}
else
{
dest.push_back('+');
}
fmt_helper::pad2(total_minutes / 60, dest); // hours
dest.push_back(':');
fmt_helper::pad2(total_minutes % 60, dest); // minutes
}
private:
log_clock::time_point last_update_{std::chrono::seconds(0)};
#ifdef _WIN32
int offset_minutes_{0};
int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
{
// refresh every 10 seconds
if (msg.time - last_update_ >= std::chrono::seconds(10))
{
offset_minutes_ = os::utc_minutes_offset(tm_time);
last_update_ = msg.time;
}
return offset_minutes_;
}
#endif
};
// Thread id
template<typename ScopedPadder>
class t_formatter final : public flag_formatter
{
public:
explicit t_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
const auto field_size = fmt_helper::count_digits(msg.thread_id);
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(msg.thread_id, dest);
}
};
// Current pid
template<typename ScopedPadder>
class pid_formatter final : public flag_formatter
{
public:
explicit pid_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
{
const auto pid = static_cast<uint32_t>(details::os::pid());
auto field_size = fmt_helper::count_digits(pid);
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(pid, dest);
}
};
template<typename ScopedPadder>
class v_formatter final : public flag_formatter
{
public:
explicit v_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
ScopedPadder p(msg.payload.size(), padinfo_, dest);
fmt_helper::append_string_view(msg.payload, dest);
}
};
class ch_formatter final : public flag_formatter
{
public:
explicit ch_formatter(char ch)
: ch_(ch)
{}
void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
{
dest.push_back(ch_);
}
private:
char ch_;
};
// aggregate user chars to display as is
class aggregate_formatter final : public flag_formatter
{
public:
aggregate_formatter() = default;
void add_ch(char ch)
{
str_ += ch;
}
void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
{
fmt_helper::append_string_view(str_, dest);
}
private:
std::string str_;
};
// mark the color range. expect it to be in the form of "%^colored text%$"
class color_start_formatter final : public flag_formatter
{
public:
explicit color_start_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
msg.color_range_start = dest.size();
}
};
class color_stop_formatter final : public flag_formatter
{
public:
explicit color_stop_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
msg.color_range_end = dest.size();
}
};
// print source location
template<typename ScopedPadder>
class source_location_formatter final : public flag_formatter
{
public:
explicit source_location_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
if (msg.source.empty())
{
return;
}
size_t text_size =
padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) + fmt_helper::count_digits(msg.source.line) + 1 : 0;
ScopedPadder p(text_size, padinfo_, dest);
fmt_helper::append_string_view(msg.source.filename, dest);
dest.push_back(':');
fmt_helper::append_int(msg.source.line, dest);
}
};
// print source filename
template<typename ScopedPadder>
class source_filename_formatter final : public flag_formatter
{
public:
explicit source_filename_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
if (msg.source.empty())
{
return;
}
size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) : 0;
ScopedPadder p(text_size, padinfo_, dest);
fmt_helper::append_string_view(msg.source.filename, dest);
}
};
template<typename ScopedPadder>
class short_filename_formatter final : public flag_formatter
{
public:
explicit short_filename_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
static const char *basename(const char *filename)
{
const char *rv = std::strrchr(filename, os::folder_sep);
return rv != nullptr ? rv + 1 : filename;
}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
if (msg.source.empty())
{
return;
}
auto filename = basename(msg.source.filename);
size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(filename) : 0;
ScopedPadder p(text_size, padinfo_, dest);
fmt_helper::append_string_view(filename, dest);
}
};
template<typename ScopedPadder>
class source_linenum_formatter final : public flag_formatter
{
public:
explicit source_linenum_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
if (msg.source.empty())
{
return;
}
auto field_size = fmt_helper::count_digits(msg.source.line);
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(msg.source.line, dest);
}
};
// print source funcname
template<typename ScopedPadder>
class source_funcname_formatter final : public flag_formatter
{
public:
explicit source_funcname_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
if (msg.source.empty())
{
return;
}
size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.funcname) : 0;
ScopedPadder p(text_size, padinfo_, dest);
fmt_helper::append_string_view(msg.source.funcname, dest);
}
};
// print elapsed time since last message
template<typename ScopedPadder, typename Units>
class elapsed_formatter final : public flag_formatter
{
public:
using DurationUnits = Units;
explicit elapsed_formatter(padding_info padinfo)
: flag_formatter(padinfo)
, last_message_time_(log_clock::now())
{}
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
auto delta = msg.time - last_message_time_;
auto delta_units = std::chrono::duration_cast<DurationUnits>(delta);
last_message_time_ = msg.time;
ScopedPadder p(6, padinfo_, dest);
fmt_helper::pad6(static_cast<size_t>(delta_units.count()), dest);
}
protected:
log_clock::time_point last_message_time_;
};
// Full info formatter
// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
class full_formatter final : public flag_formatter
{
public:
explicit full_formatter(padding_info padinfo)
: flag_formatter(padinfo)
{}
void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
using std::chrono::duration_cast;
using std::chrono::milliseconds;
using std::chrono::seconds;
#ifndef SPDLOG_NO_DATETIME
// cache the date/time part for the next second.
auto duration = msg.time.time_since_epoch();
auto secs = duration_cast<seconds>(duration);
if (cache_timestamp_ != secs || cached_datetime_.size() == 0)
{
cached_datetime_.clear();
cached_datetime_.push_back('[');
fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
cached_datetime_.push_back('-');
fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
cached_datetime_.push_back('-');
fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
cached_datetime_.push_back(' ');
fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
cached_datetime_.push_back(':');
fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
cached_datetime_.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
cached_datetime_.push_back('.');
cache_timestamp_ = secs;
}
fmt_helper::append_buf(cached_datetime_, dest);
auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
dest.push_back(']');
dest.push_back(' ');
#else // no datetime needed
(void)tm_time;
#endif
#ifndef SPDLOG_NO_NAME
if (msg.logger_name.size() > 0)
{
dest.push_back('[');
// fmt_helper::append_str(*msg.logger_name, dest);
fmt_helper::append_string_view(msg.logger_name, dest);
dest.push_back(']');
dest.push_back(' ');
}
#endif
dest.push_back('[');
// wrap the level name with color
msg.color_range_start = dest.size();
// fmt_helper::append_string_view(level::to_c_str(msg.level), dest);
fmt_helper::append_string_view(level::to_string_view(msg.level), dest);
msg.color_range_end = dest.size();
dest.push_back(']');
dest.push_back(' ');
// add source location if present
if (!msg.source.empty())
{
dest.push_back('[');
const char *filename = details::short_filename_formatter<details::null_scoped_padder>::basename(msg.source.filename);
fmt_helper::append_string_view(filename, dest);
dest.push_back(':');
fmt_helper::append_int(msg.source.line, dest);
dest.push_back(']');
dest.push_back(' ');
}
// fmt_helper::append_string_view(msg.msg(), dest);
fmt_helper::append_string_view(msg.payload, dest);
}
private:
std::chrono::seconds cache_timestamp_{0};
fmt::basic_memory_buffer<char, 128> cached_datetime_;
};
} // namespace details
SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, pattern_time_type time_type, std::string eol)
: pattern_(std::move(pattern))
, eol_(std::move(eol))
, pattern_time_type_(time_type)
, last_log_secs_(0)
{
std::memset(&cached_tm_, 0, sizeof(cached_tm_));
compile_pattern_(pattern_);
}
// use by default full formatter for if pattern is not given
SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol)
: pattern_("%+")
, eol_(std::move(eol))
, pattern_time_type_(time_type)
, last_log_secs_(0)
{
std::memset(&cached_tm_, 0, sizeof(cached_tm_));
formatters_.push_back(details::make_unique<details::full_formatter>(details::padding_info{}));
}
SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
{
return details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_);
}
SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, fmt::memory_buffer &dest)
{
#ifndef SPDLOG_NO_DATETIME
auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
if (secs != last_log_secs_)
{
cached_tm_ = get_time_(msg);
last_log_secs_ = secs;
}
#endif
for (auto &f : formatters_)
{
f->format(msg, cached_tm_, dest);
}
// write eol
details::fmt_helper::append_string_view(eol_, dest);
}
SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg)
{
if (pattern_time_type_ == pattern_time_type::local)
{
return details::os::localtime(log_clock::to_time_t(msg.time));
}
return details::os::gmtime(log_clock::to_time_t(msg.time));
}
template<typename Padder>
SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding)
{
switch (flag)
{
case ('+'): // default formatter
formatters_.push_back(details::make_unique<details::full_formatter>(padding));
break;
case 'n': // logger name
formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding));
break;
case 'l': // level
formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding));
break;
case 'L': // short level
formatters_.push_back(details::make_unique<details::short_level_formatter<Padder>>(padding));
break;
case ('t'): // thread id
formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding));
break;
case ('v'): // the message text
formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding));
break;
case ('a'): // weekday
formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding));
break;
case ('A'): // short weekday
formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding));
break;
case ('b'):
case ('h'): // month
formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding));
break;
case ('B'): // short month
formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding));
break;
case ('c'): // datetime
formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding));
break;
case ('C'): // year 2 digits
formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding));
break;
case ('Y'): // year 4 digits
formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding));
break;
case ('D'):
case ('x'): // datetime MM/DD/YY
formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding));
break;
case ('m'): // month 1-12
formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding));
break;
case ('d'): // day of month 1-31
formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding));
break;
case ('H'): // hours 24
formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding));
break;
case ('I'): // hours 12
formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding));
break;
case ('M'): // minutes
formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding));
break;
case ('S'): // seconds
formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding));
break;
case ('e'): // milliseconds
formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding));
break;
case ('f'): // microseconds
formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding));
break;
case ('F'): // nanoseconds
formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding));
break;
case ('E'): // seconds since epoch
formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding));
break;
case ('p'): // am/pm
formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding));
break;
case ('r'): // 12 hour clock 02:55:02 pm
formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding));
break;
case ('R'): // 24-hour HH:MM time
formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding));
break;
case ('T'):
case ('X'): // ISO 8601 time format (HH:MM:SS)
formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding));
break;
case ('z'): // timezone
formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding));
break;
case ('P'): // pid
formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding));
break;
case ('^'): // color range start
formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
break;
case ('$'): // color range end
formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
break;
case ('@'): // source location (filename:filenumber)
formatters_.push_back(details::make_unique<details::source_location_formatter<Padder>>(padding));
break;
case ('s'): // short source filename - without directory name
formatters_.push_back(details::make_unique<details::short_filename_formatter<Padder>>(padding));
break;
case ('g'): // full source filename
formatters_.push_back(details::make_unique<details::source_filename_formatter<Padder>>(padding));
break;
case ('#'): // source line number
formatters_.push_back(details::make_unique<details::source_linenum_formatter<Padder>>(padding));
break;
case ('!'): // source funcname
formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding));
break;
case ('%'): // % char
formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
break;
case ('u'): // elapsed time since last log message in nanos
formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(padding));
break;
case ('i'): // elapsed time since last log message in micros
formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(padding));
break;
case ('o'): // elapsed time since last log message in millis
formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(padding));
break;
case ('O'): // elapsed time since last log message in seconds
formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(padding));
break;
default: // Unknown flag appears as is
auto unknown_flag = details::make_unique<details::aggregate_formatter>();
unknown_flag->add_ch('%');
unknown_flag->add_ch(flag);
formatters_.push_back((std::move(unknown_flag)));
break;
}
}
// Extract given pad spec (e.g. %8X)
// Advance the given it pass the end of the padding spec found (if any)
// Return padding.
SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end)
{
using details::padding_info;
using details::scoped_padder;
const size_t max_width = 64;
if (it == end)
{
return padding_info{};
}
padding_info::pad_side side;
switch (*it)
{
case '-':
side = padding_info::right;
++it;
break;
case '=':
side = padding_info::center;
++it;
break;
default:
side = details::padding_info::left;
break;
}
if (it == end || !std::isdigit(static_cast<unsigned char>(*it)))
{
return padding_info{0, side};
}
auto width = static_cast<size_t>(*it - '0');
for (++it; it != end && std::isdigit(static_cast<unsigned char>(*it)); ++it)
{
auto digit = static_cast<size_t>(*it - '0');
width = width * 10 + digit;
}
return details::padding_info{std::min<size_t>(width, max_width), side};
}
SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern)
{
auto end = pattern.end();
std::unique_ptr<details::aggregate_formatter> user_chars;
formatters_.clear();
for (auto it = pattern.begin(); it != end; ++it)
{
if (*it == '%')
{
if (user_chars) // append user chars found so far
{
formatters_.push_back(std::move(user_chars));
}
auto padding = handle_padspec_(++it, end);
if (it != end)
{
if (padding.enabled())
{
handle_flag_<details::scoped_padder>(*it, padding);
}
else
{
handle_flag_<details::null_scoped_padder>(*it, padding);
}
}
else
{
break;
}
}
else // chars not following the % sign should be displayed as is
{
if (!user_chars)
{
user_chars = details::make_unique<details::aggregate_formatter>();
}
user_chars->add_ch(*it);
}
}
if (user_chars) // append raw chars found so far
{
formatters_.push_back(std::move(user_chars));
}
}
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/pattern_formatter.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/common.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
#include "spdlog/formatter.h"
#include <chrono>
#include <ctime>
#include <memory>
#include <string>
#include <vector>
namespace spdlog {
namespace details {
// padding information.
struct padding_info
{
enum pad_side
{
left,
right,
center
};
padding_info() = default;
padding_info(size_t width, padding_info::pad_side side)
: width_(width)
, side_(side)
{}
bool enabled() const
{
return width_ != 0;
}
const size_t width_ = 0;
const pad_side side_ = left;
};
class flag_formatter
{
public:
explicit flag_formatter(padding_info padinfo)
: padinfo_(padinfo)
{}
flag_formatter() = default;
virtual ~flag_formatter() = default;
virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0;
protected:
padding_info padinfo_;
};
} // namespace details
class pattern_formatter final : public formatter
{
public:
explicit pattern_formatter(
std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol);
// use default pattern is not given
explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol);
pattern_formatter(const pattern_formatter &other) = delete;
pattern_formatter &operator=(const pattern_formatter &other) = delete;
std::unique_ptr<formatter> clone() const override;
void format(const details::log_msg &msg, fmt::memory_buffer &dest) override;
private:
std::string pattern_;
std::string eol_;
pattern_time_type pattern_time_type_;
std::tm cached_tm_;
std::chrono::seconds last_log_secs_;
std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
std::tm get_time_(const details::log_msg &msg);
template<typename Padder>
void handle_flag_(char flag, details::padding_info padding);
// Extract given pad spec (e.g. %8X)
// Advance the given it pass the end of the padding spec found (if any)
// Return padding.
details::padding_info handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end);
void compile_pattern_(const std::string &pattern);
};
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "pattern_formatter-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/periodic_worker-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/periodic_worker.h"
#endif
namespace spdlog {
namespace details {
SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
{
active_ = (interval > std::chrono::seconds::zero());
if (!active_)
{
return;
}
worker_thread_ = std::thread([this, callback_fun, interval]() {
for (;;)
{
std::unique_lock<std::mutex> lock(this->mutex_);
if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
{
return; // active_ == false, so exit this thread
}
callback_fun();
}
});
}
// stop the worker thread and join it
SPDLOG_INLINE periodic_worker::~periodic_worker()
{
if (worker_thread_.joinable())
{
{
std::lock_guard<std::mutex> lock(mutex_);
active_ = false;
}
cv_.notify_one();
worker_thread_.join();
}
}
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/periodic_worker.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
// periodic worker thread - periodically executes the given callback function.
//
// RAII over the owned thread:
// creates the thread on construction.
// stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
#include <chrono>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <thread>
namespace spdlog {
namespace details {
class periodic_worker
{
public:
periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
periodic_worker(const periodic_worker &) = delete;
periodic_worker &operator=(const periodic_worker &) = delete;
// stop the worker thread and join it
~periodic_worker();
private:
bool active_;
std::thread worker_thread_;
std::mutex mutex_;
std::condition_variable cv_;
};
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "periodic_worker-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/registry-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/registry.h"
#endif
#include "spdlog/common.h"
#include "spdlog/details/periodic_worker.h"
#include "spdlog/logger.h"
#include "spdlog/details/pattern_formatter.h"
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// support for the default stdout color logger
#ifdef _WIN32
#include "spdlog/sinks/wincolor_sink.h"
#else
#include "spdlog/sinks/ansicolor_sink.h"
#endif
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
namespace spdlog {
namespace details {
SPDLOG_INLINE registry::registry()
: formatter_(new pattern_formatter())
, level_(spdlog::logger::default_level())
{
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
#ifdef _WIN32
auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
#else
auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
#endif
const char *default_logger_name = "";
default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
loggers_[default_logger_name] = default_logger_;
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
}
SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
register_logger_(std::move(new_logger));
}
SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone());
if (err_handler_)
{
new_logger->set_error_handler(err_handler_);
}
new_logger->set_level(level_);
new_logger->flush_on(flush_level_);
if (automatic_registration_)
{
register_logger_(std::move(new_logger));
}
}
SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto found = loggers_.find(logger_name);
return found == loggers_.end() ? nullptr : found->second;
}
SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_;
}
// Return raw ptr to the default logger.
// To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with set_default_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
SPDLOG_INLINE logger *registry::get_default_raw()
{
return default_logger_.get();
}
// set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map
if (default_logger_ != nullptr)
{
loggers_.erase(default_logger_->name());
}
if (new_default_logger != nullptr)
{
loggers_[new_default_logger->name()] = new_default_logger;
}
default_logger_ = std::move(new_default_logger);
}
SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp);
}
SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
return tp_;
}
// Set global formatter. Each sink in each logger will get a clone of this object
SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
formatter_ = std::move(formatter);
for (auto &l : loggers_)
{
l.second->set_formatter(formatter_->clone());
}
}
SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->set_level(log_level);
}
level_ = log_level;
}
SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->flush_on(log_level);
}
flush_level_ = log_level;
}
SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
std::function<void()> clbk = std::bind(®istry::flush_all, this);
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
}
SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg))
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->set_error_handler(handler);
}
err_handler_ = handler;
}
SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
fun(l.second);
}
}
SPDLOG_INLINE void registry::flush_all()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->flush();
}
}
SPDLOG_INLINE void registry::drop(const std::string &logger_name)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.erase(logger_name);
if (default_logger_ && default_logger_->name() == logger_name)
{
default_logger_.reset();
}
}
SPDLOG_INLINE void registry::drop_all()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.clear();
default_logger_.reset();
}
// clean all resources and threads started by the registry
SPDLOG_INLINE void registry::shutdown()
{
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset();
}
drop_all();
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_.reset();
}
}
SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex()
{
return tp_mutex_;
}
SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_regsistration)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
automatic_registration_ = automatic_regsistration;
}
SPDLOG_INLINE registry ®istry::instance()
{
static registry s_instance;
return s_instance;
}
SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
{
if (loggers_.find(logger_name) != loggers_.end())
{
throw spdlog_ex("logger with name '" + logger_name + "' already exists");
}
}
SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
{
auto logger_name = new_logger->name();
throw_if_exists_(logger_name);
loggers_[logger_name] = std::move(new_logger);
}
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/registry.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
// Loggers registry of unique name->logger pointer
// An attempt to create a logger with an already existing name will result with spdlog_ex exception.
// If user requests a non existing logger, nullptr will be returned
// This class is thread safe
#include "spdlog/common.h"
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <mutex>
namespace spdlog {
class logger;
namespace details {
class thread_pool;
class periodic_worker;
class registry
{
public:
registry(const registry &) = delete;
registry &operator=(const registry &) = delete;
void register_logger(std::shared_ptr<logger> new_logger);
void initialize_logger(std::shared_ptr<logger> new_logger);
std::shared_ptr<logger> get(const std::string &logger_name);
std::shared_ptr<logger> default_logger();
// Return raw ptr to the default logger.
// To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with set_default_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
logger *get_default_raw();
// set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
void set_default_logger(std::shared_ptr<logger> new_default_logger);
void set_tp(std::shared_ptr<thread_pool> tp);
std::shared_ptr<thread_pool> get_tp();
// Set global formatter. Each sink in each logger will get a clone of this object
void set_formatter(std::unique_ptr<formatter> formatter);
void set_level(level::level_enum log_level);
void flush_on(level::level_enum log_level);
void flush_every(std::chrono::seconds interval);
void set_error_handler(void (*handler)(const std::string &msg));
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
void flush_all();
void drop(const std::string &logger_name);
void drop_all();
// clean all resources and threads started by the registry
void shutdown();
std::recursive_mutex &tp_mutex();
void set_automatic_registration(bool automatic_regsistration);
static registry &instance();
private:
registry();
~registry() = default;
void throw_if_exists_(const std::string &logger_name);
void register_logger_(std::shared_ptr<logger> new_logger);
std::mutex logger_map_mutex_, flusher_mutex_;
std::recursive_mutex tp_mutex_;
std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
std::unique_ptr<formatter> formatter_;
level::level_enum level_ = level::info;
level::level_enum flush_level_ = level::off;
void (*err_handler_)(const std::string &msg);
std::shared_ptr<thread_pool> tp_;
std::unique_ptr<periodic_worker> periodic_flusher_;
std::shared_ptr<logger> default_logger_;
bool automatic_registration_ = true;
};
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "registry-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/details/synchronous_factory.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "registry.h"
namespace spdlog {
// Default logger factory- creates synchronous loggers
class logger;
struct synchronous_factory
{
template<typename Sink, typename... SinkArgs>
static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
{
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initialize_logger(new_logger);
return new_logger;
}
};
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/thread_pool-inl.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/thread_pool.h"
#endif
#include "spdlog/common.h"
namespace spdlog {
namespace details {
SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
: q_(q_max_items)
{
if (threads_n == 0 || threads_n > 1000)
{
throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
"range is 1-1000)");
}
for (size_t i = 0; i < threads_n; i++)
{
threads_.emplace_back([this, on_thread_start] {
on_thread_start();
this->thread_pool::worker_loop_();
});
}
}
SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
: thread_pool(q_max_items, threads_n, [] {})
{}
// message all threads to terminate gracefully join them
SPDLOG_INLINE thread_pool::~thread_pool()
{
try
{
for (size_t i = 0; i < threads_.size(); i++)
{
post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
}
for (auto &t : threads_)
{
t.join();
}
}
catch (...)
{}
}
void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy)
{
async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
post_async_msg_(std::move(async_m), overflow_policy);
}
void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
{
post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
}
size_t SPDLOG_INLINE thread_pool::overrun_counter()
{
return q_.overrun_counter();
}
void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
{
if (overflow_policy == async_overflow_policy::block)
{
q_.enqueue(std::move(new_msg));
}
else
{
q_.enqueue_nowait(std::move(new_msg));
}
}
void SPDLOG_INLINE thread_pool::worker_loop_()
{
while (process_next_msg_()) {};
}
// process next message in the queue
// return true if this thread should still be active (while no terminate msg
// was received)
bool SPDLOG_INLINE thread_pool::process_next_msg_()
{
async_msg incoming_async_msg;
bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
if (!dequeued)
{
return true;
}
switch (incoming_async_msg.msg_type)
{
case async_msg_type::log:
{
auto msg = incoming_async_msg.to_log_msg();
incoming_async_msg.worker_ptr->backend_log_(msg);
return true;
}
case async_msg_type::flush:
{
incoming_async_msg.worker_ptr->backend_flush_();
return true;
}
case async_msg_type::terminate:
{
return false;
}
}
assert(false && "Unexpected async_msg_type");
return true;
}
} // namespace details
} // namespace spdlog
================================================
FILE: extlibs/spdlog/include/spdlog/details/thread_pool.h
================================================
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include "spdlog/details/log_msg.h"
#include "spdlog/details/mpmc_blocking_q.h"
#include "spdlog/details/os.h"
#include <chrono>
#include <memory>
#include <thread>
#include <vector>
#include <functional>
namespace spdlog {
class async_logger;
namespace details {
using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
enum class async_msg_type
{
log,
flush,
terminate
};
// Async msg to move to/from the queue
// Movable only. should never be copied
struct async_msg
{
async_msg_type msg_type;
level::level_enum level;
log_clock::time_point time;
size_t thread_id;
fmt::basic_memory_buffer<char, 176> raw;
source_loc source;
async_logger_ptr worker_ptr;
async_msg() = default;
~async_msg() = default;
// should only be moved in or out of the queue..
async_msg(const async_msg &) = delete;
// support for vs2013 move
#if defined(_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type),
level(other.level),
time(other.time),
thread_id(other.thread_id),
raw(move(other.raw)),
msg_id(other.msg_id),
source(other.source),
worker_ptr(std::move(other.worker_ptr))
{}
async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT
{
msg_type = other.msg_type;
level = other.level;
time = other.time;
thread_id = other.thread_id;
raw = std::move(other.raw);
msg_id = other.msg_id;
source = other.source;
worker_ptr = std::move(other.worker_ptr);
return *this;
}
#else // (_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&) = default;
async_msg &operator=(async_msg &&) = default;
#endif
// construct from log_msg with given type
async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &m)
: msg_type(the_type)
, level(m.level)
, time(m.time)
, thread_id(m.thread_id)
, source(m.source)
, worker_ptr(std::move(worker))
{
raw.append(m.payload.data(), m.payload.data() + m.payload.size());
}
async_msg(async_logger_ptr &&worker, async_msg_type the_type)
: msg_type(the_type)
, level(level::off)
, time()
, thread_id(0)
, source()
, worker_ptr(std::move(worker))
{}
explicit async_msg(async_msg_type the_type)
: async_msg(nullptr, the_type)
{}
// copy into log_msg
log_msg to_log_msg()
{
log_msg msg(string_view_t(worker_ptr->name()), level, string_view_t(raw.data(), raw.size()));
msg.time = time;
msg.thread_id = thread_id;
msg.source = source;
msg.color_range_start = 0;
msg.color_range_end = 0;
return msg;
}
};
class thread_pool
{
public:
using item_type = async_msg;
using q_type = details::mpmc_blocking_queue<item_type>;
thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
thread_pool(size_t q_max_items, size_t threads_n);
// message all threads to terminate gracefully join them
~thread_pool();
thread_pool(const thread_pool &) = delete;
thread_pool &operator=(thread_pool &&) = delete;
void post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy);
void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
size_t overrun_counter();
private:
q_type q_;
std::vector<std::thread> threads_;
void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);
void worker_loop_();
// process next message in the queue
// return true if this thread should still be active (while no terminate msg
// was received)
bool process_next_msg_();
};
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "thread_pool-inl.h"
#endif
================================================
FILE: extlibs/spdlog/include/spdlog/fmt/bin_to_hex.h
================================================
//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
#pragma once
//
// Support for logging binary data as hex
// format flags:
// {:X} - print in uppercase.
// {:s} - don't separate each byte with space.
// {:p} - don't print the position on each line start.
// {:n} - don't split the output to lines.
//
// Examples:
//
// std::vector<char> v(200, 0x0b);
// logger->info("Some buffer {}", spdlog::to_hex(v));
// char buf[128];
// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
namespace spdlog {
namespace details {
template<typename It>
class bytes_range
{
public:
bytes_range(It range_begin, It range_end)
: begin_(range_begin)
, end_(range_end)
{}
It begin() const
{
return begin_;
}
It end() const
{
return end_;
}
private:
It begin_, end_;
};
} // namespace details
// create a bytes_range that wraps the given container
template<typename Container>
inline details::bytes_range<typename Container::const_iterator> to_hex(const Container &container)
{
static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
using Iter = typename Container::const_iterator;
return details::bytes_range<Iter>(std::begin(container), std::end(container));
}
// create bytes_range from ranges
template<typename It>
inline details::bytes_range<It> to_hex(const It range_begin, const It range_end)
{
return details::bytes_range<It>(range_begin, range_end);
}
} // namespace spdlog
namespace fmt {
template<typename T>
struct formatter<spdlog::details::bytes_range<T>>
{
const std::size_t line_size = 100;
const char delimiter = ' ';
bool put_newlines = true;
bool put_delimiters = true;
bool use_uppercase = false;
bool put_positions = true; // position on start of each line
// parse the format string flags
template<typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin())
{
auto it = ctx.begin();
while (*it && *it != '}')
{
switch (*it)
{
case 'X':
use_uppercase = true;
break;
case 's':
put_delimiters = false;
break;
case 'p':
put_positions = false;
break;
case 'n':
put_newlines = false;
break;
}
++it;
}
return it;
}
// format the given bytes range as hex
template<typename FormatContext, typename Container>
auto format(const spdlog::details::bytes_range<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
{
SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
std::size_t pos = 0;
std::size_t column = line_size;
auto inserter = ctx.begin();
for (auto &item : the_range)
{
auto ch = static_cast<unsigned char>(item);
pos++;
if (put_newlines && column >= line_size)
{
column = put_newline(inserter, pos);
// put first byte without delimiter in front of it
*inserter++ = hex_chars[(ch >> 4) & 0x0f];
*inserter++ = hex_chars[ch & 0x0f];
column += 2;
continue;
}
if (put_delimiters)
{
*inserter++ = delimiter;
++column;
}
*inserter++ = hex_chars[(ch >> 4) & 0x0f];
*inserter++ = hex_chars[ch & 0x0f];
column += 2;
}
return inserter;
}
// put newline(and position header)
// return the next column
template<typename It>
std::size_t put_newline(It inserter, std::size_t pos)
{
#ifdef _WIN32
*inserter++ = '\r';
#endif
*inserter++ = '\n';
if (put_positions)
{
fmt::format_to(inserter, "{:<04X}: ", pos - 1);
return 7;
}
else
{
return 1;
}
}
};
} // namespace fmt
================================================
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/LICENSE.rst
================================================
Copyright (c) 2012 - 2016, Victor Zverovich
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/chrono.h
================================================
// Formatting library for C++ - chrono support
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#ifndef FMT_CHRONO_H_
#define FMT_CHRONO_H_
#include "format.h"
#include "locale.h"
#include <chrono>
#include <ctime>
#include <locale>
#include <sstream>
FMT_BEGIN_NAMESPACE
namespace internal{
enum class numeric_system {
standard,
// Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
alternative
};
// Parses a put_time-like format string and invokes handler actions.
template <typename Char, typename Handler>
FMT_CONSTEXPR const Char *parse_chrono_format(
const Char *begin, const Char *end, Handler &&handler) {
auto ptr = begin;
while (ptr != end) {
auto c = *ptr;
if (c == '}') break;
if (c != '%') {
++ptr;
continue;
}
if (begin != ptr)
handler.on_text(begin, ptr);
++ptr; // consume '%'
if (ptr == end)
throw format_error("invalid format");
c = *ptr++;
switch (c) {
case '%':
handler.on_text(ptr - 1, ptr);
break;
case 'n': {
const char newline[] = "\n";
handler.on_text(newline, newline + 1);
break;
}
case 't': {
const char tab[] = "\t";
handler.on_text(tab, tab + 1);
break;
}
// Day of the week:
case 'a':
handler.on_abbr_weekday();
break;
case 'A':
handler.on_full_weekday();
break;
case 'w':
handler.on_dec0_weekday(numeric_system::standard);
break;
case 'u':
handler.on_dec1_weekday(numeric_system::standard);
break;
// Month:
case 'b':
handler.on_abbr_month();
break;
case 'B':
handler.on_full_month();
break;
// Hour, minute, second:
case 'H':
handler.on_24_hour(numeric_system::standard);
break;
case 'I':
handler.on_12_hour(numeric_system::standard);
break;
case 'M':
handler.on_minute(numeric_system::standard);
break;
case 'S':
handler.on_second(numeric_system::standard);
break;
// Other:
case 'c':
handler.on_datetime(numeric_system::standard);
break;
case 'x':
handler.on_loc_date(numeric_system::standard);
break;
case 'X':
handler.on_loc_time(numeric_system::standard);
break;
case 'D':
handler.on_us_date();
break;
case 'F':
handler.on_iso_date();
break;
case 'r':
handler.on_12_hour_time();
break;
case 'R':
handler.on_24_hour_time();
break;
case 'T':
handler.on_iso_time();
break;
case 'p':
handler.on_am_pm();
break;
case 'z':
handler.on_utc_offset();
break;
case 'Z':
handler.on_tz_name();
break;
// Alternative representation:
case 'E': {
if (ptr == end)
throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'c':
handler.on_datetime(numeric_system::alternative);
break;
case 'x':
handler.on_loc_date(numeric_system::alternative);
break;
case 'X':
handler.on_loc_time(numeric_system::alternative);
break;
default:
throw format_error("invalid format");
}
break;
}
case 'O':
if (ptr == end)
throw format_error("invalid format");
c = *ptr++;
switch (c) {
case 'w':
handler.on_dec0_weekday(numeric_system::alternative);
break;
case 'u':
handler.on_dec1_weekday(numeric_system::alternative);
break;
case 'H':
handler.on_24_hour(numeric_system::alternative);
break;
case 'I':
handler.on_12_hour(numeric_system::alternative);
break;
case 'M':
handler.on_minute(numeric_system::alternative);
break;
case 'S':
handler.on_second(numeric_system::alternative);
break;
default:
throw format_error("invalid format");
}
break;
default:
throw format_error("invalid format");
}
begin = ptr;
}
if (begin != ptr)
handler.on_text(begin, ptr);
return ptr;
}
struct chrono_format_checker {
void report_no_date() { throw format_error("no date"); }
template <typename Char>
void on_text(const Char *, const Char *) {}
void on_abbr_weekday() { report_no_date(); }
void on_full_weekday() { report_no_date(); }
void on_dec0_weekday(numeric_system) { report_no_date(); }
void on_dec1_weekday(numeric_system) { report_no_date(); }
void on_abbr_month() { report_no_date(); }
void on_full_month() { report_no_date(); }
void on_24_hour(numeric_system) {}
void on_12_hour(numeric_system) {}
void on_minute(numeric_system) {}
void on_second(numeric_system) {}
void on_datetime(numeric_system) { report_no_date(); }
void on_loc_date(numeric_system) { report_no_date(); }
void on_loc_time(numeric_system) { report_no_date(); }
void on_us_date() { report_no_date(); }
void on_iso_date() { report_no_date(); }
void on_12_hour_time() {}
void on_24_hour_time() {}
void on_iso_time() {}
void on_am_pm() {}
void on_utc_offset() { report_no_date(); }
void on_tz_name() { report_no_date(); }
};
template <typename Int>
inline int to_int(Int value) {
FMT_ASSERT(value >= (std::numeric_limits<int>::min)() &&
value <= (std::numeric_limits<int>::max)(), "invalid value");
return static_cast<int>(value);
}
template <typename FormatContext, typename OutputIt>
struct chrono_formatter {
FormatContext &context;
OutputIt out;
std::chrono::seconds s;
std::chrono::milliseconds ms;
typedef typename FormatContext::char_type char_type;
explicit chrono_formatter(FormatContext &ctx, OutputIt o)
: context(ctx), out(o) {}
int hour() const { return to_int((s.count() / 3600) % 24); }
int hour12() const {
auto hour = to_int((s.count() / 3600) % 12);
return hour > 0 ? hour : 12;
}
int minute() const { return to_int((s.count() / 60) % 60); }
int second() const { return to_int(s.count() % 60); }
std::tm time() const {
auto time = std::tm();
time.tm_hour = hour();
time.tm_min = minute();
time.tm_sec = second();
return time;
}
void write(int value, int width) {
typedef typename int_traits<int>::main_type main_type;
main_type n = to_unsigned(value);
int num_digits = internal::count_digits(n);
if (width > num_digits)
out = std::fill_n(out, width - num_digits, '0');
out = format_decimal<char_type>(out, n, num_digits);
}
void format_localized(const tm &time, const char *format) {
auto locale = context.locale().template get<std::locale>();
auto &facet = std::use_facet<std::time_put<char_type>>(locale);
std::basic_ostringstream<char_type> os;
os.imbue(locale);
facet.put(os, os, ' ', &time, format, format + std::strlen(format));
auto str = os.str();
std::copy(str.begin(), str.end(), out);
}
void on_text(const char_type *begin, const char_type *end) {
std::copy(begin, end, out);
}
// These are not implemented because durations don't have date information.
void on_abbr_weekday() {}
void on_full_weekday() {}
void on_dec0_weekday(numeric_system) {}
void on_dec1_weekday(numeric_system) {}
void on_abbr_month() {}
void on_full_month() {}
void on_datetime(numeric_system) {}
void on_loc_date(numeric_system) {}
void on_loc_time(numeric_system) {}
void on_us_date() {}
void on_iso_date() {}
void on_utc_offset() {}
void on_tz_name() {}
void on_24_hour(numeric_system ns) {
if (ns == numeric_system::standard)
return write(hour(), 2);
auto time = tm();
time.tm_hour = hour();
format_localized(time, "%OH");
}
void on_12_hour(numeric_system ns) {
if (ns == numeric_system::standard)
return write(hour12(), 2);
auto time = tm();
time.tm_hour = hour();
format_localized(time, "%OI");
}
void on_minute(numeric_system ns) {
if (ns == numeric_system::standard)
return write(minute(), 2);
auto time = tm();
time.tm_min = minute();
format_localized(time, "%OM");
}
void on_second(numeric_system ns) {
if (ns == numeric_system::standard) {
write(second(), 2);
if (ms != std::chrono::milliseconds(0)) {
*out++ = '.';
write(to_int(ms.count()), 3);
}
return;
}
auto time = tm();
time.tm_sec = second();
format_localized(time, "%OS");
}
void on_12_hour_time() { format_localized(time(), "%r"); }
void on_24_hour_time() {
write(hour(), 2);
*out++ = ':';
write(minute(), 2);
}
void on_iso_time() {
on_24_hour_time();
*out++ = ':';
write(second(), 2);
}
void on_am_pm() { format_localized(time(), "%p"); }
};
} // namespace internal
template <typename Period> FMT_CONSTEXPR const char *get_units() {
return FMT_NULL;
}
template <> FMT_CONSTEXPR const char *get_units<std::atto>() { return "as"; }
template <> FMT_CONSTEXPR const char *get_units<std::femto>() { return "fs"; }
template <> FMT_CONSTEXPR const char *get_units<std::pico>() { return "ps"; }
template <> FMT_CONSTEXPR const char *get_units<std::nano>() { return "ns"; }
template <> FMT_CONSTEXPR const char *get_units<std::micro>() { return "µs"; }
template <> FMT_CONSTEXPR const char *get_units<std::milli>() { return "ms"; }
template <> FMT_CONSTEXPR const char *get_units<std::centi>() { return "cs"; }
template <> FMT_CONSTEXPR const char *get_units<std::deci>() { return "ds"; }
template <> FMT_CONSTEXPR const char *get_units<std::ratio<1>>() { return "s"; }
template <> FMT_CONSTEXPR const char *get_units<std::deca>() { return "das"; }
template <> FMT_CONSTEXPR const char *get_units<std::hecto>() { return "hs"; }
template <> FMT_CONSTEXPR const char *get_units<std::kilo>() { return "ks"; }
template <> FMT_CONSTEXPR const char *get_units<std::mega>() { return "Ms"; }
template <> FMT_CONSTEXPR const char *get_units<std::giga>() { return "Gs"; }
template <> FMT_CONSTEXPR const char *get_units<std::tera>() { return "Ts"; }
template <> FMT_CONSTEXPR const char *get_units<std::peta>() { return "Ps"; }
template <> FMT_CONSTEXPR const char *get_units<std::exa>() { return "Es"; }
template <> FMT_CONSTEXPR const char *get_units<std::ratio<60>>() {
return "m";
}
template <> FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
return "h";
}
template <typename Rep, typename Period, typename Char>
struct formatter<std::chrono::duration<Rep, Period>, Char> {
private:
align_spec spec;
internal::arg_ref<Char> width_ref;
mutable basic_string_view<Char> format_str;
typedef std::chrono::duration<Rep, Period> duration;
struct spec_handler {
formatter &f;
basic_parse_context<Char> &context;
typedef internal::arg_ref<Char> arg_ref_type;
template <typename Id>
FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
context.check_arg_id(arg_id);
return arg_ref_type(arg_id);
}
FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id) {
return arg_ref_type(context.next_arg_id());
}
void on_error(const char *msg) { throw format_error(msg); }
void on_fill(Char fill) { f.spec.fill_ = fill; }
void on_align(alignment align) { f.spec.align_ = align; }
void on_width(unsigned width) { f.spec.width_ = width; }
template <typename Id>
void on_dynamic_width(Id arg_id) {
f.width_ref = make_arg_ref(arg_id);
}
};
public:
formatter() : spec() {}
FMT_CONSTEXPR auto parse(basic_parse_context<Char> &ctx)
-> decltype(ctx.begin()) {
auto begin = ctx.begin(), end = ctx.end();
if (begin == end) return begin;
spec_handler handler{*this, ctx};
begin = internal::parse_align(begin, end, handler);
if (begin == end) return begin;
begin = internal::parse_width(begin, end, handler);
end = parse_chrono_format(begin, end, internal::chrono_format_checker());
format_str = basic_string_view<Char>(&*begin, internal::to_unsigned(end - begin));
return end;
}
template <typename FormatContext>
auto format(const duration &d, FormatContext &ctx)
-> decltype(ctx.out()) {
auto begin = format_str.begin(), end = format_str.end();
memory_buffer buf;
typedef output_range<decltype(ctx.out()), Char> range;
basic_writer<range> w(range(ctx.out()));
if (begin == end || *begin == '}') {
if (const char *unit = get_units<Period>())
format_to(buf, "{}{}", d.count(), unit);
else if (Period::den == 1)
format_to(buf, "{}[{}]s", d.count(), Period::num);
else
format_to(buf, "{}[{}/{}]s", d.count(), Period::num, Period::den);
internal::handle_dynamic_spec<internal::width_checker>(
spec.width_, width_ref, ctx);
} else {
auto out = std::back_inserter(buf);
internal::chrono_formatter<FormatContext, decltype(out)> f(ctx, out);
f.s = std::chrono::duration_cast<std::chrono::seconds>(d);
f.ms = std::chrono::duration_cast<std::chrono::milliseconds>(d - f.s);
parse_chrono_format(begin, end, f);
}
w.write(buf.data(), buf.size(), spec);
return w.out();
}
};
FMT_END_NAMESPACE
#endif // FMT_CHRONO_H_
================================================
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/color.h
================================================
// Formatting library for C++ - color support
//
// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
// All rights reserved.
//
// For the license information refer to format.h.
#ifndef FMT_COLOR_H_
#define FMT_COLOR_H_
#include "format.h"
FMT_BEGIN_NAMESPACE
#ifdef FMT_DEPRECATED_COLORS
// color and (v)print_colored are deprecated.
enum color { black, red, green, yellow, blue, magenta, cyan, white };
FMT_API void vprint_colored(color c, string_view format, format_args args);
FMT_API void vprint_colored(color c, wstring_view format, wformat_args args);
template <typename... Args>
inline void print_colored(color c, string_view format_str,
const Args & ... args) {
vprint_colored(c, format_str, make_format_args(args...));
}
template <typename... Args>
inline void print_colored(color c, wstring_view format_str,
const Args & ... args) {
vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
}
inline void vprint_colored(color c, string_view format, format_args args) {
char escape[] = "\x1b[30m";
escape[3] = static_cast<char>('0' + c);
std::fputs(escape, stdout);
vprint(format, args);
std::fputs(internal::data::RESET_COLOR, stdout);
}
inline void vprint_colored(color c, wstring_view format, wformat_args args) {
wchar_t escape[] = L"\x1b[30m";
escape[3] = static_cast<wchar_t>('0' + c);
std::fputws(escape, stdout);
vprint(format, args);
std::fputws(internal::data::WRESET_COLOR, stdout);
}
#else
enum class color : uint32_t {
alice_blue = 0xF0F8FF, // rgb(240,248,255)
antique_white = 0xFAEBD7, // rgb(250,235,215)
aqua = 0x00FFFF, // rgb(0,255,255)
aquamarine = 0x7FFFD4, // rgb(127,255,212)
azure = 0xF0FFFF, // rgb(240,255,255)
beige = 0xF5F5DC, // rgb(245,245,220)
bisque = 0xFFE4C4, // rgb(255,228,196)
black = 0x000000, // rgb(0,0,0)
blanched_almond = 0xFFEBCD, // rgb(255,235,205)
blue = 0x0000FF, // rgb(0,0,255)
blue_violet = 0x8A2BE2, // rgb(138,43,226)
brown = 0xA52A2A, // rgb(165,42,42)
burly_wood = 0xDEB887, // rgb(222,184,135)
cadet_blue = 0x5F9EA0, // rgb(95,158,160)
chartreuse = 0x7FFF00, // rgb(127,255,0)
chocolate = 0xD2691E, // rgb(210,105,30)
coral = 0xFF7F50, // rgb(255,127,80)
cornflower_blue = 0x6495ED, // rgb(100,149,237)
cornsilk = 0xFFF8DC, // rgb(255,248,220)
crimson = 0xDC143C, // rgb(220,20,60)
cyan = 0x00FFFF, // rgb(0,255,255)
dark_blue = 0x00008B, // rgb(0,0,139)
dark_cyan = 0x008B8B, // rgb(0,139,139)
dark_golden_rod = 0xB8860B, // rgb(184,134,11)
dark_gray = 0xA9A9A9, // rgb(169,169,169)
dark_green = 0x006400, // rgb(0,100,0)
dark_khaki = 0xBDB76B, // rgb(189,183,107)
dark_magenta = 0x8B008B, // rgb(139,0,139)
dark_olive_green = 0x556B2F, // rgb(85,107,47)
dark_orange = 0xFF8C00, // rgb(255,140,0)
dark_orchid = 0x9932CC, // rgb(153,50,204)
dark_red = 0x8B0000, // rgb(139,0,0)
dark_salmon = 0xE9967A, // rgb(233,150,122)
dark_sea_green = 0x8FBC8F, // rgb(143,188,143)
dark_slate_blue = 0x483D8B, // rgb(72,61,139)
dark_slate_gray = 0x2F4F4F, // rgb(47,79,79)
dark_turquoise = 0x00CED1, // rgb(0,206,209)
dark_violet = 0x9400D3, // rgb(148,0,211)
deep_pink = 0xFF1493, // rgb(255,20,147)
deep_sky_blue = 0x00BFFF, // rgb(0,191,255)
dim_gray = 0x696969, // rgb(105,105,105)
dodger_blue = 0x1E90FF, // rgb(30,144,255)
fire_brick = 0xB22222, // rgb(178,34,34)
floral_white = 0xFFFAF0, // rgb(255,250,240)
forest_green = 0x228B22, // rgb(34,139,34)
fuchsia = 0xFF00FF, // rgb(255,0,255)
gainsboro = 0xDCDCDC, // rgb(220,220,220)
ghost_white = 0xF8F8FF, // rgb(248,248,255)
gold = 0xFFD700, // rgb(255,215,0)
golden_rod = 0xDAA520, // rgb(218,165,32)
gray = 0x808080, // rgb(128,128,128)
green = 0x008000, // rgb(0,128,0)
green_yellow = 0xADFF2F, // rgb(173,255,47)
honey_dew = 0xF0FFF0, // rgb(240,255,240)
hot_pink = 0xFF69B4, // rgb(255,105,180)
indian_red = 0xCD5C5C, // rgb(205,92,92)
indigo = 0x4B0082, // rgb(75,0,130)
ivory = 0xFFFFF0, // rgb(255,255,240)
khaki = 0xF0E68C, // rgb(240,230,140)
lavender = 0xE6E6FA, // rgb(230,230,250)
lavender_blush = 0xFFF0F5, // rgb(255,240,245)
lawn_green = 0x7CFC00, // rgb(124,252,0)
lemon_chiffon = 0xFFFACD, // rgb(255,250,205)
light_blue = 0xADD8E6, // rgb(173,216,230)
light_coral = 0xF08080, // rgb(240,128,128)
light_cyan = 0xE0FFFF, // rgb(224,255,255)
light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
light_gray = 0xD3D3D3, // rgb(211,211,211)
light_green = 0x90EE90, // rgb(144,238,144)
light_pink = 0xFFB6C1, // rgb(255,182,193)
light_salmon = 0xFFA07A, // rgb(255,160,122)
light_sea_green = 0x20B2AA, // rgb(32,178,170)
light_sky_blue = 0x87CEFA, // rgb(135,206,250)
light_slate_gray = 0x778899, // rgb(119,136,153)
light_steel_blue = 0xB0C4DE, // rgb(176,196,222)
light_yellow = 0xFFFFE0, // rgb(255,255,224)
lime = 0x00FF00, // rgb(0,255,0)
lime_green = 0x32CD32, // rgb(50,205,50)
linen = 0xFAF0E6, // rgb(250,240,230)
magenta = 0xFF00FF, // rgb(255,0,255)
maroon = 0x800000, // rgb(128,0,0)
medium_aquamarine = 0x66CDAA, // rgb(102,205,170)
medium_blue = 0x0000CD, // rgb(0,0,205)
medium_orchid = 0xBA55D3, // rgb(186,85,211)
medium_purple = 0x9370DB, // rgb(147,112,219)
medium_sea_green = 0x3CB371, // rgb(60,179,113)
medium_slate_blue = 0x7B68EE, // rgb(123,104,238)
medium_spring_green = 0x00FA9A, // rgb(0,250,154)
medium_turquoise = 0x48D1CC, // rgb(72,209,204)
medium_violet_red = 0xC71585, // rgb(199,21,133)
midnight_blue = 0x191970, // rgb(25,25,112)
mint_cream = 0xF5FFFA, // rgb(245,255,250)
misty_rose = 0xFFE4E1, // rgb(255,228,225)
moccasin = 0xFFE4B5, // rgb(255,228,181)
navajo_white = 0xFFDEAD, // rgb(255,222,173)
navy = 0x000080, // rgb(0,0,128)
old_lace = 0xFDF5E6, // rgb(253,245,230)
olive = 0x808000, // rgb(128,128,0)
olive_drab = 0x6B8E23, // rgb(107,142,35)
orange = 0xFFA500, // rgb(255,165,0)
orange_red = 0xFF4500, // rgb(255,69,0)
orchid = 0xDA70D6, // rgb(218,112,214)
pale_golden_rod = 0xEEE8AA, // rgb(238,232,170)
pale_green = 0x98FB98, // rgb(152,251,152)
pale_turquoise = 0xAFEEEE, // rgb(175,238,238)
pale_violet_red = 0xDB7093, // rgb(219,112,147)
papaya_whip = 0xFFEFD5, // rgb(255,239,213)
peach_puff = 0xFFDAB9, // rgb(255,218,185)
peru = 0xCD853F, // rgb(205,133,63)
pink = 0xFFC0CB, // rgb(255,192,203)
plum = 0xDDA0DD, // rgb(221,160,221)
powder_blue = 0xB0E0E6, // rgb(176,224,230)
purple = 0x800080, // rgb(128,0,128)
rebecca_purple = 0x663399, // rgb(102,51,153)
red = 0xFF0000, // rgb(255,0,0)
rosy_brown = 0xBC8F8F, // rgb(188,143,143)
royal_blue = 0x4169E1, // rgb(65,105,225)
saddle_brown = 0x8B4513, // rgb(139,69,19)
salmon = 0xFA8072, // rgb(250,128,114)
sandy_brown = 0xF4A460, // rgb(244,164,96)
sea_green = 0x2E8B57, // rgb(46,139,87)
sea_shell = 0xFFF5EE, // rgb(255,245,238)
sienna = 0xA0522D, // rgb(160,82,45)
silver = 0xC0C0C0, // rgb(192,192,192)
sky_blue = 0x87CEEB, // rgb(135,206,235)
slate_blue = 0x6A5ACD, // rgb(106,90,205)
slate_gray = 0x708090, // rgb(112,128,144)
snow = 0xFFFAFA, // rgb(255,250,250)
spring_green = 0x00FF7F, // rgb(0,255,127)
steel_blue = 0x4682B4, // rgb(70,130,180)
tan = 0xD2B48C, // rgb(210,180,140)
teal = 0x008080, // rgb(0,128,128)
thistle = 0xD8BFD8, // rgb(216,191,216)
tomato = 0xFF6347, // rgb(255,99,71)
turquoise = 0x40E0D0, // rgb(64,224,208)
violet = 0xEE82EE, // rgb(238,130,238)
wheat = 0xF5DEB3, // rgb(245,222,179)
white = 0xFFFFFF, // rgb(255,255,255)
white_smoke = 0xF5F5F5, // rgb(245,245,245)
yellow = 0xFFFF00, // rgb(255,255,0)
yellow_green = 0x9ACD32 // rgb(154,205,50)
}; // enum class color
enum class terminal_color : uint8_t {
black = 30,
red,
green,
yellow,
blue,
magenta,
cyan,
white,
bright_black = 90,
bright_red,
bright_green,
bright_yellow,
bright_blue,
bright_magenta,
bright_cyan,
bright_white
}; // enum class terminal_color
enum class emphasis : uint8_t {
bold = 1,
italic = 1 << 1,
underline = 1 << 2,
strikethrough = 1 << 3
}; // enum class emphasis
// rgb is a struct for red, green and blue colors.
// We use rgb as name because some editors will show it as color direct in the
// editor.
struct rgb {
FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {}
FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
: r(r_), g(g_), b(b_) {}
FMT_CONSTEXPR_DECL rgb(uint32_t hex)
: r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex) & 0xFF) {}
FMT_CONSTEXPR_DECL rgb(color hex)
: r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
b(uint32_t(hex) & 0xFF) {}
uint8_t r;
uint8_t g;
uint8_t b;
};
namespace internal {
// color is a struct of either a rgb color or a terminal color.
struct color_type {
FMT_CONSTEXPR color_type() FMT_NOEXCEPT
: is_rgb(), value{} {}
FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT
: is_rgb(true), value{} {
value.rgb_color = static_cast<uint32_t>(rgb_color);
}
FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT
: is_rgb(true), value{} {
value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16)
| (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
}
FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT
: is_rgb(), value{} {
value.term_color = static_cast<uint8_t>(term_color);
}
bool is_rgb;
union color_union {
uint8_t term_color;
uint32_t rgb_color;
} value;
};
} // namespace internal
// Experimental text formatting support.
class text_style {
public:
FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
: set_foreground_color(), set_background_color(), ems(em) {}
FMT_CONSTEXPR text_style &operator|=(const text_style &rhs) {
if (!set_foreground_color) {
set_foreground_color = rhs.set_foreground_color;
foreground_color = rhs.foreground_color;
} else if (rhs.set_foreground_color) {
if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
throw format_error("can't OR a terminal color");
foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
}
if (!set_background_color) {
set_background_color = rhs.set_background_color;
background_color = rhs.background_color;
} else if (rhs.set_background_color) {
if (!background_color.is_rgb || !rhs.background_color.is_rgb)
throw format_error("can't OR a terminal color");
background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
}
ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
static_cast<uint8_t>(rhs.ems));
return *this;
}
friend FMT_CONSTEXPR
text_style operator|(text_style lhs, const text_style &rhs) {
return lhs |= rhs;
}
FMT_CONSTEXPR text_style &operator&=(const text_style &rhs) {
if (!set_foreground_color) {
set_foreground_color = rhs.set_foreground_color;
foreground_color = rhs.foreground_color;
} else if (rhs.set_foreground_color) {
if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
throw format_error("can't AND a terminal color");
foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
}
if (!set_background_color) {
set_background_color = rhs.set_background_color;
background_color = rhs.background_color;
} else if (rhs.set_background_color) {
if (!background_color.is_rgb || !rhs.background_color.is_rgb)
throw format_error("can't AND a terminal color");
background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
}
ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
static_cast<uint8_t>(rhs.ems));
return *this;
}
friend FMT_CONSTEXPR
text_style operator&(text_style lhs, const text_style &rhs) {
return lhs &= rhs;
}
FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
return set_foreground_color;
}
FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
return set_background_color;
}
FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
return static_cast<uint8_t>(ems) != 0;
}
FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT {
assert(has_foreground() && "no foreground specified for this style");
return foreground_color;
}
FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT {
assert(has_background() && "no background specified for this style");
return background_color;
}
FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
assert(has_emphasis() && "no emphasis specified for this style");
return ems;
}
private:
FMT_CONSTEXPR text_style(bool is_foreground,
internal::color_type text_color) FMT_NOEXCEPT
: set_foreground_color(),
set_background_color(),
ems() {
if (is_foreground) {
foreground_color = text_color;
set_foreground_color = true;
} else {
background_color = text_color;
set_background_color = true;
}
}
friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
FMT_NOEXCEPT;
friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background)
FMT_NOEXCEPT;
internal::color_type foreground_color;
internal::color_type background_color;
bool set_foreground_color;
bool set_background_color;
emphasis ems;
};
FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT {
return text_style(/*is_foreground=*/true, foreground);
}
FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT {
return text_style(/*is_foreground=*/false, background);
}
FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
return text_style(lhs) | rhs;
}
namespace internal {
template <typename Char>
struct ansi_color_escape {
FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
const char * esc) FMT_NOEXCEPT {
// If we have a terminal color, we need to output another escape code
// sequence.
if (!text_color.is_rgb) {
bool is_background = esc == internal::data::BACKGROUND_COLOR;
uint32_t value = text_color.value.term_color;
// Background ASCII codes are the same as the foreground ones but with
// 10 more.
if (is_background)
value += 10u;
std::size_t index = 0;
buffer[index++] = static_cast<Char>('\x1b');
buffer[index++] = static_cast<Char>('[');
if (value >= 100u) {
buffer[index++] = static_cast<Char>('1');
value %= 100u;
}
buffer[index++] = static_cast<Char>('0' + value / 10u);
buffer[index++] = static_cast<Char>('0' + value % 10u);
buffer[index++] = static_cast<Char>('m');
buffer[index++] = static_cast<Char>('\0');
return;
}
for (int i = 0; i < 7; i++) {
buffer[i] = static_cast<Char>(esc[i]);
}
rgb color(text_color.value.rgb_color);
to_esc(color.r, buffer + 7, ';');
to_esc(color.g, buffer + 11, ';');
to_esc(color.b, buffer + 15, 'm');
buffer[19] = static_cast<Char>(0);
}
FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
uint8_t em_codes[4] = {};
uint8_t em_bits = static_cast<uint8_t>(em);
if (em_bits & static_cast<uint8_t>(emphasis::bold))
em_codes[0] = 1;
if (em_bits & static_cast<uint8_t>(emphasis::italic))
em_codes[1] = 3;
if (em_bits & static_cast<uint8_t>(emphasis::underline))
em_codes[2] = 4;
if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
em_codes[3] = 9;
std::size_t index = 0;
for (int i = 0; i < 4; ++i) {
if (!em_codes[i])
continue;
buffer[index++] = static_cast<Char>('\x1b');
buffer[index++] = static_cast<Char>('[');
buffer[index++] = static_cast<Char>('0' + em_codes[i]);
buffer[index++] = static_cast<Char>('m');
}
buffer[index++] = static_cast<Char>(0);
}
FMT_CONSTEXPR operator const Char *() const FMT_NOEXCEPT { return buffer; }
private:
Char buffer[7u + 3u * 4u + 1u];
static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out,
char delimiter) FMT_NOEXCEPT {
out[0] = static_cast<Char>('0' + c / 100);
out[1] = static_cast<Char>('0' + c / 10 % 10);
out[2] = static_cast<Char>('0' + c % 10);
out[3] = static_cast<Char>(delimiter);
}
};
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char>
make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT {
return ansi_color_escape<Char>(foreground, internal::data::FOREGROUND_COLOR);
}
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char>
make_background_color(internal::color_type background) FMT_NOEXCEPT {
return ansi_color_escape<Char>(background, internal::data::BACKGROUND_COLOR);
}
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char>
make_emphasis(emphasis em) FMT_NOEXCEPT {
return ansi_color_escape<Char>(em);
}
template <typename Char>
inline void fputs(const Char *chars, FILE *stream) FMT_NOEXCEPT {
std::fputs(chars, stream);
}
template <>
inline void fputs<wchar_t>(const wchar_t *chars, FILE *stream) FMT_NOEXCEPT {
std::fputws(chars, stream);
}
template <typename Char>
inline void reset_color(FILE *stream) FMT_NOEXCEPT {
fputs(internal::data::RESET_COLOR, stream);
}
template <>
inline void reset_color<wchar_t>(FILE *stream) FMT_NOEXCEPT {
fputs(internal::data::WRESET_COLOR, stream);
}
// The following specialiazation disables using std::FILE as a character type,
// which is needed because or else
// fmt::print(stderr, fmt::emphasis::bold, "");
// would take stderr (a std::FILE *) as the format string.
template <>
struct is_string<std::FILE *> : std::false_type {};
template <>
struct is_string<const std::FILE *> : std::false_type {};
} // namespace internal
template <
typename S, typename Char = typename internal::char_t<S>::type>
void vprint(std::FILE *f, const text_style &ts, const S &format,
basic_format_args<typename buffer_context<Char>::type> args) {
bool has_style = false;
if (ts.has_emphasis()) {
has_style = true;
internal::fputs<Char>(
internal::make_emphasis<Char>(ts.get_emphasis()), f);
}
if (ts.has_foreground()) {
has_style = true;
internal::fputs<Char>(
internal::make_foreground_color<Char>(ts.get_foreground()), f);
}
if (ts.has_background()) {
has_style = true;
internal::fputs<Char>(
internal::make_background_color<Char>(ts.get_background()), f);
}
vprint(f, format, args);
if (has_style) {
internal::reset_color<Char>(f);
}
}
/**
Formats a string and prints it to the specified file stream using ANSI
escape sequences to specify text formatting.
Example:
fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
"Elapsed time: {0:.2f} seconds", 1.23);
*/
template <typename String, typename... Args>
typename std::enable_if<internal::is_string<String>::value>::type print(
std::FILE *f, const text_style &ts, const String &format_str,
const Args &... args) {
internal::check_format_string<Args...>(format_str);
typedef typename internal::char_t<String>::type char_t;
typedef typename buffer_context<char_t>::type context_t;
format_arg_store<context_t, Args...> as{args...};
vprint(f, ts, format_str, basic_format_args<context_t>(as));
}
/**
Formats a string and prints it to stdout using ANSI escape sequences to
specify text formatting.
Example:
fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
"Elapsed time: {0:.2f} seconds", 1.23);
*/
template <typename String, typename... Args>
typename std::enable_if<internal::is_string<String>::value>::type print(
const text_style &ts, const String &format_str,
const Args &... args) {
return print(stdout, ts, format_str, args...);
}
#endif
FMT_END_NAMESPACE
#endif // FMT_COLOR_H_
================================================
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/core.h
================================================
// Formatting library for C++ - the core API
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#ifndef FMT_CORE_H_
#define FMT_CORE_H_
#include <cassert>
#include <cstdio> // std::FILE
#include <cstring>
#include <iterator>
#include <string>
#include <type_traits>
// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 50300
#ifdef __has_feature
# define FMT_HAS_FEATURE(x) __has_feature(x)
#else
# define FMT_HAS_FEATURE(x) 0
#endif
#if defined(__has_include) && !defined(__INTELLISENSE__) && \
!(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
# define FMT_HAS_INCLUDE(x) __has_include(x)
#else
# define FMT_HAS_INCLUDE(x) 0
#endif
#ifdef __has_cpp_attribute
# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#else
# define FMT_GCC_VERSION 0
#endif
#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
#else
# define FMT_HAS_GXX_CXX11 0
#endif
#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#endif
// Check if relaxed C++14 constexpr is supported.
// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
#ifndef FMT_USE_CONSTEXPR
# define FMT_USE_CONSTEXPR \
(FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
(FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
#endif
#if FMT_USE_CONSTEXPR
# define FMT_CONSTEXPR constexpr
# define FMT_CONSTEXPR_DECL constexpr
#else
# define FMT_CONSTEXPR inline
# define FMT_CONSTEXPR_DECL
#endif
#ifndef FMT_USE_CONSTEXPR11
# define FMT_USE_CONSTEXPR11 \
(FMT_USE_CONSTEXPR || FMT_GCC_VERSION >= 406 || FMT_MSC_VER >= 1900)
#endif
#if FMT_USE_CONSTEXPR11
# define FMT_CONSTEXPR11 constexpr
#else
# define FMT_CONSTEXPR11
#endif
#ifndef FMT_OVERRIDE
# if FMT_HAS_FEATURE(cxx_override) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
# define FMT_OVERRIDE override
# else
# define FMT_OVERRIDE
# endif
#endif
#if FMT_HAS_FEATURE(cxx_explicit_conversions) || \
FMT_GCC_VERSION >= 405 || FMT_MSC_VER >= 1800
# define FMT_USE_EXPLICIT 1
# define FMT_EXPLICIT explicit
#else
# define FMT_USE_EXPLICIT 0
# define FMT_EXPLICIT
#endif
#ifndef FMT_NULL
# if FMT_HAS_FEATURE(cxx_nullptr) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600
# define FMT_NULL nullptr
# define FMT_USE_NULLPTR 1
# else
# define FMT_NULL NULL
# endif
#endif
#ifndef FMT_USE_NULLPTR
# define FMT_USE_NULLPTR 0
#endif
// Check if exceptions are disabled.
#ifndef FMT_EXCEPTIONS
# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
FMT_MSC_VER && !_HAS_EXCEPTIONS
# define FMT_EXCEPTIONS 0
# else
# define FMT_EXCEPTIONS 1
# endif
#endif
// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
# define FMT_USE_NOEXCEPT 0
#endif
#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
# define FMT_DETECTED_NOEXCEPT noexcept
# define FMT_HAS_CXX11_NOEXCEPT 1
#else
# define FMT_DETECTED_NOEXCEPT throw()
# define FMT_HAS_CXX11_NOEXCEPT 0
#endif
#ifndef FMT_NOEXCEPT
# if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
# else
# define FMT_NOEXCEPT
# endif
#endif
#ifndef FMT_BEGIN_NAMESPACE
# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
FMT_MSC_VER >= 1900
# define FMT_INLINE_NAMESPACE inline namespace
# define FMT_END_NAMESPACE }}
# else
# define FMT_INLINE_NAMESPACE namespace
# define FMT_END_NAMESPACE } using namespace v5; }
# endif
# define FMT_BEGIN_NAMESPACE namespace fmt { FMT_INLINE_NAMESPACE v5 {
#endif
#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
# ifdef FMT_EXPORT
# define FMT_API __declspec(dllexport)
# elif defined(FMT_SHARED)
# define FMT_API __declspec(dllimport)
# endif
#endif
#ifndef FMT_API
# define FMT_API
#endif
#ifndef FMT_ASSERT
# define FMT_ASSERT(condition, message) assert((condition) && message)
#endif
// libc++ supports string_view in pre-c++17.
#if (FMT_HAS_INCLUDE(<string_view>) && \
(__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
(defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
# include <string_view>
# define FMT_STRING_VIEW std::basic_string_view
#elif FMT_HAS_INCLUDE(<experimental/string_view>) && __cplusplus >= 201402L
# include <experimental/string_view>
# define FMT_STRING_VIEW std::experimental::basic_string_view
#endif
// std::result_of is defined in <functional> in gcc 4.4.
#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
# include <functional>
#endif
FMT_BEGIN_NAMESPACE
namespace internal {
// An implementation of declval for pre-C++11 compilers such as gcc 4.
template <typename T>
typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
template <typename>
struct result_of;
template <typename F, typename... Args>
struct result_of<F(Args...)> {
// A workaround for gcc 4.4 that doesn't allow F to be a reference.
typedef typename std::result_of<
typename std::remove_reference<F>::type(Args...)>::type type;
};
// Casts nonnegative integer to unsigned.
template <typename Int>
FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
FMT_ASSERT(value >= 0, "negative value");
return static_cast<typename std::make_unsigned<Int>::type>(value);
}
/** A contiguous memory buffer with an optional growing ability. */
template <typename T>
class basic_buffer {
private:
basic_buffer(const basic_buffer &) = delete;
void operator=(const basic_buffer &) = delete;
T *ptr_;
std::size_t size_;
std::size_t capacity_;
protected:
// Don't initialize ptr_ since it is not accessed to save a few cycles.
basic_buffer(std::size_t sz) FMT_NOEXCEPT: size_(sz), capacity_(sz) {}
basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0)
FMT_NOEXCEPT: ptr_(p), size_(sz), capacity_(cap) {}
/** Sets the buffer data and capacity. */
void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
ptr_ = buf_data;
capacity_ = buf_capacity;
}
/** Increases the buffer capacity to hold at least *capacity* elements. */
virtual void grow(std::size_t capacity) = 0;
public:
typedef T value_type;
typedef const T &const_reference;
virtual ~basic_buffer() {}
T *begin() FMT_NOEXCEPT { return ptr_; }
T *end() FMT_NOEXCEPT { return ptr_ + size_; }
/** Returns the size of this buffer. */
std::size_t size() const FMT_NOEXCEPT { return size_; }
/** Returns the capacity of this buffer. */
std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
/** Returns a pointer to the buffer data. */
T *data() FMT_NOEXCEPT { return ptr_; }
/** Returns a pointer to the buffer data. */
const T *data() const FMT_NOEXCEPT { return ptr_; }
/**
Resizes the buffer. If T is a POD type new elements may not be initialized.
*/
void resize(std::size_t new_size) {
reserve(new_size);
size_ = new_size;
}
/** Clears this buffer. */
void clear() { size_ = 0; }
/** Reserves space to store at least *capacity* elements. */
void reserve(std::size_t new_capacity) {
if (new_capacity > capacity_)
grow(new_capacity);
}
void push_back(const T &value) {
reserve(size_ + 1);
ptr_[size_++] = value;
}
/** Appends data to the end of the buffer. */
template <typename U>
void append(const U *begin, const U *end);
T &operator[](std::size_t index) { return ptr_[index]; }
const T &operator[](std::size_t index) const { return ptr_[index]; }
};
typedef basic_buffer<char> buffer;
typedef basic_buffer<wchar_t> wbuffer;
// A container-backed buffer.
template <typename Container>
class container_buffer : public basic_buffer<typename Container::value_type> {
private:
Container &container_;
protected:
void grow(std::size_t capacity) FMT_OVERRIDE {
container_.resize(capacity);
this->set(&container_[0], capacity);
}
public:
explicit container_buffer(Container &c)
: basic_buffer<typename Container::value_type>(c.size()), container_(c) {}
};
// Extracts a reference to the container from back_insert_iterator.
template <typename Container>
inline Container &get_container(std::back_insert_iterator<Container> it) {
typedef std::back_insert_iterator<Container> bi_iterator;
struct accessor: bi_iterator {
accessor(bi_iterator iter) : bi_iterator(iter) {}
using bi_iterator::container;
};
return *accessor(it).container;
}
struct error_handler {
FMT_CONSTEXPR error_handler() {}
FMT_CONSTEXPR error_handler(const error_handler &) {}
// This function is intentionally not constexpr to give a compile-time error.
FMT_API void on_error(const char *message);
};
template <typename T>
struct no_formatter_error : std::false_type {};
} // namespace internal
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 405
template <typename... T>
struct is_constructible: std::false_type {};
#else
template <typename... T>
struct is_constructible : std::is_constructible<T...> {};
#endif
/**
An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
subset of the API. ``fmt::basic_string_view`` is used for format strings even
if ``std::string_view`` is available to prevent issues when a library is
compiled with a different ``-std`` option than the client code (which is not
recommended).
*/
template <typename Char>
class basic_string_view {
private:
const Char *data_;
size_t size_;
public:
typedef Char char_type;
typedef const Char *iterator;
FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
/** Constructs a string reference object from a C string and a size. */
FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT
: data_(s), size_(count) {}
/**
\rst
Constructs a string reference object from a C string computing
the size with ``std::char_traits<Char>::length``.
\endrst
*/
basic_string_view(const Char *s)
: data_(s), size_(std::char_traits<Char>::length(s)) {}
/** Constructs a string reference from a ``std::basic_string`` object. */
template <typename Alloc>
FMT_CONSTEXPR basic_string_view(
const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT
: data_(s.data()), size_(s.size()) {}
#ifdef FMT_STRING_VIEW
FMT_CONSTEXPR basic_string_view(FMT_STRING_VIEW<Char> s) FMT_NOEXCEPT
: data_(s.data()), size_(s.size()) {}
#endif
/** Returns a pointer to the string data. */
FMT_CONSTEXPR const Char *data() const { return data_; }
/** Returns the string size. */
FMT_CONSTEXPR size_t size() const { return size_; }
FMT_CONSTEXPR iterator begin() const { return data_; }
FMT_CONSTEXPR iterator end() const { return data_ + size_; }
FMT_CONSTEXPR void remove_prefix(size_t n) {
data_ += n;
size_ -= n;
}
// Lexicographically compare this string reference to other.
int compare(basic_string_view other) const {
size_t str_size = size_ < other.size_ ? size_ : other.size_;
int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
if (result == 0)
result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
return result;
}
friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) == 0;
}
friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) != 0;
}
friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) < 0;
}
friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) <= 0;
}
friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) > 0;
}
friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) >= 0;
}
};
typedef basic_string_view<char> string_view;
typedef basic_string_view<wchar_t> wstring_view;
/**
\rst
The function ``to_string_view`` adapts non-intrusively any kind of string or
string-like type if the user provides a (possibly templated) overload of
``to_string_view`` which takes an instance of the string class
``StringType<Char>`` and returns a ``fmt::basic_string_view<Char>``.
The conversion function must live in the very same namespace as
``StringType<Char>`` to be picked up by ADL. Non-templated string types
like f.e. QString must return a ``basic_string_view`` with a fixed matching
char type.
**Example**::
namespace my_ns {
inline string_view to_string_view(const my_string &s) {
return {s.data(), s.length()};
}
}
std::string message = fmt::format(my_string("The answer is {}"), 42);
\endrst
*/
template <typename Char>
inline basic_string_view<Char>
to_string_view(basic_string_view<Char> s) { return s; }
template <typename Char>
inline basic_string_view<Char>
to_string_view(const std::basic_string<Char> &s) { return s; }
template <typename Char>
inline basic_string_view<Char> to_string_view(const Char *s) { return s; }
#ifdef FMT_STRING_VIEW
template <typename Char>
inline basic_string_view<Char>
to_string_view(FMT_STRING_VIEW<Char> s) { return s; }
#endif
// A base class for compile-time strings. It is defined in the fmt namespace to
// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42).
struct compile_string {};
template <typename S>
struct is_compile_string : std::is_base_of<compile_string, S> {};
template <
typename S,
typename Enable = typename std::enable_if<is_compile_string<S>::value>::type>
FMT_CONSTEXPR basic_string_view<typename S::char_type>
to_string_view(const S &s) { return s; }
template <typename Context>
class basic_format_arg;
template <typename Context>
class basic_format_args;
// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter {
static_assert(internal::no_formatter_error<T>::value,
"don't know how to format the type, include fmt/ostream.h if it provides "
"an operator<< that should be used");
// The following functions are not defined intentionally.
template <typename ParseContext>
typename ParseContext::iterator parse(ParseContext &);
template <typename FormatContext>
auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out());
};
template <typename T, typename Char, typename Enable = void>
struct convert_to_int: std::integral_constant<
bool, !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value> {};
namespace internal {
struct dummy_string_view { typedef void char_type; };
dummy_string_view to_string_view(...);
using fmt::v5::to_string_view;
// Specifies whether S is a string type convertible to fmt::basic_string_view.
template <typename S>
struct is_string : std::integral_constant<bool, !std::is_same<
dummy_string_view, decltype(to_string_view(declval<S>()))>::value> {};
template <typename S>
struct char_t {
typedef decltype(to_string_view(declval<S>())) result;
typedef typename result::char_type type;
};
template <typename Char>
struct named_arg_base;
template <typename T, typename Char>
struct named_arg;
enum type {
none_type, named_arg_type,
// Integer types should go first,
int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
last_integer_type = char_type,
// followed by floating-point types.
double_type, long_double_type, last_numeric_type = long_double_type,
cstring_type, string_type, pointer_type, custom_type
};
FMT_CONSTEXPR bool is_integral(type t) {
FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
return t > internal::none_type && t <= internal::last_integer_type;
}
FMT_CONSTEXPR bool is_arithmetic(type t) {
FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
return t > internal::none_type && t <= internal::last_numeric_type;
}
template <typename Char>
struct string_value {
const Char *value;
std::size_t size;
};
template <typename Context>
struct custom_value {
const void *value;
void (*format)(const void *arg, Context &ctx);
};
// A formatting argument value.
template <typename Context>
class value {
public:
typedef typename Context::char_type char_type;
union {
int int_value;
unsigned uint_value;
long long long_long_value;
unsigned long long ulong_long_value;
double double_value;
long double long_double_value;
const void *pointer;
string_value<char_type> string;
string_value<signed char> sstring;
string_value<unsigned char> ustring;
custom_value<Context> custom;
};
FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
value(unsigned val) { uint_value = val; }
value(long long val) { long_long_value = val; }
value(unsigned long long val) { ulong_long_value = val; }
value(double val) { double_value = val; }
value(long double val) { long_double_value = val; }
value(const char_type *val) { string.value = val; }
value(const signed char *val) {
static_assert(std::is_same<char, char_type>::value,
"incompatible string types");
sstring.value = val;
}
value(const unsigned char *val) {
static_assert(std::is_same<char, char_type>::value,
"incompatible string types");
ustring.value = val;
}
value(basic_string_view<char_type> val) {
string.value = val.data();
string.size = val.size();
}
value(const void *val) { pointer = val; }
template <typename T>
explicit value(const T &val) {
custom.value = &val;
custom.format = &format_custom_arg<T>;
}
const named_arg_base<char_type> &as_named_arg() {
return *static_cast<const named_arg_base<char_type>*>(pointer);
}
private:
// Formats an argument of a custom type, such as a user-defined class.
template <typename T>
static void format_custom_arg(const void *arg, Context &ctx) {
// Get the formatter type through the context to allow different contexts
// have different extension points, e.g. `formatter<T>` for `format` and
// `printf_formatter<T>` for `printf`.
typename Context::template formatter_type<T>::type f;
auto &&parse_ctx = ctx.parse_context();
parse_ctx.advance_to(f.parse(parse_ctx));
ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
}
};
// Value initializer used to delay conversion to value and reduce memory churn.
template <typename Context, typename T, type TYPE>
struct init {
T val;
static const type type_tag = TYPE;
FMT_CONSTEXPR init(const T &v) : val(v) {}
FMT_CONSTEXPR operator value<Context>() const { return value<Context>(val); }
};
template <typename Context, typename T>
FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value);
#define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
template <typename C> \
FMT_CONSTEXPR init<C, ValueType, TAG> make_value(ArgType val) { \
return static_cast<ValueType>(val); \
}
#define FMT_MAKE_VALUE_SAME(TAG, Type) \
template <typename C> \
FMT_CONSTEXPR init<C, Type, TAG> make_value(Type val) { return val; }
FMT_MAKE_VALUE(bool_type, bool, int)
FMT_MAKE_VALUE(int_type, short, int)
FMT_MAKE_VALUE(uint_type, unsigned short, unsigned)
FMT_MAKE_VALUE_SAME(int_type, int)
FMT_MAKE_VALUE_SAME(uint_type, unsigned)
// To minimize the number of types we need to deal with, long is translated
// either to int or to long long depending on its size.
typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
long_type;
FMT_MAKE_VALUE(
(sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
unsigned, unsigned long long>::type ulong_type;
FMT_MAKE_VALUE(
(sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type),
unsigned long, ulong_type)
FMT_MAKE_VALUE_SAME(long_long_type, long long)
FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long)
FMT_MAKE_VALUE(int_type, signed char, int)
FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
// This doesn't use FMT_MAKE_VALUE because of ambiguity in gcc 4.4.
template <typename C, typename Char>
FMT_CONSTEXPR typename std::enable_if<
std::is_same<typename C::char_type, Char>::value,
init<C, int, char_type>>::type make_value(Char val) { return val; }
template <typename C>
FMT_CONSTEXPR typename std::enable_if<
!std::is_same<typename C::char_type, char>::value,
init<C, int, char_type>>::type make_value(char val) { return val; }
FMT_MAKE_VALUE(double_type, float, double)
FMT_MAKE_VALUE_SAME(double_type, double)
FMT_MAKE_VALUE_SAME(long_double_type, long double)
// Formatting of wide strings into a narrow buffer and multibyte strings
// into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606).
FMT_MAKE_VALUE(cstring_type, typename C::char_type*,
const typename C::char_type*)
FMT_MAKE_VALUE(cstring_type, const typename C::char_type*,
const typename C::char_type*)
FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
FMT_MAKE_VALUE_SAME(cstring_type, const signed char*)
FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char*)
FMT_MAKE_VALUE_SAME(string_type, basic_string_view<typename C::char_type>)
FMT_MAKE_VALUE(string_type,
typename basic_string_view<typename C::char_type>::type,
basic_string_view<typename C::char_type>)
FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
basic_string_view<typename C::char_type>)
FMT_MAKE_VALUE(pointer_type, void*, const void*)
FMT_MAKE_VALUE_SAME(pointer_type, const void*)
#if FMT_USE_NULLPTR
FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
#endif
// Formatting of arbitrary pointers is disallowed. If you want to output a
// pointer cast it to "void *" or "const void *". In particular, this forbids
// formatting of "[const] volatile char *" which is printed as bool by
// iostreams.
template <typename C, typename T>
typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type
make_value(const T *) {
static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
}
template <typename C, typename T>
inline typename std::enable_if<
std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
init<C, int, int_type>>::type
make_value(const T &val) { return static_cast<int>(val); }
template <typename C, typename T, typename Char = typename C::char_type>
inline typename std::enable_if<
is_constructible<basic_string_view<Char>, T>::value &&
!internal::is_string<T>::value,
init<C, basic_string_view<Char>, string_type>>::type
make_value(const T &val) { return basic_string_view<Char>(val); }
template <typename C, typename T, typename Char = typename C::char_type>
inline typename std::enable_if<
!convert_to_int<T, Char>::value && !std::is_same<T, Char>::value &&
!std::is_convertible<T, basic_string_view<Char>>::value &&
!is_constructible<basic_string_view<Char>, T>::value &&
!internal::is_string<T>::value,
// Implicit conversion to std::string is not handled here because it's
// unsafe: https://github.com/fmtlib/fmt/issues/729
init<C, const T &, custom_type>>::type
make_value(const T &val) { return val; }
template <typename C, typename T>
init<C, const void*, named_arg_type>
make_value(const named_arg<T, typename C::char_type> &val) {
basic_format_arg<C> arg = make_arg<C>(val.value);
std::memcpy(val.data, &arg, sizeof(arg));
return static_cast<const void*>(&val);
}
template <typename C, typename S>
FMT_CONSTEXPR11 typename std::enable_if<
internal::is_string<S>::value,
init<C, basic_string_view<typename C::char_type>, string_type>>::type
make_value(const S &val) {
// Handle adapted strings.
static_assert(std::is_same<
typename C::char_type, typename internal::char_t<S>::type>::value,
"mismatch between char-types of context and argument");
return to_string_view(val);
}
// Maximum number of arguments with packed types.
enum { max_packed_args = 15 };
enum : unsigned long long { is_unpacked_bit = 1ull << 63 };
template <typename Context>
class arg_map;
} // namespace internal
// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in basic_memory_buffer.
template <typename Context>
class basic_format_arg {
private:
internal::value<Context> value_;
internal::type type_;
template <typename ContextType, typename T>
friend FMT_CONSTEXPR basic_format_arg<ContextType>
internal::make_arg(const T &value);
template <typename Visitor, typename Ctx>
friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
visit_format_arg(Visitor &&vis, const basic_format_arg<Ctx> &arg);
friend class basic_format_args<Context>;
friend class internal::arg_map<Context>;
typedef typename Context::char_type char_type;
public:
class handle {
public:
explicit handle(internal::custom_value<Context> custom): custom_(custom) {}
void format(Context &ctx) const { custom_.format(custom_.value, ctx); }
private:
internal::custom_value<Context> custom_;
};
FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {}
FMT_EXPLICIT operator bool() const FMT_NOEXCEPT {
return type_ != internal::none_type;
}
internal::type t
gitextract_57u15zkm/
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ └── feature_request.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ └── Build.yml
├── .gitignore
├── .gitmodules
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── README.MD
├── appInfo.cmake
├── extlibs/
│ ├── spdlog/
│ │ ├── include/
│ │ │ └── spdlog/
│ │ │ ├── async.h
│ │ │ ├── async_logger-inl.h
│ │ │ ├── async_logger.h
│ │ │ ├── common-inl.h
│ │ │ ├── common.h
│ │ │ ├── details/
│ │ │ │ ├── circular_q.h
│ │ │ │ ├── console_globals.h
│ │ │ │ ├── file_helper-inl.h
│ │ │ │ ├── file_helper.h
│ │ │ │ ├── fmt_helper.h
│ │ │ │ ├── log_msg-inl.h
│ │ │ │ ├── log_msg.h
│ │ │ │ ├── mpmc_blocking_q.h
│ │ │ │ ├── null_mutex.h
│ │ │ │ ├── os-inl.h
│ │ │ │ ├── os.h
│ │ │ │ ├── pattern_formatter-inl.h
│ │ │ │ ├── pattern_formatter.h
│ │ │ │ ├── periodic_worker-inl.h
│ │ │ │ ├── periodic_worker.h
│ │ │ │ ├── registry-inl.h
│ │ │ │ ├── registry.h
│ │ │ │ ├── synchronous_factory.h
│ │ │ │ ├── thread_pool-inl.h
│ │ │ │ └── thread_pool.h
│ │ │ ├── fmt/
│ │ │ │ ├── bin_to_hex.h
│ │ │ │ ├── bundled/
│ │ │ │ │ ├── LICENSE.rst
│ │ │ │ │ ├── chrono.h
│ │ │ │ │ ├── color.h
│ │ │ │ │ ├── core.h
│ │ │ │ │ ├── format-inl.h
│ │ │ │ │ ├── format.h
│ │ │ │ │ ├── locale.h
│ │ │ │ │ ├── ostream.h
│ │ │ │ │ ├── posix.h
│ │ │ │ │ ├── printf.h
│ │ │ │ │ ├── ranges.h
│ │ │ │ │ └── time.h
│ │ │ │ ├── fmt.h
│ │ │ │ └── ostr.h
│ │ │ ├── formatter.h
│ │ │ ├── logger-inl.h
│ │ │ ├── logger.h
│ │ │ ├── sinks/
│ │ │ │ ├── android_sink.h
│ │ │ │ ├── ansicolor_sink-inl.h
│ │ │ │ ├── ansicolor_sink.h
│ │ │ │ ├── base_sink-inl.h
│ │ │ │ ├── base_sink.h
│ │ │ │ ├── basic_file_sink-inl.h
│ │ │ │ ├── basic_file_sink.h
│ │ │ │ ├── daily_file_sink.h
│ │ │ │ ├── dist_sink.h
│ │ │ │ ├── dup_filter_sink.h
│ │ │ │ ├── msvc_sink.h
│ │ │ │ ├── null_sink.h
│ │ │ │ ├── ostream_sink.h
│ │ │ │ ├── rotating_file_sink-inl.h
│ │ │ │ ├── rotating_file_sink.h
│ │ │ │ ├── sink-inl.h
│ │ │ │ ├── sink.h
│ │ │ │ ├── stdout_color_sinks-inl.h
│ │ │ │ ├── stdout_color_sinks.h
│ │ │ │ ├── stdout_sinks-inl.h
│ │ │ │ ├── stdout_sinks.h
│ │ │ │ ├── syslog_sink.h
│ │ │ │ ├── systemd_sink.h
│ │ │ │ ├── wincolor_sink-inl.h
│ │ │ │ └── wincolor_sink.h
│ │ │ ├── spdlog-inl.h
│ │ │ ├── spdlog.h
│ │ │ ├── tweakme.h
│ │ │ └── version.h
│ │ └── src/
│ │ └── spdlog.cpp
│ └── squirrel/
│ ├── .gitignore
│ ├── .travis.yml
│ ├── CMakeLists.txt
│ ├── COMPILE
│ ├── COPYRIGHT
│ ├── HISTORY
│ ├── Makefile
│ ├── README
│ ├── appveyor.yml
│ ├── doc/
│ │ ├── Makefile
│ │ ├── make.bat
│ │ └── source/
│ │ ├── conf.py
│ │ ├── index.rst
│ │ ├── reference/
│ │ │ ├── api/
│ │ │ │ ├── bytecode_serialization.rst
│ │ │ │ ├── calls.rst
│ │ │ │ ├── compiler.rst
│ │ │ │ ├── debug_interface.rst
│ │ │ │ ├── garbage_collector.rst
│ │ │ │ ├── object_creation_and_handling.rst
│ │ │ │ ├── object_manipulation.rst
│ │ │ │ ├── raw_object_handling.rst
│ │ │ │ ├── stack_operations.rst
│ │ │ │ └── virtual_machine.rst
│ │ │ ├── api_reference.rst
│ │ │ ├── embedding/
│ │ │ │ ├── build_configuration.rst
│ │ │ │ ├── calling_a_function.rst
│ │ │ │ ├── compiling_a_script.rst
│ │ │ │ ├── creating_a_c_function.rst
│ │ │ │ ├── debug_interface.rst
│ │ │ │ ├── error_conventions.rst
│ │ │ │ ├── memory_management.rst
│ │ │ │ ├── references_from_c.rst
│ │ │ │ ├── runtime_error_handling.rst
│ │ │ │ ├── tables_and_arrays_manipulation.rst
│ │ │ │ ├── the_registry_table.rst
│ │ │ │ ├── the_stack.rst
│ │ │ │ ├── userdata_and_userpointers.rst
│ │ │ │ └── vm_initialization.rst
│ │ │ ├── embedding_squirrel.rst
│ │ │ ├── index.rst
│ │ │ ├── introduction.rst
│ │ │ ├── language/
│ │ │ │ ├── arrays.rst
│ │ │ │ ├── builtin_functions.rst
│ │ │ │ ├── classes.rst
│ │ │ │ ├── constants_and_enumerations.rst
│ │ │ │ ├── datatypes.rst
│ │ │ │ ├── delegation.rst
│ │ │ │ ├── execution_context.rst
│ │ │ │ ├── expressions.rst
│ │ │ │ ├── functions.rst
│ │ │ │ ├── generators.rst
│ │ │ │ ├── lexical_structure.rst
│ │ │ │ ├── metamethods.rst
│ │ │ │ ├── statements.rst
│ │ │ │ ├── tables.rst
│ │ │ │ ├── threads.rst
│ │ │ │ └── weak_references.rst
│ │ │ └── language.rst
│ │ └── stdlib/
│ │ ├── index.rst
│ │ ├── introduction.rst
│ │ ├── stdauxlib.rst
│ │ ├── stdbloblib.rst
│ │ ├── stdiolib.rst
│ │ ├── stdmathlib.rst
│ │ ├── stdstringlib.rst
│ │ └── stdsystemlib.rst
│ ├── etc/
│ │ ├── minimal.c
│ │ └── test.nut
│ ├── include/
│ │ ├── sqconfig.h
│ │ ├── sqstdaux.h
│ │ ├── sqstdblob.h
│ │ ├── sqstdio.h
│ │ ├── sqstdmath.h
│ │ ├── sqstdstring.h
│ │ ├── sqstdsystem.h
│ │ └── squirrel.h
│ ├── samples/
│ │ ├── ackermann.nut
│ │ ├── array.nut
│ │ ├── class.nut
│ │ ├── classattributes.nut
│ │ ├── coroutines.nut
│ │ ├── delegation.nut
│ │ ├── fibonacci.nut
│ │ ├── flow.nut
│ │ ├── generators.nut
│ │ ├── hello.nut
│ │ ├── list.nut
│ │ ├── loops.nut
│ │ ├── matrix.nut
│ │ ├── metamethods.nut
│ │ ├── methcall.nut
│ │ ├── regex.nut
│ │ └── tailstate.nut
│ ├── sq/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile
│ │ ├── sq.c
│ │ └── sq.dsp
│ ├── sqstdlib/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile
│ │ ├── sqstdaux.cpp
│ │ ├── sqstdblob.cpp
│ │ ├── sqstdblobimpl.h
│ │ ├── sqstdio.cpp
│ │ ├── sqstdlib.dsp
│ │ ├── sqstdmath.cpp
│ │ ├── sqstdrex.cpp
│ │ ├── sqstdstream.cpp
│ │ ├── sqstdstream.h
│ │ ├── sqstdstring.cpp
│ │ └── sqstdsystem.cpp
│ ├── squirrel/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile
│ │ ├── sqapi.cpp
│ │ ├── sqarray.h
│ │ ├── sqbaselib.cpp
│ │ ├── sqclass.cpp
│ │ ├── sqclass.h
│ │ ├── sqclosure.h
│ │ ├── sqcompiler.cpp
│ │ ├── sqcompiler.h
│ │ ├── sqdebug.cpp
│ │ ├── sqfuncproto.h
│ │ ├── sqfuncstate.cpp
│ │ ├── sqfuncstate.h
│ │ ├── sqlexer.cpp
│ │ ├── sqlexer.h
│ │ ├── sqmem.cpp
│ │ ├── sqobject.cpp
│ │ ├── sqobject.h
│ │ ├── sqopcodes.h
│ │ ├── sqpcheader.h
│ │ ├── sqstate.cpp
│ │ ├── sqstate.h
│ │ ├── sqstring.h
│ │ ├── sqtable.cpp
│ │ ├── sqtable.h
│ │ ├── squirrel.dsp
│ │ ├── squserdata.h
│ │ ├── squtils.h
│ │ ├── sqvm.cpp
│ │ └── sqvm.h
│ └── squirrel.dsw
├── include/
│ └── engge/
│ ├── Audio/
│ │ ├── SoundCategory.hpp
│ │ ├── SoundDefinition.hpp
│ │ ├── SoundId.hpp
│ │ ├── SoundManager.hpp
│ │ └── SoundTrigger.hpp
│ ├── Dialog/
│ │ ├── ConditionVisitor.hpp
│ │ ├── DialogConditionAbstract.hpp
│ │ ├── DialogContextAbstract.hpp
│ │ ├── DialogManager.hpp
│ │ ├── DialogPlayer.hpp
│ │ ├── DialogScriptAbstract.hpp
│ │ ├── EngineDialogScript.hpp
│ │ └── ExpressionVisitor.hpp
│ ├── EnggeApplication.hpp
│ ├── Engine/
│ │ ├── ActorIconSlot.hpp
│ │ ├── ActorIcons.hpp
│ │ ├── Callback.hpp
│ │ ├── Camera.hpp
│ │ ├── ChangeProperty.hpp
│ │ ├── Cutscene.hpp
│ │ ├── Engine.hpp
│ │ ├── EngineCommands.hpp
│ │ ├── EngineSettings.hpp
│ │ ├── EntityManager.hpp
│ │ ├── ExCommandConstants.hpp
│ │ ├── Function.hpp
│ │ ├── Hud.hpp
│ │ ├── InputStateConstants.hpp
│ │ ├── Interpolations.hpp
│ │ ├── Inventory.hpp
│ │ ├── Light.hpp
│ │ ├── Preferences.hpp
│ │ ├── RoomEffect.hpp
│ │ ├── SavegameSlot.hpp
│ │ ├── Sentence.hpp
│ │ ├── TextDatabase.hpp
│ │ ├── Thread.hpp
│ │ ├── ThreadBase.hpp
│ │ ├── TimeFunction.hpp
│ │ ├── Trigger.hpp
│ │ └── Verb.hpp
│ ├── Entities/
│ │ ├── Actor.hpp
│ │ ├── AnimationLoader.hpp
│ │ ├── BlinkState.hpp
│ │ ├── Costume.hpp
│ │ ├── DirectionConstants.hpp
│ │ ├── Entity.hpp
│ │ ├── Facing.hpp
│ │ ├── Object.hpp
│ │ ├── TextObject.hpp
│ │ └── UseDirection.hpp
│ ├── Graphics/
│ │ ├── AnimControl.hpp
│ │ ├── AnimDrawable.hpp
│ │ ├── AnimState.hpp
│ │ ├── Animation.hpp
│ │ ├── GGFont.hpp
│ │ ├── LightingShader.h
│ │ ├── ResourceManager.hpp
│ │ ├── Screen.hpp
│ │ ├── SpriteSheet.hpp
│ │ ├── SpriteSheetItem.h
│ │ └── Text.hpp
│ ├── Input/
│ │ ├── CommandManager.hpp
│ │ ├── InputConstants.hpp
│ │ └── InputMappings.hpp
│ ├── Parsers/
│ │ ├── GGPackBufferStream.hpp
│ │ ├── GGPackStream.hpp
│ │ ├── Lip.hpp
│ │ ├── SavegameManager.hpp
│ │ ├── YackParser.hpp
│ │ └── YackTokenReader.hpp
│ ├── Room/
│ │ ├── Room.hpp
│ │ ├── RoomLayer.hpp
│ │ └── RoomScaling.hpp
│ ├── Scripting/
│ │ ├── ScriptEngine.hpp
│ │ ├── ScriptExecute.hpp
│ │ ├── ScriptObject.hpp
│ │ └── VerbExecute.hpp
│ ├── System/
│ │ ├── Locator.hpp
│ │ ├── Logger.hpp
│ │ ├── NonCopyable.hpp
│ │ └── Services.hpp
│ ├── UI/
│ │ ├── OptionsDialog.hpp
│ │ ├── QuitDialog.hpp
│ │ ├── SaveLoadDialog.hpp
│ │ └── StartScreenDialog.hpp
│ └── Util/
│ ├── BTEACrypto.hpp
│ └── RandomNumberGenerator.hpp
└── src/
├── Audio/
│ ├── SoundDefinition.cpp
│ ├── SoundId.cpp
│ ├── SoundManager.cpp
│ └── SoundTrigger.cpp
├── CMakeLists.txt
├── Dialog/
│ ├── Ast.cpp
│ ├── AstDump.hpp
│ ├── ConditionVisitor.cpp
│ ├── DialogManager.cpp
│ ├── DialogPlayer.cpp
│ ├── EngineDialogScript.cpp
│ └── ExpressionVisitor.cpp
├── EnggeApplication.cpp
├── Engine/
│ ├── AchievementManager.cpp
│ ├── AchievementManager.hpp
│ ├── ActorIcons.cpp
│ ├── Callback.cpp
│ ├── Camera.cpp
│ ├── Cutscene.cpp
│ ├── DebugFeatures.hpp
│ ├── Engine.cpp
│ ├── EngineImpl.cpp
│ ├── EngineImpl.hpp
│ ├── EngineSettings.cpp
│ ├── EntityManager.cpp
│ ├── Hud.cpp
│ ├── Inventory.cpp
│ ├── Light.cpp
│ ├── Preferences.cpp
│ ├── Sentence.cpp
│ ├── Shaders.cpp
│ ├── Shaders.hpp
│ ├── TextDatabase.cpp
│ ├── Thread.cpp
│ ├── ThreadBase.cpp
│ ├── TimeFunction.cpp
│ └── Trigger.cpp
├── Entities/
│ ├── Actor.cpp
│ ├── AnimationLoader.cpp
│ ├── BlinkState.cpp
│ ├── Costume.cpp
│ ├── Entity.cpp
│ ├── JiggleFunction.cpp
│ ├── JiggleFunction.hpp
│ ├── LipAnimation.cpp
│ ├── LipAnimation.hpp
│ ├── Object.cpp
│ ├── ShakeFunction.cpp
│ ├── ShakeFunction.hpp
│ ├── TalkingState.cpp
│ ├── TalkingState.hpp
│ ├── TextObject.cpp
│ ├── WalkingState.cpp
│ └── WalkingState.hpp
├── Graphics/
│ ├── AnimControl.cpp
│ ├── AnimDrawable.cpp
│ ├── GGFont.cpp
│ ├── GraphDrawable.cpp
│ ├── GraphDrawable.hpp
│ ├── LightingShader.cpp
│ ├── PathDrawable.cpp
│ ├── PathDrawable.hpp
│ ├── ResourceManager.cpp
│ ├── SpriteSheet.cpp
│ ├── Text.cpp
│ ├── WalkboxDrawable.cpp
│ └── WalkboxDrawable.hpp
├── Input/
│ ├── CommandManager.cpp
│ └── InputMappings.cpp
├── Parsers/
│ ├── GGPackBufferStream.cpp
│ ├── Lip.cpp
│ ├── SavegameManager.cpp
│ ├── YackParser.cpp
│ └── YackTokenReader.cpp
├── Room/
│ ├── Room.cpp
│ ├── RoomLayer.cpp
│ ├── RoomScaling.cpp
│ ├── RoomTrigger.cpp
│ ├── RoomTrigger.hpp
│ ├── RoomTriggerThread.cpp
│ └── RoomTriggerThread.hpp
├── Scripting/
│ ├── ActorPack.hpp
│ ├── ActorWalk.cpp
│ ├── ActorWalk.hpp
│ ├── BnutPass.hpp
│ ├── DefaultScriptExecute.cpp
│ ├── DefaultScriptExecute.hpp
│ ├── DefaultVerbExecute.cpp
│ ├── DefaultVerbExecute.hpp
│ ├── GeneralPack.hpp
│ ├── ObjectPack.hpp
│ ├── PostWalk.cpp
│ ├── PostWalk.hpp
│ ├── ReachAnim.cpp
│ ├── ReachAnim.hpp
│ ├── RoomPack.hpp
│ ├── ScriptEngine.cpp
│ ├── ScriptEngine.inl
│ ├── SetDefaultVerb.cpp
│ ├── SetDefaultVerb.hpp
│ ├── SoundPack.hpp
│ ├── SystemPack.hpp
│ ├── VerbExecuteFunction.cpp
│ └── VerbExecuteFunction.hpp
├── System/
│ ├── DebugTools/
│ │ ├── ActorTools.cpp
│ │ ├── ActorTools.hpp
│ │ ├── CameraTools.cpp
│ │ ├── CameraTools.hpp
│ │ ├── Console.cpp
│ │ ├── Console.hpp
│ │ ├── ConsoleTools.cpp
│ │ ├── ConsoleTools.hpp
│ │ ├── DebugControls.cpp
│ │ ├── DebugControls.hpp
│ │ ├── DebugTools.cpp
│ │ ├── DebugTools.hpp
│ │ ├── GeneralTools.cpp
│ │ ├── GeneralTools.hpp
│ │ ├── ObjectTools.cpp
│ │ ├── ObjectTools.hpp
│ │ ├── PreferencesTools.cpp
│ │ ├── PreferencesTools.hpp
│ │ ├── RoomTools.cpp
│ │ ├── RoomTools.hpp
│ │ ├── SoundTools.cpp
│ │ ├── SoundTools.hpp
│ │ ├── TextureTools.cpp
│ │ ├── TextureTools.hpp
│ │ ├── ThreadTools.cpp
│ │ └── ThreadTools.hpp
│ └── Logger.cpp
├── UI/
│ ├── Button.cpp
│ ├── Button.hpp
│ ├── Checkbox.cpp
│ ├── Checkbox.hpp
│ ├── Control.cpp
│ ├── Control.hpp
│ ├── ControlConstants.hpp
│ ├── HelpDialog.cpp
│ ├── HelpDialog.hpp
│ ├── OptionsDialog.cpp
│ ├── QuitDialog.cpp
│ ├── SaveLoadDialog.cpp
│ ├── Slider.cpp
│ ├── Slider.hpp
│ ├── StartScreenDialog.cpp
│ ├── SwitchButton.cpp
│ └── SwitchButton.hpp
├── Util/
│ ├── BTEACrypto.cpp
│ ├── Dumper.hpp
│ ├── RandomNumberGenerator.cpp
│ ├── Util.cpp
│ └── Util.hpp
└── main.cpp
Showing preview only (210K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2593 symbols across 347 files)
FILE: extlibs/spdlog/include/spdlog/async.h
function namespace (line 25) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/async_logger-inl.h
function SPDLOG_INLINE (line 17) | SPDLOG_INLINE spdlog::async_logger::async_logger(
FILE: extlibs/spdlog/include/spdlog/async_logger.h
type class (line 22) | enum class
function namespace (line 29) | namespace details {
FILE: extlibs/spdlog/include/spdlog/common-inl.h
function namespace (line 10) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/common.h
function namespace (line 71) | namespace sinks {
function namespace (line 126) | namespace level {
type class (line 163) | enum class
type class (line 174) | enum class
function class (line 183) | class spdlog_ex : public std::exception
type source_loc (line 194) | struct source_loc
function line (line 208) | int line{0}
function namespace (line 212) | namespace details {
FILE: extlibs/spdlog/include/spdlog/details/circular_q.h
function namespace (line 9) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/console_globals.h
function namespace (line 9) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/file_helper-inl.h
function namespace (line 19) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/fmt_helper.h
function namespace (line 11) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/log_msg-inl.h
function namespace (line 12) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/log_msg.h
function namespace (line 9) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/mpmc_blocking_q.h
function namespace (line 18) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/null_mutex.h
function namespace (line 9) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/os-inl.h
function namespace (line 61) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/pattern_formatter-inl.h
function namespace (line 29) | namespace details {
function string_view_t (line 83) | string_view_t spaces_{" ...
type null_scoped_padder (line 86) | struct null_scoped_padder
function format (line 99) | void format(const details::log_msg &msg, const std::tm &, fmt::memory_bu...
function format (line 115) | void format(const details::log_msg &msg, const std::tm &, fmt::memory_bu...
function format (line 132) | void format(const details::log_msg &msg, const std::tm &, fmt::memory_bu...
function to12h (line 149) | static int to12h(const tm &t)
function format (line 165) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memor...
function format (line 184) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memor...
function format (line 203) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memor...
function std (line 212) | static const std::array<const char *, 12> full_months{
function SPDLOG_INLINE (line 1010) | SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
function SPDLOG_INLINE (line 1033) | SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_ms...
function handle_flag_ (line 1043) | void pattern_formatter::handle_flag_(char flag, details::padding_info pa...
FILE: extlibs/spdlog/include/spdlog/details/pattern_formatter.h
function namespace (line 18) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/periodic_worker-inl.h
function namespace (line 10) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/periodic_worker.h
function namespace (line 17) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/registry-inl.h
function namespace (line 30) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/registry.h
function namespace (line 20) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/synchronous_factory.h
function namespace (line 8) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/thread_pool-inl.h
function namespace (line 12) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/details/thread_pool.h
function namespace (line 16) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/fmt/bin_to_hex.h
function namespace (line 24) | namespace spdlog {
function namespace (line 68) | namespace fmt {
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/chrono.h
function FMT_BEGIN_NAMESPACE (line 19) | FMT_BEGIN_NAMESPACE
type std (line 377) | typedef std::chrono::duration<Rep, Period> duration;
type spec_handler (line 379) | struct spec_handler {
function arg_ref_type (line 391) | arg_ref_type make_arg_ref(internal::auto_id) {
function on_error (line 395) | void on_error(const char *msg) { throw format_error(msg); }
function on_fill (line 396) | void on_fill(Char fill) { f.spec.fill_ = fill; }
function on_align (line 397) | void on_align(alignment align) { f.spec.align_ = align; }
function on_width (line 398) | void on_width(unsigned width) { f.spec.width_ = width; }
function FMT_CONSTEXPR (line 409) | FMT_CONSTEXPR auto parse(basic_parse_context<Char> &ctx)
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/color.h
type color (line 18) | enum color { black, red, green, yellow, blue, magenta, cyan, white }
function print_colored (line 22) | void print_colored(color c, string_view format_str,
function print_colored (line 27) | void print_colored(color c, wstring_view format_str,
function vprint_colored (line 32) | inline void vprint_colored(color c, string_view format, format_args args) {
function vprint_colored (line 40) | inline void vprint_colored(color c, wstring_view format, wformat_args ar...
function color (line 50) | enum class color : uint32_t {
function namespace (line 389) | namespace internal {
type typename (line 553) | typedef typename internal::char_t<String>::type char_t;
type typename (line 554) | typedef typename buffer_context<char_t>::type context_t;
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/core.h
function FMT_BEGIN_NAMESPACE (line 189) | FMT_BEGIN_NAMESPACE
type Char (line 357) | typedef const Char *iterator;
function FMT_CONSTEXPR (line 359) | FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(...
function FMT_CONSTEXPR (line 394) | FMT_CONSTEXPR void remove_prefix(size_t n) {
function compare (line 400) | int compare(basic_string_view other) const {
type basic_string_view (line 428) | typedef basic_string_view<char> string_view;
type basic_string_view (line 429) | typedef basic_string_view<wchar_t> wstring_view;
type compile_string (line 472) | struct compile_string {}
function namespace (line 507) | namespace internal {
type type (line 530) | enum type {
function FMT_CONSTEXPR (line 540) | FMT_CONSTEXPR bool is_integral(type t) {
function FMT_CONSTEXPR (line 545) | FMT_CONSTEXPR bool is_arithmetic(type t) {
function named_arg_base (line 611) | const named_arg_base<char_type> &as_named_arg() {
function format_custom_arg (line 618) | void format_custom_arg(const void *arg, Context &ctx) {
function FMT_CONSTEXPR (line 635) | FMT_CONSTEXPR init(const T &v) : val(v) {}
type std (line 660) | typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
function custom_ (line 800) | custom_(custom) {}
function format (line 802) | void format(Context &ctx) const { custom_.format(custom_.value, ctx); }
type typename (line 832) | typedef typename Context::char_type char_type;
type typename (line 885) | typedef typename basic_string_view<Char>::iterator iterator;
function FMT_CONSTEXPR (line 901) | FMT_CONSTEXPR void advance_to(iterator it) {
function FMT_CONSTEXPR (line 908) | FMT_CONSTEXPR bool check_arg_id(unsigned) {
function check_arg_id (line 916) | void check_arg_id(basic_string_view<Char>) {}
function FMT_CONSTEXPR (line 918) | FMT_CONSTEXPR void on_error(const char *message) {
type typename (line 940) | typedef typename Context::char_type char_type;
type entry (line 942) | struct entry {
function push_back (line 950) | void push_back(value<Context> val) {
function class (line 972) | class locale_ref {
type basic_format_arg (line 1000) | typedef basic_format_arg<Context> format_arg;
function format_arg (line 1017) | format_arg get_arg(unsigned arg_id) {
function on_error (line 1031) | void on_error(const char *message) { parse_context_.on_error(message); }
function iterator (line 1034) | iterator out() { return out_; }
function iterator (line 1035) | iterator begin() { return out_; }
function advance_to (line 1038) | void advance_to(iterator it) { out_ = it; }
function locale_ref (line 1040) | locale_ref locale() { return loc_; }
type value_type (line 1045) | typedef decltype(make_value<Context>(
function get_types (line 1051) | unsigned long long get_types() { return 0; }
function get_types (line 1054) | unsigned long long get_types() {
type formatter (line 1090) | typedef formatter<T, char_type> type;
type internal (line 1098) | typedef internal::context_base<OutputIt, basic_format_context, Char> base;
type typename (line 1099) | typedef typename base::format_arg format_arg;
function format_arg (line 1114) | format_arg next_arg() {
function format_arg (line 1117) | format_arg get_arg(unsigned arg_id) { return this->do_get_arg(arg_id); }
type basic_format_context (line 1126) | typedef basic_format_context<
type buffer_context (line 1129) | typedef buffer_context<char>::type format_context;
type buffer_context (line 1130) | typedef buffer_context<wchar_t>::type wformat_context;
type typename (line 1147) | typedef typename std::conditional<IS_PACKED,
function get_types (line 1157) | static FMT_CONSTEXPR11 unsigned long long get_types() {
function data_ (line 1179) | format_arg_store(const Args &... args)
type basic_format_arg (line 1206) | typedef basic_format_arg<Context> format_arg;
function typename (line 1224) | typename internal::type type(unsigned index) const {
function set_data (line 1232) | void set_data(const internal::value<Context> *values) { values_ = values; }
function set_data (line 1233) | void set_data(const format_arg *args) { args_ = args; }
function format_arg (line 1235) | format_arg do_get(size_type index) const {
function TYPES (line 1263) | long>(store.TYPES)) {
function format_arg (line 1278) | format_arg get(size_type index) const {
function size_type (line 1285) | size_type max_size() const {
function namespace (line 1323) | namespace internal {
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/format-inl.h
function fmt (line 58) | inline fmt::internal::null<> strerror_r(int, char *, ...) {
function fmt (line 61) | inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
function FMT_BEGIN_NAMESPACE (line 65) | FMT_BEGIN_NAMESPACE
function format_error_code (line 159) | void format_error_code(internal::buffer &out, int error_code,
function report_error (line 186) | void report_error(FormatFunc func, int error_code,
function namespace (line 208) | namespace internal {
function Char (line 229) | Char internal::thousands_sep_impl(locale_ref) {
function namespace (line 243) | namespace internal {
function FMT_FUNC (line 453) | FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
type gen_digits_params (line 541) | struct gen_digits_params {
function insert (line 548) | struct prettify_handler {
function insert (line 567) | void insert(ptrdiff_t pos, char c) {
function append (line 573) | void append(ptrdiff_t n, char c) {
function append (line 578) | void append(char c) { data[size++] = c; }
function remove_trailing (line 580) | void remove_trailing(char c) {
function write_exponent (line 587) | void write_exponent(int exp, Handler &&h) {
type fill (line 608) | struct fill {
function grisu2_prettify (line 619) | void grisu2_prettify(const gen_digits_params ¶ms,
function insert (line 659) | struct char_counter {
function append (line 665) | void append(ptrdiff_t n, char) { size += n; }
function append (line 666) | void append(char) { ++size; }
function remove_trailing (line 667) | void remove_trailing(char) {}
function char_counter (line 708) | char_counter counter{num_digits};
function FMT_FUNC (line 810) | FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
function FMT_FUNC (line 834) | FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
function FMT_FUNC (line 906) | FMT_FUNC void format_system_error(
function FMT_FUNC (line 933) | FMT_FUNC void report_system_error(
function FMT_FUNC (line 939) | FMT_FUNC void report_windows_error(
function FMT_FUNC (line 945) | FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args a...
function FMT_FUNC (line 952) | FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args...
function FMT_FUNC (line 958) | FMT_FUNC void vprint(string_view format_str, format_args args) {
function FMT_FUNC (line 962) | FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/format.h
function FMT_BEGIN_NAMESPACE (line 101) | FMT_BEGIN_NAMESPACE
function FMT_BEGIN_NAMESPACE (line 187) | FMT_BEGIN_NAMESPACE
function FMT_BEGIN_NAMESPACE (line 235) | FMT_BEGIN_NAMESPACE
function FMT_END_NAMESPACE (line 295) | FMT_END_NAMESPACE
type sentinel (line 338) | typedef void sentinel;
type T (line 343) | typedef T value_type;
function explicit (line 345) | explicit output_range(OutputIt it): it_(it) {}
function base (line 358) | back_insert_range(typename base::iterator it): base(it) {}
type basic_writer (line 361) | typedef basic_writer<back_insert_range<internal::buffer>> writer;
type basic_writer (line 362) | typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
function class (line 365) | class format_error : public std::runtime_error {
function namespace (line 374) | namespace internal {
type char8_t (line 407) | enum char8_t: unsigned char {}
function class (line 411) | class u8string_view : public basic_string_view<char8_t> {
type basic_memory_buffer (line 553) | typedef basic_memory_buffer<char> memory_buffer;
type basic_memory_buffer (line 554) | typedef basic_memory_buffer<wchar_t> wmemory_buffer;
function namespace (line 556) | namespace internal {
type T (line 622) | typedef T value_type;
type std (line 623) | typedef std::ptrdiff_t difference_type;
type T (line 624) | typedef T* pointer;
type T (line 625) | typedef T& reference;
type counting_iterator (line 626) | typedef counting_iterator _Unchecked_type;
type difference_type (line 658) | typedef void difference_type;
type pointer (line 659) | typedef void pointer;
type reference (line 660) | typedef void reference;
type truncating_iterator_base (line 661) | typedef truncating_iterator_base _Unchecked_type;
type std (line 676) | typedef std::iterator_traits<OutputIt> traits;
type typename (line 740) | typedef typename std::conditional<
function write_pair (line 851) | void write_pair(unsigned N, uint32_t index) {
function count_digits (line 899) | inline int count_digits(uint32_t n) {
function enum (line 906) | struct no_thousands_sep {
function explicit (line 927) | explicit add_thousands_sep(basic_string_view<Char> sep)
function Char (line 945) | Char thousands_sep(locale_ref loc) {
function wchar_t (line 950) | inline wchar_t thousands_sep(locale_ref loc) {
function Char (line 958) | Char *format_decimal(Char *buffer, UInt value, int num_digits,
function Iterator (line 987) | Iterator format_decimal(
function It (line 1000) | It format_decimal(It out, UInt value, int num_digits) {
function class (line 1039) | class utf8_to_utf16 {
function class (line 1053) | class utf16_to_utf8 {
type alignment (line 1079) | enum alignment {
type align_spec (line 1087) | struct align_spec {
type core_format_specs (line 1100) | struct core_format_specs {
function FMT_CONSTEXPR (line 1112) | FMT_CONSTEXPR basic_format_specs() {}
type basic_format_specs (line 1115) | typedef basic_format_specs<char> format_specs;
function namespace (line 1125) | namespace internal {
function handle_int_type_spec (line 1140) | void handle_int_type_spec(char spec, Handler &&handler) {
function handle_float_type_spec (line 1163) | void handle_float_type_spec(char spec, Handler &&handler) {
function handle_char_specs (line 1184) | void handle_char_specs(
function handle_cstring_type_spec (line 1194) | void handle_cstring_type_spec(Char spec, Handler &&handler) {
function check_string_type_spec (line 1204) | void check_string_type_spec(Char spec, ErrorHandler &&eh) {
function check_pointer_type_spec (line 1210) | void check_pointer_type_spec(Char spec, ErrorHandler &&eh) {
function FMT_CONSTEXPR (line 1220) | FMT_CONSTEXPR void on_dec() {}
function FMT_CONSTEXPR (line 1221) | FMT_CONSTEXPR void on_hex() {}
function FMT_CONSTEXPR (line 1222) | FMT_CONSTEXPR void on_bin() {}
function FMT_CONSTEXPR (line 1223) | FMT_CONSTEXPR void on_oct() {}
function FMT_CONSTEXPR (line 1224) | FMT_CONSTEXPR void on_num() {}
function FMT_CONSTEXPR (line 1226) | FMT_CONSTEXPR void on_error() {
function FMT_CONSTEXPR (line 1237) | FMT_CONSTEXPR void on_general() {}
function FMT_CONSTEXPR (line 1238) | FMT_CONSTEXPR void on_exp() {}
function FMT_CONSTEXPR (line 1239) | FMT_CONSTEXPR void on_fixed() {}
function FMT_CONSTEXPR (line 1240) | FMT_CONSTEXPR void on_hex() {}
function FMT_CONSTEXPR (line 1242) | FMT_CONSTEXPR void on_error() {
function FMT_CONSTEXPR (line 1256) | FMT_CONSTEXPR void on_int() {
function FMT_CONSTEXPR (line 1259) | FMT_CONSTEXPR void on_char() {}
function FMT_CONSTEXPR (line 1268) | FMT_CONSTEXPR void on_string() {}
function FMT_CONSTEXPR (line 1269) | FMT_CONSTEXPR void on_pointer() {}
type iterator (line 1308) | typedef decltype(internal::declval<Range>().begin()) iterator;
type basic_format_specs (line 1309) | typedef basic_format_specs<char_type> format_specs;
type char_writer (line 1316) | struct char_writer {
function write_char (line 1326) | void write_char(char_type value) {
function write_pointer (line 1333) | void write_pointer(const void *p) {
function format_specs (line 1342) | format_specs *spec() { return specs_; }
function iterator (line 1343) | iterator out() { return writer_.out(); }
function write (line 1345) | void write(bool value) {
function write (line 1350) | void write(const char_type *value) {
function error_handler (line 1393) | struct char_spec_handler : internal::error_handler {
function error_handler (line 1409) | struct cstring_spec_handler : internal::error_handler {
function iterator (line 1420) | iterator operator()(const char_type *value) {
function iterator (line 1427) | iterator operator()(basic_string_view<char_type> value) {
function iterator (line 1438) | iterator operator()(const void *value) {
function is_name_start (line 1447) | bool is_name_start(Char c) {
function parse_nonnegative_int (line 1454) | unsigned parse_nonnegative_int(
function const (line 1487) | bool operator()(typename basic_format_arg<Context>::handle h) const {
function handler_ (line 1507) | handler_(eh) {}
function handler_ (line 1532) | handler_(eh) {}
function specs_ (line 1558) | specs_(specs) {}
function FMT_CONSTEXPR (line 1560) | FMT_CONSTEXPR specs_setter(const specs_setter &other): specs_(other.spec...
function FMT_CONSTEXPR (line 1562) | FMT_CONSTEXPR void on_align(alignment align) { specs_.align_ = align; }
function FMT_CONSTEXPR (line 1563) | FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill_ = fill; }
function FMT_CONSTEXPR (line 1564) | FMT_CONSTEXPR void on_plus() { specs_.flags |= SIGN_FLAG | PLUS_FLAG; }
function FMT_CONSTEXPR (line 1565) | FMT_CONSTEXPR void on_minus() { specs_.flags |= MINUS_FLAG; }
function FMT_CONSTEXPR (line 1566) | FMT_CONSTEXPR void on_space() { specs_.flags |= SIGN_FLAG; }
function FMT_CONSTEXPR (line 1567) | FMT_CONSTEXPR void on_hash() { specs_.flags |= HASH_FLAG; }
function FMT_CONSTEXPR (line 1569) | FMT_CONSTEXPR void on_zero() {
function FMT_CONSTEXPR (line 1574) | FMT_CONSTEXPR void on_width(unsigned width) { specs_.width_ = width; }
function FMT_CONSTEXPR (line 1575) | FMT_CONSTEXPR void on_precision(unsigned precision) {
function FMT_CONSTEXPR (line 1578) | FMT_CONSTEXPR void end_precision() {}
function FMT_CONSTEXPR (line 1580) | FMT_CONSTEXPR void on_type(Char type) {
function FMT_CONSTEXPR (line 1605) | FMT_CONSTEXPR void on_plus() {
function FMT_CONSTEXPR (line 1610) | FMT_CONSTEXPR void on_minus() {
function FMT_CONSTEXPR (line 1615) | FMT_CONSTEXPR void on_space() {
function FMT_CONSTEXPR (line 1620) | FMT_CONSTEXPR void on_hash() {
function FMT_CONSTEXPR (line 1625) | FMT_CONSTEXPR void on_zero() {
function FMT_CONSTEXPR (line 1630) | FMT_CONSTEXPR void end_precision() {
function FMT_CONSTEXPR (line 1641) | FMT_CONSTEXPR void check_sign() {
type auto_id (line 1663) | struct auto_id {}
function FMT_CONSTEXPR (line 1671) | FMT_CONSTEXPR specs_handler(
function on_dynamic_width (line 1676) | void on_dynamic_width(Id arg_id) {
function on_dynamic_precision (line 1682) | void on_dynamic_precision(Id arg_id) {
function on_error (line 1687) | void on_error(const char *message) {
type Kind (line 1708) | enum Kind { NONE, INDEX, NAME }
function FMT_CONSTEXPR (line 1711) | FMT_CONSTEXPR explicit arg_ref(unsigned index) : kind(INDEX), index(inde...
function explicit (line 1712) | explicit arg_ref(basic_string_view<Char> nm) : kind(NAME) {
function on_dynamic_width (line 1755) | void on_dynamic_width(Id arg_id) {
function on_dynamic_precision (line 1760) | void on_dynamic_precision(Id arg_id) {
function FMT_CONSTEXPR (line 1764) | FMT_CONSTEXPR void on_error(const char *message) {
function arg_ref_type (line 1772) | arg_ref_type make_arg_ref(Id arg_id) {
function make_arg_ref (line 1777) | make_arg_ref(auto_id) {
function Char (line 1786) | const Char *parse_arg_id(
function handler (line 1812) | handler(h) {}
function FMT_CONSTEXPR (line 1814) | FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
function FMT_CONSTEXPR (line 1815) | FMT_CONSTEXPR void operator()(unsigned id) { handler.on_dynamic_width(id...
function FMT_CONSTEXPR (line 1820) | FMT_CONSTEXPR void on_error(const char *message) {
function handler (line 1830) | handler(h) {}
function FMT_CONSTEXPR (line 1832) | FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()...
function FMT_CONSTEXPR (line 1833) | FMT_CONSTEXPR void operator()(unsigned id) {
function FMT_CONSTEXPR (line 1840) | FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(mess...
function Char (line 1847) | const Char *parse_align(
function Char (line 1884) | const Char *parse_width(
function Char (line 1903) | const Char *parse_format_specs(
function find (line 1970) | bool find(Ptr first, Ptr last, T value, Ptr &out) {
function FMT_CONSTEXPR (line 1987) | FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
function FMT_CONSTEXPR (line 1988) | FMT_CONSTEXPR void operator()(unsigned id) { handler.on_arg_id(id); }
function FMT_CONSTEXPR (line 1992) | FMT_CONSTEXPR void on_error(const char *message) {
function typename (line 2052) | const typename ParseContext::char_type *
function FMT_CONSTEXPR (line 2067) | FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
function FMT_CONSTEXPR (line 2069) | FMT_CONSTEXPR void on_arg_id() {
function FMT_CONSTEXPR (line 2073) | FMT_CONSTEXPR void on_arg_id(unsigned id) {
function FMT_CONSTEXPR (line 2096) | FMT_CONSTEXPR void check_arg_id() {
type Char (line 2102) | typedef const Char *(*parse_func)(parse_context_type &);
type typename (line 2120) | typedef typename S::char_type char_t;
type typename (line 2136) | typedef typename Context::char_type char_type;
type internal (line 2161) | typedef internal::arg_formatter_base<Range> base;
type basic_format_context (line 2162) | typedef basic_format_context<typename
type typename (line 2168) | typedef typename base::iterator iterator;
type typename (line 2169) | typedef typename base::format_specs format_specs;
function explicit (line 2178) | explicit arg_formatter(context_type &ctx, format_specs *spec = FMT_NULL)
function iterator (line 2188) | iterator operator()(typename basic_format_arg<context_type>::handle hand...
type iterator (line 2262) | typedef decltype(internal::declval<Range>().begin()) iterator;
type basic_format_specs (line 2263) | typedef basic_format_specs<char_type> format_specs;
function decltype (line 2271) | auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
type typename (line 2350) | typedef typename internal::int_traits<Int>::main_type main_type;
type typename (line 2365) | typedef typename internal::int_traits<Int>::main_type unsigned_type;
type dec_writer (line 2399) | struct dec_writer {
function on_dec (line 2409) | void on_dec() {
type hex_writer (line 2415) | struct hex_writer {
function on_hex (line 2426) | void on_hex() {
function on_bin (line 2447) | void on_bin() {
function on_oct (line 2457) | void on_oct() {
type num_writer (line 2471) | struct num_writer {
function on_num (line 2484) | void on_num() {
function on_error (line 2492) | void on_error() {
function width (line 2506) | struct inf_or_nan_writer {
function write (line 2573) | void write(int value) { write_decimal(value); }
function write (line 2574) | void write(long value) { write_decimal(value); }
function write (line 2575) | void write(long long value) { write_decimal(value); }
function write (line 2577) | void write(unsigned value) { write_decimal(value); }
function write (line 2578) | void write(unsigned long value) { write_decimal(value); }
function write (line 2579) | void write(unsigned long long value) { write_decimal(value); }
function write (line 2594) | void write(double value) {
function write (line 2604) | void write(long double value) {
function write (line 2609) | void write(char value) {
function write (line 2612) | void write(wchar_t value) {
function write (line 2622) | void write(string_view value) {
function write (line 2626) | void write(wstring_view value) {
function on_exp (line 2658) | struct float_spec_handler {
function on_fixed (line 2676) | void on_fixed() {
function on_hex (line 2686) | void on_hex() {
function on_error (line 2691) | void on_error() {
type write_inf_or_nan_t (line 2713) | struct write_inf_or_nan_t {
function class (line 2766) | class windows_error : public system_error {
function class (line 2813) | class format_int {
function explicit (line 2855) | explicit format_int(long value) { format_signed(value); }
function explicit (line 2856) | explicit format_int(long long value) { format_signed(value); }
function explicit (line 2857) | explicit format_int(unsigned value) : str_(format_decimal(value)) {}
function explicit (line 2858) | explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
function explicit (line 2859) | explicit format_int(unsigned long long value) : str_(format_decimal(valu...
type typename (line 2895) | typedef typename internal::int_traits<T>::main_type main_type;
function typename (line 2927) | typename ParseContext::iterator parse(ParseContext &ctx) {
type output_range (line 2983) | typedef output_range<typename
type null_handler (line 3006) | struct null_handler
function on_align (line 3007) | void on_align(alignment) {}
function on_plus (line 3008) | void on_plus() {}
function on_minus (line 3009) | void on_minus() {}
function on_space (line 3010) | void on_space() {}
function on_hash (line 3011) | void on_hash() {}
type output_range (line 3037) | typedef output_range<typename
type typename (line 3069) | typedef typename ArgFormatter::range range;
function on_arg_id (line 3084) | void on_arg_id() { arg = context.next_arg(); }
function on_arg_id (line 3085) | void on_arg_id(unsigned id) {
function on_arg_id (line 3089) | void on_arg_id(basic_string_view<Char> id) {
function on_replacement_field (line 3093) | void on_replacement_field(const Char *p) {
function Char (line 3100) | const Char *on_format_specs(const Char *begin, const Char *end) {
type formatter (line 3156) | typedef formatter<typename
function string (line 3209) | string to_string(const T &value) {
function wstring (line 3220) | wstring to_wstring(const T &value) {
type back_insert_range (line 3236) | typedef back_insert_range<internal::basic_buffer<Char> > range;
type typename (line 3256) | typedef typename buffer_context<Char>::type context;
function namespace (line 3262) | namespace internal {
type type (line 3299) | typedef decltype(test<It>(typename it_category<It>::type{})) type;
type typename (line 3300) | typedef typename std::remove_reference<type>::type result;
type typename (line 3344) | typedef typename format_context_t<OutputIt, FMT_CHAR(S)>::type context;
type basic_format_args (line 3364) | typedef basic_format_args<
type Char (line 3402) | typedef FMT_CHAR(S) Char;
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/locale.h
function FMT_BEGIN_NAMESPACE (line 14) | FMT_BEGIN_NAMESPACE
type typename (line 69) | typedef typename format_context_t<OutputIt, FMT_CHAR(S)>::type context;
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/ostream.h
function FMT_BEGIN_NAMESPACE (line 14) | FMT_BEGIN_NAMESPACE
type null (line 51) | struct null
type result (line 68) | typedef decltype(test<T>(0)) result;
type std (line 78) | typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
function vprint (line 128) | void vprint(std::basic_ostream<Char> &os,
function typename (line 145) | typename std::enable_if<internal::is_string<S>::value>::type
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/posix.h
function FMT_BEGIN_NAMESPACE (line 65) | FMT_BEGIN_NAMESPACE
type basic_cstring_view (line 112) | typedef basic_cstring_view<char> cstring_view;
type basic_cstring_view (line 113) | typedef basic_cstring_view<wchar_t> wcstring_view;
function class (line 116) | class error_code {
function class (line 127) | class buffered_file {
function print (line 177) | void print(string_view format_str, const Args & ... args) {
function class (line 188) | class file {
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/printf.h
function FMT_BEGIN_NAMESPACE (line 16) | FMT_BEGIN_NAMESPACE
function T (line 104) | const T *pointer_from(const T *p) { return p; }
function fits_in_int (line 148) | bool fits_in_int(T value) {
function fits_in_int (line 152) | static bool fits_in_int(bool) { return true; }
type int_checker (line 156) | struct int_checker
function fits_in_int (line 158) | bool fits_in_int(T value) {
function fits_in_int (line 162) | static bool fits_in_int(int) { return true; }
function class (line 165) | class printf_precision_handler: public function<int> {
function class (line 183) | class is_zero_int: public function<bool> {
function bool (line 198) | struct make_unsigned_or_bool<bool> {
type typename (line 231) | typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
function arg_ (line 270) | arg_(arg) {}
type typename (line 300) | typedef typename internal::int_traits<T>::main_type UnsignedType;
type iterator (line 350) | typedef decltype(internal::declval<Range>().begin()) iterator;
type internal (line 351) | typedef internal::arg_formatter_base<Range> base;
type basic_printf_context (line 352) | typedef basic_printf_context<iterator, char_type> context_type;
function write_null_pointer (line 356) | void write_null_pointer(char) {
function write_null_pointer (line 361) | void write_null_pointer(wchar_t) {
function iterator (line 413) | iterator operator()(const char *value) {
function iterator (line 424) | iterator operator()(const wchar_t *value) {
function iterator (line 434) | iterator operator()(basic_string_view<char_type> value) {
function iterator (line 438) | iterator operator()(monostate value) {
function iterator (line 443) | iterator operator()(const void *value) {
function iterator (line 452) | iterator operator()(typename basic_format_arg<context_type>::handle hand...
type printf_formatter (line 482) | typedef printf_formatter<T> type;
type typename (line 486) | typedef typename base::format_arg format_arg;
type basic_format_specs (line 487) | typedef basic_format_specs<char_type> format_specs;
type internal (line 488) | typedef internal::null_terminating_iterator<char_type> iterator;
type basic_printf_context (line 703) | typedef basic_printf_context<
type basic_printf_context_t (line 707) | typedef basic_printf_context_t<internal::buffer>::type printf_context;
type basic_printf_context_t (line 708) | typedef basic_printf_context_t<internal::wbuffer>::type wprintf_context;
type basic_format_args (line 710) | typedef basic_format_args<printf_context> printf_args;
type basic_format_args (line 711) | typedef basic_format_args<wprintf_context> wprintf_args;
type internal (line 757) | typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
type typename (line 758) | typedef typename basic_printf_context_t<buffer>::type context;
function vfprintf (line 765) | int vfprintf(std::FILE *f, const S &format,
type internal (line 788) | typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
type typename (line 789) | typedef typename basic_printf_context_t<buffer>::type context;
function vprintf (line 796) | int vprintf(const S &format,
type internal (line 815) | typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
type typename (line 816) | typedef typename basic_printf_context_t<buffer>::type context;
function vfprintf (line 823) | int vfprintf(std::basic_ostream<Char> &os,
type internal (line 847) | typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
type typename (line 848) | typedef typename basic_printf_context_t<buffer>::type context;
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/ranges.h
function FMT_BEGIN_NAMESPACE (line 23) | FMT_BEGIN_NAMESPACE
type T (line 134) | typedef T value_type;
function FMT_CONSTEXPR (line 136) | static FMT_CONSTEXPR std::size_t size() {
type make_integer_sequence (line 145) | struct make_integer_sequence
FILE: extlibs/spdlog/include/spdlog/fmt/bundled/time.h
function namespace (line 21) | namespace internal{
function std (line 29) | inline std::tm localtime(std::time_t time) {
function std (line 67) | inline std::tm gmtime(std::time_t time) {
function namespace (line 103) | namespace internal {
FILE: extlibs/spdlog/include/spdlog/formatter.h
function namespace (line 9) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/logger-inl.h
function namespace (line 15) | namespace spdlog {
function SPDLOG_INLINE (line 150) | SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
function SPDLOG_INLINE (line 162) | SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_n...
FILE: extlibs/spdlog/include/spdlog/logger.h
function namespace (line 37) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/android_sink.h
function namespace (line 24) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h
function namespace (line 13) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/ansicolor_sink.h
function namespace (line 14) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/base_sink-inl.h
function SPDLOG_INLINE (line 26) | SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_ms...
function SPDLOG_INLINE (line 33) | SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush()
function SPDLOG_INLINE (line 40) | SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::st...
function SPDLOG_INLINE (line 47) | SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique...
function SPDLOG_INLINE (line 54) | SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::s...
function SPDLOG_INLINE (line 60) | SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::uniqu...
FILE: extlibs/spdlog/include/spdlog/sinks/base_sink.h
function namespace (line 16) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/basic_file_sink-inl.h
function namespace (line 13) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/basic_file_sink.h
function namespace (line 14) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/daily_file_sink.h
function namespace (line 19) | namespace spdlog {
function flush_ (line 85) | void flush_() override
FILE: extlibs/spdlog/include/spdlog/sinks/dist_sink.h
function namespace (line 19) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/dup_filter_sink.h
function namespace (line 40) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/msvc_sink.h
function namespace (line 16) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/null_sink.h
function namespace (line 12) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/ostream_sink.h
function namespace (line 12) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h
function namespace (line 23) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/rotating_file_sink.h
function namespace (line 15) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/sink.h
function namespace (line 9) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h
function namespace (line 13) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/stdout_color_sinks.h
function namespace (line 14) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/stdout_sinks-inl.h
function namespace (line 14) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/stdout_sinks.h
function namespace (line 11) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/syslog_sink.h
function namespace (line 13) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/systemd_sink.h
function namespace (line 12) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/wincolor_sink-inl.h
function namespace (line 13) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/sinks/wincolor_sink.h
function namespace (line 17) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/spdlog-inl.h
function namespace (line 13) | namespace spdlog {
FILE: extlibs/spdlog/include/spdlog/spdlog.h
function namespace (line 23) | namespace spdlog {
FILE: extlibs/spdlog/src/spdlog.cpp
class spdlog::sinks::base_sink<std::mutex> (line 25) | class spdlog::sinks::base_sink<std::mutex>
class spdlog::sinks::base_sink<spdlog::details::null_mutex> (line 26) | class spdlog::sinks::base_sink<spdlog::details::null_mutex>
class spdlog::sinks::basic_file_sink<std::mutex> (line 29) | class spdlog::sinks::basic_file_sink<std::mutex>
class spdlog::sinks::basic_file_sink<spdlog::details::null_mutex> (line 30) | class spdlog::sinks::basic_file_sink<spdlog::details::null_mutex>
class spdlog::sinks::rotating_file_sink<std::mutex> (line 33) | class spdlog::sinks::rotating_file_sink<std::mutex>
class spdlog::sinks::rotating_file_sink<spdlog::details::null_mutex> (line 34) | class spdlog::sinks::rotating_file_sink<spdlog::details::null_mutex>
class spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg> (line 44) | class spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>
class spdlog::sinks::wincolor_sink<spdlog::details::console_mutex> (line 51) | class spdlog::sinks::wincolor_sink<spdlog::details::console_mutex>
class spdlog::sinks::wincolor_sink<spdlog::details::console_nullmutex> (line 52) | class spdlog::sinks::wincolor_sink<spdlog::details::console_nullmutex>
class spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_mutex> (line 53) | class spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_mutex>
class spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_nullmutex> (line 54) | class spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_nullm...
class spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_mutex> (line 55) | class spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_mutex>
class spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_nullmutex> (line 56) | class spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_nullm...
class spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex> (line 59) | class spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>
class spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex> (line 60) | class spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>
class spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_mutex> (line 61) | class spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_mutex>
class spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex> (line 62) | class spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_null...
class spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_mutex> (line 63) | class spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_mutex>
class spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_nullmutex> (line 64) | class spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_null...
class spdlog::sinks::stdout_sink_base<spdlog::details::console_mutex> (line 85) | class spdlog::sinks::stdout_sink_base<spdlog::details::console_mutex>
class spdlog::sinks::stdout_sink_base<spdlog::details::console_nullmutex> (line 86) | class spdlog::sinks::stdout_sink_base<spdlog::details::console_nullmutex>
class spdlog::sinks::stdout_sink<spdlog::details::console_mutex> (line 87) | class spdlog::sinks::stdout_sink<spdlog::details::console_mutex>
class spdlog::sinks::stdout_sink<spdlog::details::console_nullmutex> (line 88) | class spdlog::sinks::stdout_sink<spdlog::details::console_nullmutex>
class spdlog::sinks::stderr_sink<spdlog::details::console_mutex> (line 89) | class spdlog::sinks::stderr_sink<spdlog::details::console_mutex>
class spdlog::sinks::stderr_sink<spdlog::details::console_nullmutex> (line 90) | class spdlog::sinks::stderr_sink<spdlog::details::console_nullmutex>
FILE: extlibs/squirrel/etc/minimal.c
function printfunc (line 21) | void printfunc(HSQUIRRELVM v,const SQChar *s,...)
function errorfunc (line 29) | void errorfunc(HSQUIRRELVM v,const SQChar *s,...)
function call_foo (line 37) | void call_foo(HSQUIRRELVM v, int n,float f,const SQChar *s)
function main (line 52) | int main(int argc, char* argv[])
FILE: extlibs/squirrel/include/sqconfig.h
type __int64 (line 5) | typedef __int64 SQInteger;
type SQUnsignedInteger (line 6) | typedef unsigned __int64 SQUnsignedInteger;
type SQHash (line 7) | typedef unsigned __int64 SQHash;
type SQInteger (line 9) | typedef long long SQInteger;
type SQUnsignedInteger (line 10) | typedef unsigned long long SQUnsignedInteger;
type SQHash (line 11) | typedef unsigned long long SQHash;
type SQInt32 (line 13) | typedef int SQInt32;
type SQUnsignedInteger32 (line 14) | typedef unsigned int SQUnsignedInteger32;
type SQInteger (line 16) | typedef int SQInteger;
type SQInt32 (line 17) | typedef int SQInt32;
type SQUnsignedInteger32 (line 18) | typedef unsigned int SQUnsignedInteger32;
type SQUnsignedInteger (line 19) | typedef unsigned int SQUnsignedInteger;
type SQHash (line 20) | typedef unsigned int SQHash;
type SQFloat (line 25) | typedef double SQFloat;
type SQFloat (line 27) | typedef float SQFloat;
type __int64 (line 32) | typedef __int64 SQRawObjectVal;
type SQRawObjectVal (line 34) | typedef long long SQRawObjectVal;
type SQUnsignedInteger (line 38) | typedef SQUnsignedInteger SQRawObjectVal;
type SQUnsignedInteger (line 51) | typedef SQUnsignedInteger SQBool;
type SQInteger (line 52) | typedef SQInteger SQRESULT;
type wchar_t (line 59) | typedef wchar_t SQChar;
type SQChar (line 105) | typedef char SQChar;
FILE: extlibs/squirrel/include/sqstdio.h
type SQStream (line 9) | struct SQStream {
FILE: extlibs/squirrel/include/sqstdstring.h
type SQRexBool (line 9) | typedef unsigned int SQRexBool;
type SQRex (line 10) | typedef struct SQRex SQRex;
type SQRexMatch (line 12) | typedef struct {
FILE: extlibs/squirrel/include/squirrel.h
type SQVM (line 47) | struct SQVM
type SQTable (line 48) | struct SQTable
type SQArray (line 49) | struct SQArray
type SQString (line 50) | struct SQString
type SQClosure (line 51) | struct SQClosure
type SQGenerator (line 52) | struct SQGenerator
type SQNativeClosure (line 53) | struct SQNativeClosure
type SQUserData (line 54) | struct SQUserData
type SQFunctionProto (line 55) | struct SQFunctionProto
type SQRefCounted (line 56) | struct SQRefCounted
type SQClass (line 57) | struct SQClass
type SQInstance (line 58) | struct SQInstance
type SQDelegable (line 59) | struct SQDelegable
type SQOuter (line 60) | struct SQOuter
type SQObjectType (line 109) | typedef enum tagSQObjectType{
type SQObjectValue (line 133) | typedef union tagSQObjectValue
type SQObject (line 157) | typedef struct tagSQObject
type SQMemberHandle (line 163) | typedef struct tagSQMemberHandle{
type SQStackInfos (line 168) | typedef struct tagSQStackInfos{
type SQVM (line 174) | struct SQVM
type SQObject (line 175) | typedef SQObject HSQOBJECT;
type SQMemberHandle (line 176) | typedef SQMemberHandle HSQMEMBERHANDLE;
type SQInteger (line 177) | typedef SQInteger (*SQFUNCTION)(HSQUIRRELVM);
type SQInteger (line 178) | typedef SQInteger (*SQRELEASEHOOK)(SQUserPointer,SQInteger size);
type SQInteger (line 182) | typedef SQInteger (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,SQInteger);
type SQInteger (line 183) | typedef SQInteger (*SQREADFUNC)(SQUserPointer,SQUserPointer,SQInteger);
type SQInteger (line 185) | typedef SQInteger (*SQLEXREADFUNC)(SQUserPointer);
type SQRegFunction (line 187) | typedef struct tagSQRegFunction{
type SQFunctionInfo (line 194) | typedef struct tagSQFunctionInfo {
FILE: extlibs/squirrel/sq/sq.c
function MemAllocHook (line 32) | int MemAllocHook( int allocType, void *userData, size_t size, int blockT...
function SQInteger (line 41) | SQInteger quit(HSQUIRRELVM v)
function printfunc (line 49) | void printfunc(HSQUIRRELVM SQ_UNUSED_ARG(v),const SQChar *s,...)
function errorfunc (line 57) | void errorfunc(HSQUIRRELVM SQ_UNUSED_ARG(v),const SQChar *s,...)
function PrintVersionInfos (line 65) | void PrintVersionInfos()
function PrintUsage (line 70) | void PrintUsage()
function getargs (line 86) | int getargs(HSQUIRRELVM v,int argc, char* argv[],SQInteger *retval)
function Interactive (line 224) | void Interactive(HSQUIRRELVM v)
function main (line 306) | int main(int argc, char* argv[])
FILE: extlibs/squirrel/sqstdlib/sqstdaux.cpp
function sqstd_printcallstack (line 6) | void sqstd_printcallstack(HSQUIRRELVM v)
function SQInteger (line 99) | static SQInteger _sqstd_aux_printerror(HSQUIRRELVM v)
function _sqstd_compiler_error (line 117) | void _sqstd_compiler_error(HSQUIRRELVM v,const SQChar *sErr,const SQChar...
function sqstd_seterrorhandlers (line 125) | void sqstd_seterrorhandlers(HSQUIRRELVM v)
FILE: extlibs/squirrel/sqstdlib/sqstdblob.cpp
function SQInteger (line 23) | static SQInteger _blob_resize(HSQUIRRELVM v)
function __swap_dword (line 33) | static void __swap_dword(unsigned int *n)
function __swap_word (line 41) | static void __swap_word(unsigned short *n)
function SQInteger (line 46) | static SQInteger _blob_swap4(HSQUIRRELVM v)
function SQInteger (line 57) | static SQInteger _blob_swap2(HSQUIRRELVM v)
function SQInteger (line 68) | static SQInteger _blob__set(HSQUIRRELVM v)
function SQInteger (line 81) | static SQInteger _blob__get(HSQUIRRELVM v)
function SQInteger (line 98) | static SQInteger _blob__nexti(HSQUIRRELVM v)
function SQInteger (line 117) | static SQInteger _blob__typeof(HSQUIRRELVM v)
function SQInteger (line 123) | static SQInteger _blob_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_...
function SQInteger (line 131) | static SQInteger _blob_constructor(HSQUIRRELVM v)
function SQInteger (line 151) | static SQInteger _blob__cloned(HSQUIRRELVM v)
function SQInteger (line 188) | static SQInteger _g_blob_casti2f(HSQUIRRELVM v)
function SQInteger (line 196) | static SQInteger _g_blob_castf2i(HSQUIRRELVM v)
function SQInteger (line 204) | static SQInteger _g_blob_swap2(HSQUIRRELVM v)
function SQInteger (line 213) | static SQInteger _g_blob_swap4(HSQUIRRELVM v)
function SQInteger (line 223) | static SQInteger _g_blob_swapfloat(HSQUIRRELVM v)
function SQRESULT (line 242) | SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr)
function SQInteger (line 251) | SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx)
function SQUserPointer (line 259) | SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size)
function SQRESULT (line 279) | SQRESULT sqstd_register_bloblib(HSQUIRRELVM v)
FILE: extlibs/squirrel/sqstdlib/sqstdblobimpl.h
function SQStream (line 5) | struct SQBlob : public SQStream
function virtual (line 15) | virtual ~SQBlob() {
function SQInteger (line 18) | SQInteger Write(void *buffer, SQInteger size) {
function SQInteger (line 26) | SQInteger Read(void *buffer,SQInteger size) {
function Resize (line 37) | bool Resize(SQInteger n) {
function GrowBufOf (line 56) | bool GrowBufOf(SQInteger n)
function CanAdvance (line 68) | bool CanAdvance(SQInteger n) {
function SQInteger (line 72) | SQInteger Seek(SQInteger offset, SQInteger origin) {
function IsValid (line 90) | bool IsValid() {
function EOS (line 93) | bool EOS() {
function SQInteger (line 96) | SQInteger Flush() { return 0; }
function SQInteger (line 97) | SQInteger Tell() { return _ptr; }
function SQInteger (line 98) | SQInteger Len() { return _size; }
function SQUserPointer (line 99) | SQUserPointer GetBuf(){ return _buf; }
FILE: extlibs/squirrel/sqstdlib/sqstdio.cpp
function SQFILE (line 10) | SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode)
function SQInteger (line 19) | SQInteger sqstd_fread(void* buffer, SQInteger size, SQInteger count, SQF...
function SQInteger (line 25) | SQInteger sqstd_fwrite(const SQUserPointer buffer, SQInteger size, SQInt...
function SQInteger (line 30) | SQInteger sqstd_fseek(SQFILE file, SQInteger offset, SQInteger origin)
function SQInteger (line 42) | SQInteger sqstd_ftell(SQFILE file)
function SQInteger (line 47) | SQInteger sqstd_fflush(SQFILE file)
function SQInteger (line 52) | SQInteger sqstd_fclose(SQFILE file)
function SQInteger (line 57) | SQInteger sqstd_feof(SQFILE file)
type SQFile (line 63) | struct SQFile : public SQStream {
method SQFile (line 64) | SQFile() { _handle = NULL; _owns = false;}
method SQFile (line 65) | SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;}
method Open (line 67) | bool Open(const SQChar *filename ,const SQChar *mode) {
method Close (line 75) | void Close() {
method SQInteger (line 82) | SQInteger Read(void *buffer,SQInteger size) {
method SQInteger (line 85) | SQInteger Write(void *buffer,SQInteger size) {
method SQInteger (line 88) | SQInteger Flush() {
method SQInteger (line 91) | SQInteger Tell() {
method SQInteger (line 94) | SQInteger Len() {
method SQInteger (line 101) | SQInteger Seek(SQInteger offset, SQInteger origin) {
method IsValid (line 104) | bool IsValid() { return _handle?true:false; }
method EOS (line 105) | bool EOS() { return Tell()==Len()?true:false;}
method SQFILE (line 106) | SQFILE GetHandle() {return _handle;}
function SQInteger (line 112) | static SQInteger _file__typeof(HSQUIRRELVM v)
function SQInteger (line 118) | static SQInteger _file_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_...
function SQInteger (line 126) | static SQInteger _file_constructor(HSQUIRRELVM v)
function SQInteger (line 154) | static SQInteger _file_close(HSQUIRRELVM v)
function SQRESULT (line 176) | SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own)
function SQRESULT (line 200) | SQRESULT sqstd_getfile(HSQUIRRELVM v, SQInteger idx, SQFILE *file)
type IOBuffer (line 213) | struct IOBuffer {
function SQInteger (line 220) | SQInteger _read_byte(IOBuffer *iobuffer)
function SQInteger (line 240) | SQInteger _read_two_bytes(IOBuffer *iobuffer)
function SQInteger (line 261) | static SQInteger _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
function SQInteger (line 269) | static SQInteger _io_file_lexfeed_UTF8(SQUserPointer iobuf)
function SQInteger (line 308) | static SQInteger _io_file_lexfeed_UCS2_LE(SQUserPointer iobuf)
function SQInteger (line 317) | static SQInteger _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf)
function SQInteger (line 328) | SQInteger file_read(SQUserPointer file,SQUserPointer buf,SQInteger size)
function SQInteger (line 335) | SQInteger file_write(SQUserPointer file,SQUserPointer p,SQInteger size)
function SQRESULT (line 340) | SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool prin...
function SQRESULT (line 400) | SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval...
function SQRESULT (line 417) | SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename)
function SQInteger (line 429) | SQInteger _g_io_loadfile(HSQUIRRELVM v)
function SQInteger (line 442) | SQInteger _g_io_writeclosuretofile(HSQUIRRELVM v)
function SQInteger (line 451) | SQInteger _g_io_dofile(HSQUIRRELVM v)
function SQRESULT (line 473) | SQRESULT sqstd_register_iolib(HSQUIRRELVM v)
FILE: extlibs/squirrel/sqstdlib/sqstdmath.cpp
function SQInteger (line 22) | static SQInteger math_srand(HSQUIRRELVM v)
function SQInteger (line 31) | static SQInteger math_rand(HSQUIRRELVM v)
function SQInteger (line 37) | static SQInteger math_abs(HSQUIRRELVM v)
function SQRESULT (line 89) | SQRESULT sqstd_register_mathlib(HSQUIRRELVM v)
FILE: extlibs/squirrel/sqstdlib/sqstdrex.cpp
type tagSQRexNode (line 48) | struct tagSQRexNode{
type SQRex (line 55) | struct SQRex{
function SQInteger (line 73) | static SQInteger sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
function sqstd_rex_error (line 90) | static void sqstd_rex_error(SQRex *exp,const SQChar *error)
function sqstd_rex_expect (line 96) | static void sqstd_rex_expect(SQRex *exp, SQInteger n){
function SQChar (line 102) | static SQChar sqstd_rex_escapechar(SQRex *exp)
function SQInteger (line 118) | static SQInteger sqstd_rex_charclass(SQRex *exp,SQInteger classid)
function SQInteger (line 125) | static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
function SQInteger (line 179) | static SQInteger sqstd_rex_class(SQRex *exp)
function SQInteger (line 226) | static SQInteger sqstd_rex_parsenumber(SQRex *exp)
function SQInteger (line 239) | static SQInteger sqstd_rex_element(SQRex *exp)
function SQInteger (line 321) | static SQInteger sqstd_rex_list(SQRex *exp)
function SQBool (line 346) | static SQBool sqstd_rex_matchcclass(SQInteger cclass,SQChar c)
function SQBool (line 369) | static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c)
function SQChar (line 386) | static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,cons...
function SQRex (line 554) | SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
function sqstd_rex_free (line 599) | void sqstd_rex_free(SQRex *exp)
function SQBool (line 609) | SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
function SQBool (line 621) | SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const S...
function SQBool (line 650) | SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** ou...
function SQInteger (line 655) | SQInteger sqstd_rex_getsubexpcount(SQRex* exp)
function SQBool (line 660) | SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp)
FILE: extlibs/squirrel/sqstdlib/sqstdstream.cpp
function SQInteger (line 19) | SQInteger _stream_readblob(HSQUIRRELVM v)
function SQInteger (line 40) | SQInteger _stream_readn(HSQUIRRELVM v)
function SQInteger (line 100) | SQInteger _stream_writeblob(HSQUIRRELVM v)
function SQInteger (line 114) | SQInteger _stream_writen(HSQUIRRELVM v)
function SQInteger (line 183) | SQInteger _stream_seek(HSQUIRRELVM v)
function SQInteger (line 202) | SQInteger _stream_tell(HSQUIRRELVM v)
function SQInteger (line 209) | SQInteger _stream_len(HSQUIRRELVM v)
function SQInteger (line 216) | SQInteger _stream_flush(HSQUIRRELVM v)
function SQInteger (line 226) | SQInteger _stream_eos(HSQUIRRELVM v)
function SQInteger (line 236) | SQInteger _stream__cloned(HSQUIRRELVM v)
function init_streamclass (line 255) | void init_streamclass(HSQUIRRELVM v)
function SQRESULT (line 286) | SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer t...
FILE: extlibs/squirrel/sqstdlib/sqstdstring.cpp
function SQBool (line 14) | static SQBool isfmtchr(SQChar ch)
function SQInteger (line 22) | static SQInteger validate_format(HSQUIRRELVM v, SQChar *fmt, const SQCha...
function SQRESULT (line 67) | SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger...
function SQInteger (line 156) | static SQInteger _string_printf(HSQUIRRELVM v)
function SQInteger (line 169) | static SQInteger _string_format(HSQUIRRELVM v)
function __strip_l (line 179) | static void __strip_l(const SQChar *str,const SQChar **start)
function __strip_r (line 186) | static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end)
function SQInteger (line 197) | static SQInteger _string_strip(HSQUIRRELVM v)
function SQInteger (line 208) | static SQInteger _string_lstrip(HSQUIRRELVM v)
function SQInteger (line 217) | static SQInteger _string_rstrip(HSQUIRRELVM v)
function SQInteger (line 227) | static SQInteger _string_split(HSQUIRRELVM v)
function SQInteger (line 265) | static SQInteger _string_escape(HSQUIRRELVM v)
function SQInteger (line 335) | static SQInteger _string_startswith(HSQUIRRELVM v)
function SQInteger (line 350) | static SQInteger _string_endswith(HSQUIRRELVM v)
function SQInteger (line 369) | static SQInteger _rexobj_releasehook(SQUserPointer p, SQInteger SQ_UNUSE...
function SQInteger (line 376) | static SQInteger _regexp_match(HSQUIRRELVM v)
function _addrexmatch (line 390) | static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *b...
function SQInteger (line 401) | static SQInteger _regexp_search(HSQUIRRELVM v)
function SQInteger (line 415) | static SQInteger _regexp_capture(HSQUIRRELVM v)
function SQInteger (line 439) | static SQInteger _regexp_subexpcount(HSQUIRRELVM v)
function SQInteger (line 446) | static SQInteger _regexp_constructor(HSQUIRRELVM v)
function SQInteger (line 457) | static SQInteger _regexp__typeof(HSQUIRRELVM v)
function SQInteger (line 491) | SQInteger sqstd_register_stringlib(HSQUIRRELVM v)
FILE: extlibs/squirrel/sqstdlib/sqstdsystem.cpp
function SQInteger (line 23) | static SQInteger _system_getenv(HSQUIRRELVM v)
function SQInteger (line 34) | static SQInteger _system_system(HSQUIRRELVM v)
function SQInteger (line 45) | static SQInteger _system_clock(HSQUIRRELVM v)
function SQInteger (line 51) | static SQInteger _system_time(HSQUIRRELVM v)
function SQInteger (line 58) | static SQInteger _system_remove(HSQUIRRELVM v)
function SQInteger (line 67) | static SQInteger _system_rename(HSQUIRRELVM v)
function _set_integer_slot (line 77) | static void _set_integer_slot(HSQUIRRELVM v,const SQChar *name,SQInteger...
function SQInteger (line 84) | static SQInteger _system_date(HSQUIRRELVM v)
function SQInteger (line 133) | SQInteger sqstd_register_systemlib(HSQUIRRELVM v)
FILE: extlibs/squirrel/squirrel/sqapi.cpp
function sq_aux_gettypedarg (line 16) | static bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType ...
function SQInteger (line 35) | SQInteger sq_aux_invalidtype(HSQUIRRELVM v,SQObjectType type)
function HSQUIRRELVM (line 42) | HSQUIRRELVM sq_open(SQInteger initialstacksize)
function HSQUIRRELVM (line 60) | HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize)
function SQInteger (line 78) | SQInteger sq_getvmstate(HSQUIRRELVM v)
function sq_seterrorhandler (line 88) | void sq_seterrorhandler(HSQUIRRELVM v)
function sq_setnativedebughook (line 97) | void sq_setnativedebughook(HSQUIRRELVM v,SQDEBUGHOOK hook)
function sq_setdebughook (line 104) | void sq_setdebughook(HSQUIRRELVM v)
function sq_close (line 115) | void sq_close(HSQUIRRELVM v)
function SQInteger (line 122) | SQInteger sq_getversion()
function SQRESULT (line 127) | SQRESULT sq_compile(HSQUIRRELVM v,SQLEXREADFUNC read,SQUserPointer p,con...
function sq_enabledebuginfo (line 141) | void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable)
function sq_notifyallexceptions (line 146) | void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable)
function sq_addref (line 151) | void sq_addref(HSQUIRRELVM v,HSQOBJECT *po)
function SQUnsignedInteger (line 161) | SQUnsignedInteger sq_getrefcount(HSQUIRRELVM v,HSQOBJECT *po)
function SQBool (line 171) | SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po)
function SQUnsignedInteger (line 183) | SQUnsignedInteger sq_getvmrefcount(HSQUIRRELVM SQ_UNUSED_ARG(v), const H...
function SQChar (line 189) | const SQChar *sq_objtostring(const HSQOBJECT *o)
function SQInteger (line 197) | SQInteger sq_objtointeger(const HSQOBJECT *o)
function SQFloat (line 205) | SQFloat sq_objtofloat(const HSQOBJECT *o)
function SQBool (line 213) | SQBool sq_objtobool(const HSQOBJECT *o)
function SQUserPointer (line 221) | SQUserPointer sq_objtouserpointer(const HSQOBJECT *o)
function sq_pushnull (line 229) | void sq_pushnull(HSQUIRRELVM v)
function sq_pushstring (line 234) | void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len)
function sq_pushinteger (line 241) | void sq_pushinteger(HSQUIRRELVM v,SQInteger n)
function sq_pushbool (line 246) | void sq_pushbool(HSQUIRRELVM v,SQBool b)
function sq_pushfloat (line 251) | void sq_pushfloat(HSQUIRRELVM v,SQFloat n)
function sq_pushuserpointer (line 256) | void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p)
function sq_pushthread (line 261) | void sq_pushthread(HSQUIRRELVM v, HSQUIRRELVM thread)
function SQUserPointer (line 266) | SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size)
function sq_newtable (line 273) | void sq_newtable(HSQUIRRELVM v)
function sq_newtableex (line 278) | void sq_newtableex(HSQUIRRELVM v,SQInteger initialcapacity)
function sq_newarray (line 283) | void sq_newarray(HSQUIRRELVM v,SQInteger size)
function SQRESULT (line 288) | SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase)
function SQBool (line 303) | SQBool sq_instanceof(HSQUIRRELVM v)
function SQRESULT (line 312) | SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 322) | SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
function SQRESULT (line 335) | SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize)
function SQRESULT (line 348) | SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 368) | SQRESULT sq_arrayremove(HSQUIRRELVM v,SQInteger idx,SQInteger itemidx)
function SQRESULT (line 376) | SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos)
function sq_newclosure (line 386) | void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfree...
function SQRESULT (line 397) | SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQInteger *nparam...
function SQRESULT (line 417) | SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQCha...
function SQRESULT (line 428) | SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQ...
function SQRESULT (line 450) | SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 487) | SQRESULT sq_getclosurename(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 503) | SQRESULT sq_setclosureroot(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 516) | SQRESULT sq_getclosureroot(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 524) | SQRESULT sq_clear(HSQUIRRELVM v,SQInteger idx)
function sq_pushroottable (line 538) | void sq_pushroottable(HSQUIRRELVM v)
function sq_pushregistrytable (line 543) | void sq_pushregistrytable(HSQUIRRELVM v)
function sq_pushconsttable (line 548) | void sq_pushconsttable(HSQUIRRELVM v)
function SQRESULT (line 553) | SQRESULT sq_setroottable(HSQUIRRELVM v)
function SQRESULT (line 564) | SQRESULT sq_setconsttable(HSQUIRRELVM v)
function sq_setforeignptr (line 575) | void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p)
function SQUserPointer (line 580) | SQUserPointer sq_getforeignptr(HSQUIRRELVM v)
function sq_setsharedforeignptr (line 585) | void sq_setsharedforeignptr(HSQUIRRELVM v,SQUserPointer p)
function SQUserPointer (line 590) | SQUserPointer sq_getsharedforeignptr(HSQUIRRELVM v)
function sq_setvmreleasehook (line 595) | void sq_setvmreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook)
function SQRELEASEHOOK (line 600) | SQRELEASEHOOK sq_getvmreleasehook(HSQUIRRELVM v)
function sq_setsharedreleasehook (line 605) | void sq_setsharedreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook)
function SQRELEASEHOOK (line 610) | SQRELEASEHOOK sq_getsharedreleasehook(HSQUIRRELVM v)
function sq_push (line 615) | void sq_push(HSQUIRRELVM v,SQInteger idx)
function SQObjectType (line 620) | SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 625) | SQRESULT sq_typeof(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 636) | SQRESULT sq_tostring(HSQUIRRELVM v,SQInteger idx)
function sq_tobool (line 647) | void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b)
function SQRESULT (line 653) | SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i)
function SQRESULT (line 671) | SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f)
function SQRESULT (line 681) | SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b)
function SQRESULT (line 691) | SQRESULT sq_getstringandsize(HSQUIRRELVM v,SQInteger idx,const SQChar **...
function SQRESULT (line 700) | SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c)
function SQRESULT (line 708) | SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread)
function SQRESULT (line 716) | SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx)
function SQInteger (line 727) | SQInteger sq_getsize(HSQUIRRELVM v, SQInteger idx)
function SQHash (line 743) | SQHash sq_gethash(HSQUIRRELVM v, SQInteger idx)
function SQRESULT (line 749) | SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQU...
function SQRESULT (line 758) | SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag)
function SQRESULT (line 769) | SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag)
function SQRESULT (line 780) | SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag)
function SQRESULT (line 788) | SQRESULT sq_getuserpointer(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p)
function SQRESULT (line 796) | SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p)
function SQRESULT (line 804) | SQRESULT sq_setclassudsize(HSQUIRRELVM v, SQInteger idx, SQInteger udsize)
function SQRESULT (line 814) | SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p...
function SQInteger (line 831) | SQInteger sq_gettop(HSQUIRRELVM v)
function sq_settop (line 836) | void sq_settop(HSQUIRRELVM v, SQInteger newtop)
function sq_pop (line 845) | void sq_pop(HSQUIRRELVM v, SQInteger nelemstopop)
function sq_poptop (line 851) | void sq_poptop(HSQUIRRELVM v)
function sq_remove (line 858) | void sq_remove(HSQUIRRELVM v, SQInteger idx)
function SQInteger (line 863) | SQInteger sq_cmp(HSQUIRRELVM v)
function SQRESULT (line 870) | SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic)
function SQRESULT (line 883) | SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
function SQRESULT (line 900) | SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 910) | SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 948) | SQRESULT sq_newmember(HSQUIRRELVM v,SQInteger idx,SQBool bstatic)
function SQRESULT (line 962) | SQRESULT sq_rawnewmember(HSQUIRRELVM v,SQInteger idx,SQBool bstatic)
function SQRESULT (line 976) | SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1007) | SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
function SQRESULT (line 1024) | SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1042) | SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1052) | SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1089) | SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po)
function SQChar (line 1095) | const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsign...
function sq_pushobject (line 1120) | void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj)
function sq_resetobject (line 1125) | void sq_resetobject(HSQOBJECT *po)
function SQRESULT (line 1130) | SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err)
function SQRESULT (line 1136) | SQRESULT sq_throwobject(HSQUIRRELVM v)
function sq_reseterror (line 1144) | void sq_reseterror(HSQUIRRELVM v)
function sq_getlasterror (line 1149) | void sq_getlasterror(HSQUIRRELVM v)
function SQRESULT (line 1154) | SQRESULT sq_reservestack(HSQUIRRELVM v,SQInteger nsize)
function SQRESULT (line 1165) | SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror)
function SQRESULT (line 1179) | SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool rai...
function SQRESULT (line 1193) | SQRESULT sq_tailcall(HSQUIRRELVM v, SQInteger nparams)
function SQRESULT (line 1212) | SQRESULT sq_suspendvm(HSQUIRRELVM v)
function SQRESULT (line 1217) | SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool wakeupret,SQBool retval,SQBool...
function sq_setreleasehook (line 1238) | void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook)
function SQRELEASEHOOK (line 1249) | SQRELEASEHOOK sq_getreleasehook(HSQUIRRELVM v,SQInteger idx)
function sq_setcompilererrorhandler (line 1260) | void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f)
function SQRESULT (line 1265) | SQRESULT sq_writeclosure(HSQUIRRELVM v,SQWRITEFUNC w,SQUserPointer up)
function SQRESULT (line 1279) | SQRESULT sq_readclosure(HSQUIRRELVM v,SQREADFUNC r,SQUserPointer up)
function SQChar (line 1294) | SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize)
function SQRESULT (line 1299) | SQRESULT sq_resurrectunreachable(HSQUIRRELVM v)
function SQInteger (line 1309) | SQInteger sq_collectgarbage(HSQUIRRELVM v)
function SQRESULT (line 1318) | SQRESULT sq_getcallee(HSQUIRRELVM v)
function SQChar (line 1328) | const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedI...
function SQRESULT (line 1357) | SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedIntege...
function SQRESULT (line 1383) | SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1405) | SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1425) | SQRESULT sq_getmemberhandle(HSQUIRRELVM v,SQInteger idx,HSQMEMBERHANDLE ...
function SQRESULT (line 1441) | SQRESULT _getmemberbyhandle(HSQUIRRELVM v,SQObjectPtr &self,const HSQMEM...
function SQRESULT (line 1472) | SQRESULT sq_getbyhandle(HSQUIRRELVM v,SQInteger idx,const HSQMEMBERHANDL...
function SQRESULT (line 1483) | SQRESULT sq_setbyhandle(HSQUIRRELVM v,SQInteger idx,const HSQMEMBERHANDL...
function SQRESULT (line 1496) | SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1507) | SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1515) | SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx)
function sq_weakref (line 1523) | void sq_weakref(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1533) | SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx)
function SQRESULT (line 1543) | SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t)
function SQRESULT (line 1562) | SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx)
type BufState (line 1579) | struct BufState{
function SQInteger (line 1585) | SQInteger buf_lexfeed(SQUserPointer file)
function SQRESULT (line 1593) | SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,c...
function sq_move (line 1601) | void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx)
function sq_setprintfunc (line 1606) | void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc,SQPRINTFUN...
function SQPRINTFUNCTION (line 1612) | SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v)
function SQPRINTFUNCTION (line 1617) | SQPRINTFUNCTION sq_geterrorfunc(HSQUIRRELVM v)
function sq_free (line 1632) | void sq_free(void *p,SQUnsignedInteger size)
FILE: extlibs/squirrel/squirrel/sqarray.h
function CHAINABLE_OBJ (line 5) | struct SQArray : public CHAINABLE_OBJ
FILE: extlibs/squirrel/squirrel/sqbaselib.cpp
function str2num (line 16) | static bool str2num(const SQChar *s,SQObjectPtr &res,SQInteger base)
function SQInteger (line 44) | static SQInteger base_dummy(HSQUIRRELVM SQ_UNUSED_ARG(v))
function SQInteger (line 50) | static SQInteger base_collectgarbage(HSQUIRRELVM v)
function SQInteger (line 55) | static SQInteger base_resurectureachable(HSQUIRRELVM v)
function SQInteger (line 62) | static SQInteger base_getroottable(HSQUIRRELVM v)
function SQInteger (line 68) | static SQInteger base_getconsttable(HSQUIRRELVM v)
function SQInteger (line 75) | static SQInteger base_setroottable(HSQUIRRELVM v)
function SQInteger (line 83) | static SQInteger base_setconsttable(HSQUIRRELVM v)
function SQInteger (line 91) | static SQInteger base_seterrorhandler(HSQUIRRELVM v)
function SQInteger (line 97) | static SQInteger base_setdebughook(HSQUIRRELVM v)
function SQInteger (line 103) | static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
function SQInteger (line 111) | static SQInteger __getcallstackinfos(HSQUIRRELVM v,SQInteger level)
function SQInteger (line 149) | static SQInteger base_getstackinfos(HSQUIRRELVM v)
function SQInteger (line 156) | static SQInteger base_assert(HSQUIRRELVM v)
function SQInteger (line 171) | static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQIntege...
function SQInteger (line 195) | static SQInteger base_print(HSQUIRRELVM v)
function SQInteger (line 208) | static SQInteger base_error(HSQUIRRELVM v)
function SQInteger (line 221) | static SQInteger base_compilestring(HSQUIRRELVM v)
function SQInteger (line 237) | static SQInteger base_newthread(HSQUIRRELVM v)
function SQInteger (line 246) | static SQInteger base_suspend(HSQUIRRELVM v)
function SQInteger (line 251) | static SQInteger base_array(HSQUIRRELVM v)
function SQInteger (line 266) | static SQInteger base_type(HSQUIRRELVM v)
function SQInteger (line 273) | static SQInteger base_callee(HSQUIRRELVM v)
function sq_base_register (line 310) | void sq_base_register(HSQUIRRELVM v)
function SQInteger (line 341) | static SQInteger default_delegate_len(HSQUIRRELVM v)
function SQInteger (line 347) | static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
function SQInteger (line 372) | static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
function SQInteger (line 401) | static SQInteger default_delegate_tostring(HSQUIRRELVM v)
function SQInteger (line 408) | static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
function SQInteger (line 414) | static SQInteger obj_clear(HSQUIRRELVM v)
function SQInteger (line 420) | static SQInteger number_delegate_tochar(HSQUIRRELVM v)
function SQInteger (line 433) | static SQInteger table_rawdelete(HSQUIRRELVM v)
function SQInteger (line 441) | static SQInteger container_rawexists(HSQUIRRELVM v)
function SQInteger (line 451) | static SQInteger container_rawset(HSQUIRRELVM v)
function SQInteger (line 456) | static SQInteger container_rawsafeget(HSQUIRRELVM v)
function SQInteger (line 466) | static SQInteger container_rawget(HSQUIRRELVM v)
function SQInteger (line 471) | static SQInteger table_setdelegate(HSQUIRRELVM v)
function SQInteger (line 479) | static SQInteger table_getdelegate(HSQUIRRELVM v)
function SQInteger (line 484) | static SQInteger table_filter(HSQUIRRELVM v)
function SQInteger (line 530) | static SQInteger array_append(HSQUIRRELVM v)
function SQInteger (line 535) | static SQInteger array_extend(HSQUIRRELVM v)
function SQInteger (line 542) | static SQInteger array_reverse(HSQUIRRELVM v)
function SQInteger (line 547) | static SQInteger array_pop(HSQUIRRELVM v)
function SQInteger (line 552) | static SQInteger array_top(HSQUIRRELVM v)
function SQInteger (line 562) | static SQInteger array_insert(HSQUIRRELVM v)
function SQInteger (line 573) | static SQInteger array_remove(HSQUIRRELVM v)
function SQInteger (line 587) | static SQInteger array_resize(HSQUIRRELVM v)
function SQInteger (line 606) | static SQInteger __map_array(SQArray *dest,SQArray *src,HSQUIRRELVM v) {
function SQInteger (line 642) | static SQInteger array_map(HSQUIRRELVM v)
function SQInteger (line 653) | static SQInteger array_apply(HSQUIRRELVM v)
function SQInteger (line 662) | static SQInteger array_reduce(HSQUIRRELVM v)
function SQInteger (line 698) | static SQInteger array_filter(HSQUIRRELVM v)
function SQInteger (line 722) | static SQInteger array_find(HSQUIRRELVM v)
function _sort_compare (line 741) | static bool _sort_compare(HSQUIRRELVM v,SQObjectPtr &a,SQObjectPtr &b,SQ...
function _hsort_sift_down (line 767) | static bool _hsort_sift_down(HSQUIRRELVM v,SQArray *arr, SQInteger root,...
function _hsort (line 807) | static bool _hsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger SQ_UNUSED_A...
function SQInteger (line 824) | static SQInteger array_sort(HSQUIRRELVM v)
function SQInteger (line 838) | static SQInteger array_slice(HSQUIRRELVM v)
function SQInteger (line 885) | static SQInteger string_slice(HSQUIRRELVM v)
function SQInteger (line 899) | static SQInteger string_find(HSQUIRRELVM v)
function SQInteger (line 964) | static SQInteger closure_pcall(HSQUIRRELVM v)
function SQInteger (line 969) | static SQInteger closure_call(HSQUIRRELVM v)
function SQInteger (line 979) | static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
function SQInteger (line 988) | static SQInteger closure_acall(HSQUIRRELVM v)
function SQInteger (line 993) | static SQInteger closure_pacall(HSQUIRRELVM v)
function SQInteger (line 998) | static SQInteger closure_bindenv(HSQUIRRELVM v)
function SQInteger (line 1005) | static SQInteger closure_getroot(HSQUIRRELVM v)
function SQInteger (line 1012) | static SQInteger closure_setroot(HSQUIRRELVM v)
function SQInteger (line 1019) | static SQInteger closure_getinfos(HSQUIRRELVM v) {
function SQInteger (line 1079) | static SQInteger generator_getstatus(HSQUIRRELVM v)
function SQInteger (line 1098) | static SQInteger thread_call(HSQUIRRELVM v)
function SQInteger (line 1117) | static SQInteger thread_wakeup(HSQUIRRELVM v)
function SQInteger (line 1153) | static SQInteger thread_wakeupthrow(HSQUIRRELVM v)
function SQInteger (line 1194) | static SQInteger thread_getstatus(HSQUIRRELVM v)
function SQInteger (line 1213) | static SQInteger thread_getstackinfos(HSQUIRRELVM v)
function SQInteger (line 1257) | static SQInteger class_getattributes(HSQUIRRELVM v)
function SQInteger (line 1262) | static SQInteger class_setattributes(HSQUIRRELVM v)
function SQInteger (line 1267) | static SQInteger class_instance(HSQUIRRELVM v)
function SQInteger (line 1272) | static SQInteger class_getbase(HSQUIRRELVM v)
function SQInteger (line 1277) | static SQInteger class_newmember(HSQUIRRELVM v)
function SQInteger (line 1293) | static SQInteger class_rawnewmember(HSQUIRRELVM v)
function SQInteger (line 1325) | static SQInteger instance_getclass(HSQUIRRELVM v)
function SQInteger (line 1342) | static SQInteger weakref_ref(HSQUIRRELVM v)
FILE: extlibs/squirrel/squirrel/sqclass.cpp
function SQInstance (line 101) | SQInstance *SQClass::CreateInstance()
function SQInteger (line 107) | SQInteger SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, ...
FILE: extlibs/squirrel/squirrel/sqclass.h
type SQInstance (line 5) | struct SQInstance
type SQClassMember (line 7) | struct SQClassMember {
type sqvector (line 16) | typedef sqvector<SQClassMember> SQClassMemberVec;
function CHAINABLE_OBJ (line 28) | struct SQClass : public CHAINABLE_OBJ
function SQDelegable (line 90) | struct SQInstance : public SQDelegable
FILE: extlibs/squirrel/squirrel/sqclosure.h
type SQFunctionProto (line 8) | struct SQFunctionProto
type SQClass (line 9) | struct SQClass
function CHAINABLE_OBJ (line 10) | struct SQClosure : public CHAINABLE_OBJ
function Release (line 27) | void Release(){
function SetRoot (line 36) | void SetRoot(SQWeakRef *r)
function SQClosure (line 42) | SQClosure *Clone()
function Finalize (line 58) | void Finalize(){
function SQObjectType (line 63) | SQObjectType GetType() {return OT_CLOSURE;}
function CHAINABLE_OBJ (line 74) | struct SQOuter : public CHAINABLE_OBJ
function CHAINABLE_OBJ (line 108) | struct SQGenerator : public CHAINABLE_OBJ
function CHAINABLE_OBJ (line 147) | struct SQNativeClosure : public CHAINABLE_OBJ
function SQNativeClosure (line 162) | SQNativeClosure *Clone()
function Release (line 178) | void Release(){
function Finalize (line 187) | void Finalize() { _NULL_SQOBJECT_VECTOR(_outervalues,_noutervalues); }
function SQObjectType (line 188) | SQObjectType GetType() {return OT_NATIVECLOSURE;}
FILE: extlibs/squirrel/squirrel/sqcompiler.cpp
type SQExpState (line 23) | struct SQExpState {
type SQScope (line 31) | struct SQScope {
class SQCompiler (line 72) | class SQCompiler
method SQCompiler (line 75) | SQCompiler(SQVM *v, SQLEXREADFUNC rg, SQUserPointer up, const SQChar* ...
method ThrowError (line 85) | static void ThrowError(void *ud, const SQChar *s) {
method Error (line 89) | void Error(const SQChar *s, ...)
method Lex (line 97) | void Lex(){ _token = _lex.Lex();}
method SQObject (line 98) | SQObject Expect(SQInteger tok)
method IsEndOfStatement (line 149) | bool IsEndOfStatement() { return ((_lex._prevtoken == _SC('\n')) || (_...
method OptionalSemicolon (line 150) | void OptionalSemicolon()
method MoveIfCurrentTargetIsLocal (line 154) | void MoveIfCurrentTargetIsLocal() {
method Compile (line 161) | bool Compile(SQObjectPtr &o)
method Statements (line 199) | void Statements()
method Statement (line 206) | void Statement(bool closeframe = true)
method EmitDerefOp (line 315) | void EmitDerefOp(SQOpcode op)
method Emit2ArgsOP (line 322) | void Emit2ArgsOP(SQOpcode op, SQInteger p3 = 0)
method EmitCompoundArith (line 328) | void EmitCompoundArith(SQInteger tok, SQInteger etype, SQInteger pos)
method CommaExpr (line 364) | void CommaExpr()
method Expression (line 368) | void Expression()
method INVOKE_EXP (line 451) | void INVOKE_EXP(T f)
method BIN_EXP (line 460) | void BIN_EXP(SQOpcode op, T f,SQInteger op3 = 0)
method LogicalOrExp (line 468) | void LogicalOrExp()
method LogicalAndExp (line 487) | void LogicalAndExp()
method BitwiseOrExp (line 511) | void BitwiseOrExp()
method BitwiseXorExp (line 518) | void BitwiseXorExp()
method BitwiseAndExp (line 525) | void BitwiseAndExp()
method EqExp (line 532) | void EqExp()
method CompExp (line 542) | void CompExp()
method ShiftExp (line 555) | void ShiftExp()
method SQOpcode (line 565) | SQOpcode ChooseArithOpByToken(SQInteger tok)
method SQInteger (line 577) | SQInteger ChooseCompArithCharByToken(SQInteger tok)
method PlusExp (line 591) | void PlusExp()
method MultExp (line 601) | void MultExp()
method PrefixedExpr (line 611) | void PrefixedExpr()
method SQInteger (line 711) | SQInteger Factor()
method EmitLoadConstInt (line 875) | void EmitLoadConstInt(SQInteger value,SQInteger target)
method EmitLoadConstFloat (line 887) | void EmitLoadConstFloat(SQFloat value,SQInteger target)
method UnaryOP (line 899) | void UnaryOP(SQOpcode op)
method NeedGet (line 905) | bool NeedGet()
method FunctionCallArgs (line 919) | void FunctionCallArgs(bool rawcall = false)
method ParseTableOrClass (line 941) | void ParseTableOrClass(SQInteger separator,SQInteger terminator)
method LocalDeclStatement (line 1005) | void LocalDeclStatement()
method IfBlock (line 1036) | void IfBlock()
method IfStatement (line 1058) | void IfStatement()
method WhileStatement (line 1096) | void WhileStatement()
method DoWhileStatement (line 1115) | void DoWhileStatement()
method ForStatement (line 1137) | void ForStatement()
method ForEachStatement (line 1183) | void ForEachStatement()
method SwitchStatement (line 1225) | void SwitchStatement()
method FunctionStatement (line 1279) | void FunctionStatement()
method ClassStatement (line 1299) | void ClassStatement()
method SQObject (line 1319) | SQObject ExpectScalar()
method EnumStatement (line 1362) | void EnumStatement()
method TryCatchStatement (line 1390) | void TryCatchStatement()
method FunctionExp (line 1421) | void FunctionExp(SQInteger ftype)
method ClassExp (line 1428) | void ClassExp()
method DeleteExpr (line 1448) | void DeleteExpr()
method PrefixIncDec (line 1464) | void PrefixIncDec(SQInteger token)
method CreateFunction (line 1491) | void CreateFunction(SQObject &name)
method ResolveBreaks (line 1544) | void ResolveBreaks(SQFuncState *funcstate, SQInteger ntoresolve)
method ResolveContinues (line 1554) | void ResolveContinues(SQFuncState *funcstate, SQInteger ntoresolve, SQ...
function Compile (line 1580) | bool Compile(SQVM *vm,SQLEXREADFUNC rg, SQUserPointer up, const SQChar *...
FILE: extlibs/squirrel/squirrel/sqcompiler.h
type SQVM (line 5) | struct SQVM
FILE: extlibs/squirrel/squirrel/sqdebug.cpp
function SQRESULT (line 11) | SQRESULT sq_getfunctioninfo(HSQUIRRELVM v,SQInteger level,SQFunctionInfo...
function SQRESULT (line 29) | SQRESULT sq_stackinfos(HSQUIRRELVM v, SQInteger level, SQStackInfos *si)
function SQString (line 74) | SQString *SQVM::PrintObjVal(const SQObjectPtr &o)
FILE: extlibs/squirrel/squirrel/sqfuncproto.h
type SQOuterType (line 7) | enum SQOuterType {
function SQOuterVar (line 12) | struct SQOuterVar
function Release (line 33) | struct SQLocalVarInfo
function Finalize (line 120) | void Finalize(){ _NULL_SQOBJECT_VECTOR(_literals,_nliterals); }
function SQObjectType (line 121) | SQObjectType GetType() {return OT_FUNCPROTO;}
FILE: extlibs/squirrel/squirrel/sqfuncstate.cpp
function DumpLiteral (line 78) | void DumpLiteral(SQObjectPtr &o)
function SQInteger (line 215) | SQInteger SQFuncState::GetNumericConstant(const SQInteger cons)
function SQInteger (line 220) | SQInteger SQFuncState::GetNumericConstant(const SQFloat cons)
function SQInteger (line 225) | SQInteger SQFuncState::GetConstant(const SQObject &cons)
function SQInteger (line 259) | SQInteger SQFuncState::AllocStackPos()
function SQInteger (line 270) | SQInteger SQFuncState::PushTarget(SQInteger n)
function SQInteger (line 281) | SQInteger SQFuncState::GetUpTarget(SQInteger n){
function SQInteger (line 285) | SQInteger SQFuncState::TopTarget(){
function SQInteger (line 288) | SQInteger SQFuncState::PopTarget()
function SQInteger (line 300) | SQInteger SQFuncState::GetStackSize()
function SQInteger (line 305) | SQInteger SQFuncState::CountOuters(SQInteger stacksize)
function SQInteger (line 353) | SQInteger SQFuncState::PushLocalVariable(const SQObject &name)
function SQInteger (line 367) | SQInteger SQFuncState::GetLocalVariable(const SQObject &name)
function SQInteger (line 387) | SQInteger SQFuncState::GetOuterVariable(const SQObject &name)
function SQObject (line 582) | SQObject SQFuncState::CreateString(const SQChar *s,SQInteger len)
function SQObject (line 589) | SQObject SQFuncState::CreateTable()
function SQFunctionProto (line 596) | SQFunctionProto *SQFuncState::BuildProto()
function SQFuncState (line 630) | SQFuncState *SQFuncState::PushChildState(SQSharedState *ss)
FILE: extlibs/squirrel/squirrel/sqfuncstate.h
type SQFuncState (line 7) | struct SQFuncState
function PopInstructions (line 22) | void PopInstructions(SQInteger size){for(SQInteger i=0;i<size;i++)_instr...
function SnoozeOpt (line 25) | void SnoozeOpt(){_optimization=false;}
function AddDefaultParam (line 26) | void AddDefaultParam(SQInteger trg) { _defaultparams.push_back(trg); }
function SQInteger (line 27) | SQInteger GetDefaultParamCount() { return _defaultparams.size(); }
function SQInteger (line 28) | SQInteger GetCurrentPos(){return _instructions.size()-1;}
FILE: extlibs/squirrel/squirrel/sqlexer.cpp
function SQChar (line 100) | const SQChar *SQLexer::Tok2Str(SQInteger tok)
function SQInteger (line 129) | SQInteger SQLexer::Lex()
function SQInteger (line 284) | SQInteger SQLexer::GetIDType(const SQChar *s,SQInteger len)
function SQInteger (line 295) | SQInteger SQLexer::AddUTF16(SQUnsignedInteger ch)
function SQInteger (line 311) | SQInteger SQLexer::AddUTF8(SQUnsignedInteger ch)
function SQInteger (line 339) | SQInteger SQLexer::ProcessStringHexEscape(SQChar *dest, SQInteger maxdig...
function SQInteger (line 353) | SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
function LexHexadecimal (line 445) | void LexHexadecimal(const SQChar *s,SQUnsignedInteger *res)
function LexInteger (line 456) | void LexInteger(const SQChar *s,SQUnsignedInteger *res)
function SQInteger (line 465) | SQInteger scisodigit(SQInteger c) { return c >= _SC('0') && c <= _SC('7'...
function LexOctal (line 467) | void LexOctal(const SQChar *s,SQUnsignedInteger *res)
function SQInteger (line 477) | SQInteger isexponent(SQInteger c) { return c == 'e' || c=='E'; }
function SQInteger (line 481) | SQInteger SQLexer::ReadNumber()
function SQInteger (line 550) | SQInteger SQLexer::ReadID()
FILE: extlibs/squirrel/squirrel/sqlexer.h
type SQChar (line 6) | typedef SQChar LexChar;
type LexChar (line 8) | typedef unsigned char LexChar;
type SQLexer (line 11) | struct SQLexer
FILE: extlibs/squirrel/squirrel/sqmem.cpp
function sq_vm_free (line 10) | void sq_vm_free(void *p, SQUnsignedInteger SQ_UNUSED_ARG(size)){ free(p); }
FILE: extlibs/squirrel/squirrel/sqobject.cpp
function SQChar (line 15) | const SQChar *IdType2Name(SQObjectType type)
function SQChar (line 44) | const SQChar *GetTypeName(const SQObjectPtr &obj1)
function SQString (line 49) | SQString *SQString::Create(SQSharedState *ss,const SQChar *s,SQInteger len)
function SQInteger (line 60) | SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey,...
function SQUnsignedInteger (line 73) | SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx)
function SQWeakRef (line 85) | SQWeakRef *SQRefCounted::GetWeakRef(SQObjectType type)
function SQChar (line 215) | const SQChar* SQFunctionProto::GetLocal(SQVM *vm,SQUnsignedInteger stack...
function SQInteger (line 236) | SQInteger SQFunctionProto::GetLine(SQInstruction *curr)
function SafeWrite (line 279) | bool SafeWrite(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPo...
function SafeRead (line 288) | bool SafeRead(HSQUIRRELVM v,SQREADFUNC read,SQUserPointer up,SQUserPoint...
function WriteTag (line 297) | bool WriteTag(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUnsigne...
function CheckTag (line 302) | bool CheckTag(HSQUIRRELVM v,SQREADFUNC read,SQUserPointer up,SQUnsignedI...
function WriteObject (line 313) | bool WriteObject(HSQUIRRELVM v,SQUserPointer up,SQWRITEFUNC write,SQObje...
function ReadObject (line 336) | bool ReadObject(HSQUIRRELVM v,SQUserPointer up,SQREADFUNC read,SQObjectP...
FILE: extlibs/squirrel/squirrel/sqobject.h
type SQSharedState (line 17) | struct SQSharedState
type SQMetaMethod (line 19) | enum SQMetaMethod{
type SQRefCounted (line 87) | struct SQRefCounted
function SQRefCounted (line 98) | struct SQWeakRef : SQRefCounted
type SQObjectPtr (line 106) | struct SQObjectPtr
function SQObject (line 205) | struct SQObjectPtr : public SQObject
function Null (line 287) | inline void Null()
function _Swap (line 300) | inline void _Swap(SQObject &a,SQObject &b)
function SQRefCounted (line 313) | struct SQCollectable : public SQRefCounted {
function CHAINABLE_OBJ (line 339) | struct SQDelegable : public CHAINABLE_OBJ {
type sqvector (line 346) | typedef sqvector<SQObjectPtr> SQObjectPtrVec;
type sqvector (line 347) | typedef sqvector<SQInteger> SQIntVec;
FILE: extlibs/squirrel/squirrel/sqopcodes.h
type BitWiseOP (line 8) | enum BitWiseOP {
type CmpOP (line 17) | enum CmpOP {
type NewObjectType (line 25) | enum NewObjectType {
type AppendArrayType (line 31) | enum AppendArrayType {
type SQOpcode (line 39) | enum SQOpcode
type SQInstructionDesc (line 105) | struct SQInstructionDesc {
type SQInstruction (line 109) | struct SQInstruction
type sqvector (line 127) | typedef sqvector<SQInstruction> SQInstructionVec;
FILE: extlibs/squirrel/squirrel/sqstate.cpp
function CompileTypemask (line 35) | bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
function SQTable (line 76) | SQTable *CreateDefaultDelegate(SQSharedState *ss,const SQRegFunction *fu...
function SQInteger (line 213) | SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
function SQInteger (line 267) | SQInteger SQSharedState::ResurrectUnreachable(SQVM *vm)
function SQInteger (line 321) | SQInteger SQSharedState::CollectGarbage(SQVM *vm)
function SQChar (line 374) | SQChar* SQSharedState::GetScratchPad(SQInteger size)
function SQUnsignedInteger (line 432) | SQUnsignedInteger RefTable::GetRefCount(SQObject &obj)
function SQBool (line 441) | SQBool RefTable::Release(SQObject &obj)
function SQString (line 580) | SQString *SQStringTable::Add(const SQChar *news,SQInteger len)
FILE: extlibs/squirrel/squirrel/sqstate.h
type SQString (line 7) | struct SQString
type SQTable (line 8) | struct SQTable
type SQStringTable (line 12) | struct SQStringTable
type RefTable (line 27) | struct RefTable {
type SQObjectPtr (line 57) | struct SQObjectPtr
type SQSharedState (line 59) | struct SQSharedState
FILE: extlibs/squirrel/squirrel/sqstring.h
function SQHash (line 5) | inline SQHash _hashstr (const SQChar *s, size_t l)
function SQRefCounted (line 14) | struct SQString : public SQRefCounted
FILE: extlibs/squirrel/squirrel/sqtable.cpp
function SQTable (line 73) | SQTable *SQTable::Clone()
function SQInteger (line 176) | SQInteger SQTable::Next(bool getweakrefs,const SQObjectPtr &refpos, SQOb...
FILE: extlibs/squirrel/squirrel/sqtable.h
function SQHash (line 15) | inline SQHash HashObj(const SQObjectPtr &key)
function SQDelegable (line 25) | struct SQTable : public SQDelegable
function SQObjectType (line 64) | SQObjectType GetType() {return OT_TABLE;}
function _HashNode (line 66) | inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)
function GetStr (line 77) | inline bool GetStr(const SQChar* key,SQInteger keylen,SQObjectPtr &val)
function SQInteger (line 101) | SQInteger CountUsed(){ return _usednodes;}
function Release (line 103) | void Release()
FILE: extlibs/squirrel/squirrel/squserdata.h
function SQDelegable (line 5) | struct SQUserData : SQDelegable
FILE: extlibs/squirrel/squirrel/squtils.h
function copy (line 31) | void copy(const sqvector<T>& v)
function reserve (line 53) | void reserve(SQUnsignedInteger newsize) { _realloc(newsize); }
function shrinktofit (line 71) | void shrinktofit() { if(_size > 4) { _realloc(_size); } }
function pop_back (line 81) | inline void pop_back()
function insert (line 85) | void insert(SQUnsignedInteger idx, const T& val)
function remove (line 93) | void remove(SQUnsignedInteger idx)
function SQUnsignedInteger (line 101) | SQUnsignedInteger capacity() { return _allocated; }
function T (line 103) | inline T& operator[](SQUnsignedInteger pos) const{ return _vals[pos]; }
FILE: extlibs/squirrel/squirrel/sqvm.cpp
function SQRESULT (line 511) | SQRESULT SQVM::Suspend()
function SQInteger (line 1311) | SQInteger SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &k...
function SQInteger (line 1384) | SQInteger SQVM::FallBackSet(const SQObjectPtr &self,const SQObjectPtr &k...
function SQObjectPtr (line 1737) | SQObjectPtr &SQVM::Top() { CheckStackAccess(_top-1); return _stack[_top-...
function SQObjectPtr (line 1738) | SQObjectPtr &SQVM::PopGet() { CheckStackAccess(_top-1); return _stack[--...
function SQObjectPtr (line 1739) | SQObjectPtr &SQVM::GetUp(SQInteger n) { CheckStackAccess(_top+n); return...
function SQObjectPtr (line 1740) | SQObjectPtr &SQVM::GetAt(SQInteger n) { CheckStackAccess(n); return _sta...
FILE: extlibs/squirrel/squirrel/sqvm.h
function SQExceptionTrap (line 20) | struct SQExceptionTrap{
type sqvector (line 32) | typedef sqvector<SQExceptionTrap> ExceptionsTraps;
function CHAINABLE_OBJ (line 34) | struct SQVM : public CHAINABLE_OBJ
function AutoDec (line 183) | struct AutoDec{
function SQObjectPtr (line 189) | inline SQObjectPtr &stack_get(HSQUIRRELVM v,SQInteger idx){return ((idx>...
FILE: include/engge/Audio/SoundCategory.hpp
type ng (line 3) | namespace ng {
type SoundCategory (line 4) | enum class SoundCategory {
FILE: include/engge/Audio/SoundDefinition.hpp
type ng (line 9) | namespace ng {
class SoundId (line 10) | class SoundId
class Sound (line 12) | class Sound : public ScriptObject {
class SoundDefinition (line 17) | class SoundDefinition final : public Sound {
method getPath (line 25) | [[nodiscard]] std::string getPath() const { return m_path; }
FILE: include/engge/Audio/SoundId.hpp
type ng (line 8) | namespace ng {
class Entity (line 9) | class Entity
class SoundManager (line 10) | class SoundManager
class SoundId (line 12) | class SoundId final : public Sound {
method getSoundDefinition (line 21) | std::shared_ptr<ng::SoundDefinition> getSoundDefinition() { return m...
method getSoundHandle (line 22) | std::shared_ptr<ngf::SoundHandle> getSoundHandle() { return m_sound; }
method SoundCategory (line 23) | [[nodiscard]] SoundCategory getSoundCategory() const { return m_cate...
FILE: include/engge/Audio/SoundManager.hpp
type ng (line 9) | namespace ng {
class Entity (line 10) | class Entity
class Engine (line 11) | class Engine
class SoundDefinition (line 12) | class SoundDefinition
class SoundId (line 13) | class SoundId
class SoundManager (line 15) | class SoundManager {
method setEngine (line 19) | void setEngine(Engine *pEngine) { m_pEngine = pEngine; }
method Engine (line 20) | [[nodiscard]] Engine *getEngine() const { return m_pEngine; }
method setMasterVolume (line 41) | void setMasterVolume(float volume) { m_masterVolume = std::clamp(vol...
method getMasterVolume (line 42) | [[nodiscard]] float getMasterVolume() const { return m_masterVolume; }
method setSoundVolume (line 43) | void setSoundVolume(float volume) { m_soundVolume = std::clamp(volum...
method getSoundVolume (line 44) | [[nodiscard]] float getSoundVolume() const { return m_soundVolume; }
method setMusicVolume (line 45) | void setMusicVolume(float volume) { m_musicVolume = std::clamp(volum...
method getMusicVolume (line 46) | [[nodiscard]] float getMusicVolume() const { return m_musicVolume; }
method setTalkVolume (line 47) | void setTalkVolume(float volume) { m_talkVolume = std::clamp(volume,...
method getTalkVolume (line 48) | [[nodiscard]] float getTalkVolume() const { return m_talkVolume; }
method setSoundHover (line 55) | void setSoundHover(std::shared_ptr<SoundDefinition> sound) { m_pSoun...
method getSoundHover (line 56) | [[nodiscard]] std::shared_ptr<SoundDefinition> getSoundHover() const...
method getSize (line 58) | [[nodiscard]] size_t getSize() const { return m_soundIds.size(); }
FILE: include/engge/Audio/SoundTrigger.hpp
type ng (line 7) | namespace ng {
class Entity (line 8) | class Entity
class Engine (line 9) | class Engine
class SoundDefinition (line 10) | class SoundDefinition
class SoundId (line 11) | class SoundId
class SoundTrigger (line 12) | class SoundTrigger final : public Trigger {
FILE: include/engge/Dialog/ConditionVisitor.hpp
type ng (line 4) | namespace ng{
class DialogConditionAbstract (line 6) | class DialogConditionAbstract
class ConditionVisitor (line 8) | class ConditionVisitor final : public Ast::AstVisitor {
method isAccepted (line 11) | [[nodiscard]] bool isAccepted() const { return m_isAccepted; }
FILE: include/engge/Dialog/DialogConditionAbstract.hpp
type ng (line 5) | namespace ng {
class DialogConditionAbstract (line 6) | class DialogConditionAbstract {
FILE: include/engge/Dialog/DialogContextAbstract.hpp
type ng (line 6) | namespace ng{
class DialogContextAbstract (line 7) | class DialogContextAbstract {
FILE: include/engge/Dialog/DialogManager.hpp
type ng (line 11) | namespace ng {
class Actor (line 12) | class Actor
class Engine (line 13) | class Engine
type DialogSlot (line 15) | struct DialogSlot {
class DialogManager (line 21) | class DialogManager final : public ngf::Drawable {
method DialogManagerState (line 31) | [[nodiscard]] DialogManagerState getState() const { return m_state; }
FILE: include/engge/Dialog/DialogPlayer.hpp
type ng (line 7) | namespace ng {
type DialogManagerState (line 9) | enum class DialogManagerState {
type DialogPlayerState (line 15) | enum class DialogPlayerState {
type DialogConditionMode (line 24) | enum class DialogConditionMode {
type DialogConditionState (line 32) | struct DialogConditionState {
class DialogScriptAbstract (line 40) | class DialogScriptAbstract
class DialogPlayer (line 41) | class DialogPlayer final : public DialogContextAbstract, public Dialog...
method getActor (line 54) | [[nodiscard]] std::string getActor() const { return m_actor; }
method getDialogName (line 55) | [[nodiscard]] std::string getDialogName() const { return m_dialogNam...
FILE: include/engge/Dialog/DialogScriptAbstract.hpp
type ng (line 4) | namespace ng {
class DialogScriptAbstract (line 5) | class DialogScriptAbstract {
FILE: include/engge/Dialog/EngineDialogScript.hpp
type ng (line 6) | namespace ng {
class Engine (line 7) | class Engine
class EngineDialogScript (line 9) | class EngineDialogScript final : public DialogScriptAbstract {
FILE: include/engge/Dialog/ExpressionVisitor.hpp
type ng (line 5) | namespace ng {
class DialogContextAbstract (line 6) | class DialogContextAbstract
class ExpressionVisitor (line 7) | class ExpressionVisitor final : public Ast::AstVisitor {
FILE: include/engge/EnggeApplication.hpp
type ng (line 13) | namespace ng {
class Engine (line 15) | class Engine
class EnggeApplication (line 17) | class EnggeApplication final : public ngf::Application {
FILE: include/engge/Engine/ActorIconSlot.hpp
type ng (line 3) | namespace ng {
class Actor (line 4) | class Actor
type ActorIconSlot (line 5) | struct ActorIconSlot {
FILE: include/engge/Engine/ActorIcons.hpp
type ng (line 7) | namespace ng {
type ActorSlotSelectableMode (line 8) | enum class ActorSlotSelectableMode {
class Engine (line 14) | class Engine
class ActorIcons (line 15) | class ActorIcons final : public ngf::Drawable {
method isMouseOver (line 23) | [[nodiscard]] bool isMouseOver() const { return m_isInside; }
method ActorSlotSelectableMode (line 26) | [[nodiscard]] inline ActorSlotSelectableMode getMode() const { retur...
method setVisible (line 27) | void setVisible(bool visible) { m_visible = visible; }
FILE: include/engge/Engine/Callback.hpp
type ng (line 8) | namespace ng {
class Callback (line 9) | class Callback final : public TimeFunction {
method getId (line 14) | [[nodiscard]] int getId() const { return m_id; }
method HSQOBJECT (line 16) | [[nodiscard]] HSQOBJECT getArgument() const { return m_arg; }
FILE: include/engge/Engine/Camera.hpp
type ng (line 9) | namespace ng {
class Engine (line 10) | class Engine
class Camera (line 11) | class Camera {
type Impl (line 46) | struct Impl
FILE: include/engge/Engine/ChangeProperty.hpp
type ng (line 7) | namespace ng {
class ChangeProperty (line 9) | class ChangeProperty : public TimeFunction {
method ChangeProperty (line 11) | ChangeProperty(std::function<Value()> get,
method isElapsed (line 43) | bool isElapsed() override {
method onElapsed (line 49) | void onElapsed() override {
FILE: include/engge/Engine/Cutscene.hpp
type ng (line 6) | namespace ng {
class Actor (line 7) | class Actor
class Engine (line 8) | class Engine
class Room (line 9) | class Room
class Cutscene (line 10) | class Cutscene final : public ThreadBase, public Function {
method isGlobal (line 22) | [[nodiscard]] bool isGlobal() const final { return true; }
method hasCutsceneOverride (line 29) | [[nodiscard]] bool hasCutsceneOverride() const { return m_hasCutscen...
FILE: include/engge/Engine/Engine.hpp
type ng (line 13) | namespace ng {
class Actor (line 14) | class Actor
class Camera (line 15) | class Camera
class Cutscene (line 16) | class Cutscene
class DialogManager (line 17) | class DialogManager
class EnggeApplication (line 18) | class EnggeApplication
class Entity (line 19) | class Entity
class Function (line 20) | class Function
class Inventory (line 21) | class Inventory
class Object (line 22) | class Object
class Preferences (line 23) | class Preferences
class Room (line 24) | class Room
class ScriptExecute (line 25) | class ScriptExecute
class Sentence (line 26) | class Sentence
class SoundDefinition (line 27) | class SoundDefinition
class SoundManager (line 28) | class SoundManager
class ResourceManager (line 29) | class ResourceManager
class ThreadBase (line 30) | class ThreadBase
type Verb (line 31) | struct Verb
class VerbExecute (line 32) | class VerbExecute
type UseFlag (line 34) | enum class UseFlag {
type FadeEffect (line 42) | enum class FadeEffect {
type FadeEffectParameters (line 49) | struct FadeEffectParameters {
type WalkboxesFlags (line 59) | enum class WalkboxesFlags {
class Engine (line 66) | class Engine : public NonCopyable {
type Impl (line 192) | struct Impl
FILE: include/engge/Engine/EngineCommands.hpp
type ng::EngineCommands (line 3) | namespace ng::EngineCommands {
FILE: include/engge/Engine/EngineSettings.hpp
type ng (line 9) | namespace ng {
class EngineSettings (line 10) | class EngineSettings {
method getPackCount (line 19) | [[nodiscard]] int getPackCount() const { return static_cast<int>(m_p...
method iterator (line 25) | iterator begin() { return m_packs.begin(); }
method iterator (line 26) | iterator end() { return m_packs.end(); }
method const_iterator (line 28) | [[nodiscard]] const_iterator cbegin() const { return m_packs.cbegin(...
method const_iterator (line 29) | [[nodiscard]] const_iterator cend() const { return m_packs.cend(); }
FILE: include/engge/Engine/EntityManager.hpp
type ng (line 9) | namespace ng {
class Actor (line 10) | class Actor
class Entity (line 11) | class Entity
class Sound (line 12) | class Sound
class SoundDefinition (line 13) | class SoundDefinition
class SoundId (line 14) | class SoundId
class ThreadBase (line 15) | class ThreadBase
class EntityManager (line 17) | class EntityManager {
method getActorId (line 35) | inline int getActorId() { return START_ACTORID + m_actorId++; }
method getRoomId (line 36) | inline int getRoomId() { return START_ROOMID + m_roomId++; }
method getObjectId (line 37) | inline int getObjectId() { return START_OBJECTID + m_objectId++; }
method getLightId (line 38) | inline int getLightId() { return START_LIGHTID + m_lightId++; }
method getSoundId (line 39) | inline int getSoundId() { return START_SOUNDID + m_soundId++; }
method getCallbackId (line 40) | inline int getCallbackId() { return START_CALLBACKID + m_callbackId+...
method setCallbackId (line 41) | inline void setCallbackId(int id) { m_callbackId = id - START_CALLBA...
method getThreadId (line 42) | inline int getThreadId() { return START_THREADID + m_threadId++; }
method isActor (line 68) | static bool isActor(int id) { return isBetween(id, START_ACTORID, EN...
method isRoom (line 69) | static bool isRoom(int id) { return isBetween(id, START_ROOMID, END_...
method isObject (line 70) | static bool isObject(int id) { return isBetween(id, START_OBJECTID, ...
method isLight (line 71) | static bool isLight(int id) { return isBetween(id, START_LIGHTID, EN...
method isSound (line 72) | static bool isSound(int id) { return isBetween(id, START_SOUNDID, EN...
method isThread (line 73) | static bool isThread(int id) { return isBetween(id, START_THREADID, ...
method isBetween (line 76) | static inline bool isBetween(int id, int min, int max) { return id >...
function TScriptObject (line 89) | TScriptObject *EntityManager::getScriptObject(HSQUIRRELVM v, HSQOBJECT...
function TScriptObject (line 106) | TScriptObject *EntityManager::getScriptObject(HSQUIRRELVM v, SQInteger...
function TScriptObject (line 122) | TScriptObject *EntityManager::getScriptObjectFromId(int id) {
FILE: include/engge/Engine/ExCommandConstants.hpp
type ExCommandConstants (line 3) | namespace ExCommandConstants {
FILE: include/engge/Engine/Function.hpp
type ng (line 7) | namespace ng {
class Function (line 8) | class Function : public NonCopyable {
method isElapsed (line 10) | virtual bool isElapsed() { return true; }
FILE: include/engge/Engine/Hud.hpp
type ng (line 7) | namespace ng {
class Hud (line 8) | class Hud final : public ngf::Drawable {
type State (line 10) | enum class State {
method setCurrentVerb (line 35) | void setCurrentVerb(const Verb *pVerb) { m_pVerb = pVerb; }
method setVerbOverride (line 36) | void setVerbOverride(const Verb *pVerb) { m_pVerbOverride = pVerb; }
method Verb (line 37) | [[nodiscard]] const Verb *getCurrentVerb() const { return m_pVerb; }
method Verb (line 38) | [[nodiscard]] const Verb *getVerbOverride() const { return m_pVerbOv...
method setHoveredEntity (line 39) | void setHoveredEntity(Entity *pEntity) { m_pHoveredEntity = pEntity; }
method Entity (line 40) | [[nodiscard]] Entity *getHoveredEntity() const { return m_pHoveredEn...
method Inventory (line 46) | Inventory &getInventory() { return m_inventory; }
method setVisible (line 50) | void setVisible(bool visible) { m_isVisible = visible; }
method getActive (line 52) | [[nodiscard]] bool getActive() const { return m_active; }
FILE: include/engge/Engine/InputStateConstants.hpp
type ng::InputStateConstants (line 3) | namespace ng::InputStateConstants {
FILE: include/engge/Engine/Interpolations.hpp
type ng (line 5) | namespace ng {
type InterpolationMethod (line 6) | enum class InterpolationMethod {
function T (line 18) | inline T operator~(T a) { return (T) ~(int) a; }
function T (line 19) | inline T operator|(T a, T b) { return (T) ((int) a | (int) b); }
function T (line 20) | inline T operator&(T a, T b) { return (T) ((int) a & (int) b); }
function T (line 21) | inline T operator^(T a, T b) { return (T) ((int) a ^ (int) b); }
function T (line 22) | inline T &operator|=(T &a, T b) { return (T &) ((int &) a |= (int) b); }
function T (line 23) | inline T &operator&=(T &a, T b) { return (T &) ((int &) a &= (int) b); }
function T (line 24) | inline T &operator^=(T &a, T b) { return (T &) ((int &) a ^= (int) b); }
class Interpolations (line 26) | class Interpolations {
method linear (line 28) | static float linear(float t) { return t; }
method easeIn (line 30) | static float easeIn(float t) { return t * t * t * t; }
method easeOut (line 32) | static float easeOut(float t) {
method easeInOut (line 37) | static float easeInOut(float t) {
class InterpolationHelper (line 47) | class InterpolationHelper {
method getInterpolationMethod (line 49) | static std::function<float(float)> getInterpolationMethod(Interpolat...
FILE: include/engge/Engine/Inventory.hpp
type ng (line 6) | namespace ng {
class Object (line 7) | class Object
class Inventory (line 9) | class Inventory final : public ngf::Drawable {
method setCurrentActorIndex (line 14) | void setCurrentActorIndex(int index) { m_currentActorIndex = index; }
method setCurrentActor (line 15) | void setCurrentActor(Actor *pActor) { m_pCurrentActor = pActor; }
method setMousePosition (line 16) | void setMousePosition(const glm::vec2 &pos) { m_mousePos = pos; }
method Object (line 17) | Object *getCurrentInventoryObject() { return m_pCurrentInventoryObje...
method setVerbUiColors (line 20) | void setVerbUiColors(const VerbUiColors *pColors) { m_pColors = pCol...
method setAlpha (line 21) | void setAlpha(float alpha) { m_alpha = alpha;}
method getAlpha (line 22) | [[nodiscard]] float getAlpha() const {return m_alpha;}
FILE: include/engge/Engine/Light.hpp
type ng (line 8) | namespace ng {
class Light (line 9) | class Light final : public ScriptObject {
FILE: include/engge/Engine/Preferences.hpp
type ng (line 7) | namespace ng {
type PreferenceNames (line 8) | namespace PreferenceNames {
type PreferenceDefaultValues (line 44) | namespace PreferenceDefaultValues {
type TempPreferenceNames (line 79) | namespace TempPreferenceNames {
type TempPreferenceDefaultValues (line 84) | namespace TempPreferenceDefaultValues {
class Preferences (line 89) | class Preferences {
function T (line 139) | T Preferences::getUserPreference(const std::string &name, T value) con...
function T (line 149) | T Preferences::getTempPreference(const std::string &name, T value) con...
FILE: include/engge/Engine/RoomEffect.hpp
type ng (line 4) | namespace ng {
type RoomEffect (line 5) | struct RoomEffect {
method reset (line 19) | void reset() {
FILE: include/engge/Engine/SavegameSlot.hpp
type ng (line 6) | namespace ng {
class SavegameSlot (line 7) | class SavegameSlot {
FILE: include/engge/Engine/Sentence.hpp
type ng (line 7) | namespace ng {
class Sentence (line 8) | class Sentence : public Function {
FILE: include/engge/Engine/TextDatabase.hpp
type ng (line 5) | namespace ng {
class TextDatabase (line 6) | class TextDatabase {
FILE: include/engge/Engine/Thread.hpp
type ng (line 7) | namespace ng {
class Thread (line 8) | class Thread final : public ThreadBase {
method isGlobal (line 20) | [[nodiscard]] bool isGlobal() const final { return m_isGlobal; }
FILE: include/engge/Engine/ThreadBase.hpp
type ng (line 6) | namespace ng {
class ThreadBase (line 7) | class ThreadBase : public ScriptObject {
method setPauseable (line 17) | inline void setPauseable(bool value) { m_isPauseable = value; }
method isPauseable (line 18) | [[nodiscard]] inline bool isPauseable() const { return m_isPauseable; }
method isGlobal (line 19) | [[nodiscard]] virtual bool isGlobal() const { return false; }
FILE: include/engge/Engine/TimeFunction.hpp
type ng (line 5) | namespace ng {
class TimeFunction (line 6) | class TimeFunction : public Function {
FILE: include/engge/Engine/Trigger.hpp
type ng (line 4) | namespace ng {
class Trigger (line 5) | class Trigger {
FILE: include/engge/Engine/Verb.hpp
type ng (line 6) | namespace ng {
type VerbConstants (line 7) | namespace VerbConstants {
type Verb (line 21) | struct Verb {
method getName (line 28) | static std::string getName(int id) {
class VerbSlot (line 45) | class VerbSlot {
method setVerb (line 47) | void setVerb(int index, const Verb &verb) { m_verbs.at(index) = verb; }
method Verb (line 48) | [[nodiscard]] const Verb &getVerb(int index) const { return m_verbs....
type VerbUiColors (line 54) | struct VerbUiColors {
FILE: include/engge/Entities/Actor.hpp
type ng (line 9) | namespace ng {
class Costume (line 10) | class Costume
class Engine (line 11) | class Engine
class Lip (line 12) | class Lip
class Object (line 13) | class Object
class PathDrawable (line 14) | class PathDrawable
class Room (line 15) | class Room
class Actor (line 17) | class Actor final : public Entity {
type Impl (line 77) | struct Impl
FILE: include/engge/Entities/AnimationLoader.hpp
type ng (line 8) | namespace ng {
class AnimationLoader (line 9) | class AnimationLoader final {
FILE: include/engge/Entities/BlinkState.hpp
type ng (line 5) | namespace ng {
class Costume (line 6) | class Costume
class BlinkState (line 8) | class BlinkState final {
FILE: include/engge/Entities/Costume.hpp
type ng (line 17) | namespace ng {
type Reaching (line 19) | enum class Reaching {
class Actor (line 25) | class Actor
class Costume (line 27) | class Costume final : public ngf::Drawable {
method getPath (line 33) | [[nodiscard]] std::string getPath() const { return m_path; }
method getSheet (line 34) | [[nodiscard]] std::string getSheet() const { return m_sheet; }
method setStandState (line 43) | void setStandState() { setState(m_standAnimName); }
method setWalkState (line 44) | void setWalkState() { setState(m_walkAnimName, true); }
method Animation (line 47) | Animation *getAnimation() { return m_pCurrentAnimation; }
method AnimControl (line 48) | AnimControl& getAnimControl() { return m_animControl; }
method setActor (line 63) | void setActor(Actor *pActor) { m_pActor = pActor; }
FILE: include/engge/Entities/DirectionConstants.hpp
type ng (line 3) | namespace ng {
type DirectionConstants (line 4) | namespace DirectionConstants {
FILE: include/engge/Entities/Entity.hpp
type ng (line 15) | namespace ng {
class Actor (line 16) | class Actor
class Engine (line 17) | class Engine
class Room (line 18) | class Room
class SoundDefinition (line 19) | class SoundDefinition
class SoundTrigger (line 20) | class SoundTrigger
class Trigger (line 21) | class Trigger
type Motor (line 22) | struct Motor
class Entity (line 24) | class Entity : public ScriptObject, public ngf::Drawable {
type Impl (line 133) | struct Impl
FILE: include/engge/Entities/Facing.hpp
type ng (line 4) | namespace ng {
type Facing (line 5) | enum class Facing {
FILE: include/engge/Entities/Object.hpp
type ng (line 8) | namespace ng {
type ScreenSpace (line 9) | enum class ScreenSpace {
type ObjectType (line 14) | enum class ObjectType {
class Actor (line 21) | class Actor
class Room (line 22) | class Room
type ObjectStateConstants (line 24) | namespace ObjectStateConstants {
type ObjectFlagConstants (line 36) | namespace ObjectFlagConstants {
class Object (line 57) | class Object : public Entity {
type Impl (line 134) | struct Impl
FILE: include/engge/Entities/TextObject.hpp
type ngf (line 4) | namespace ngf {
class Font (line 5) | class Font
type ng (line 8) | namespace ng {
type TextAlignment (line 9) | enum class TextAlignment : unsigned long {
class TextObject (line 20) | class TextObject final : public Object {
method setFont (line 26) | void setFont(const ngf::Font *font) { m_font = font; }
method setAlignment (line 31) | void setAlignment(TextAlignment alignment) { m_alignment = alignment; }
method TextAlignment (line 32) | TextAlignment getAlignment() const { return m_alignment; }
method setMaxWidth (line 34) | void setMaxWidth(int maxWidth) { m_maxWidth = maxWidth; }
method getMaxWidth (line 35) | int getMaxWidth() const { return m_maxWidth; }
FILE: include/engge/Entities/UseDirection.hpp
type ng (line 4) | namespace ng {
type UseDirection (line 5) | enum class UseDirection {
FILE: include/engge/Graphics/AnimControl.hpp
type ng (line 6) | namespace ng {
class AnimControl (line 7) | class AnimControl {
FILE: include/engge/Graphics/AnimDrawable.hpp
type ng (line 6) | namespace ng {
type Animation (line 7) | struct Animation
class AnimDrawable (line 9) | class AnimDrawable {
FILE: include/engge/Graphics/AnimState.hpp
type ng (line 3) | namespace ng {
type AnimState (line 4) | enum class AnimState {
FILE: include/engge/Graphics/Animation.hpp
type ng (line 11) | namespace ng {
type Animation (line 12) | struct Animation {
FILE: include/engge/Graphics/GGFont.hpp
type ng (line 7) | namespace ng {
class GGFont (line 8) | class GGFont : public ngf::Font {
FILE: include/engge/Graphics/LightingShader.h
function namespace (line 8) | namespace ng {
FILE: include/engge/Graphics/ResourceManager.hpp
type ngf (line 7) | namespace ngf {
class FntFont (line 8) | class FntFont
type ng (line 11) | namespace ng {
class GGFont (line 12) | class GGFont
class SpriteSheet (line 13) | class SpriteSheet
type TextureResource (line 15) | struct TextureResource {
class ResourceManager (line 20) | class ResourceManager : public NonCopyable {
FILE: include/engge/Graphics/Screen.hpp
type ng (line 3) | namespace ng {
class Screen (line 4) | class Screen {
FILE: include/engge/Graphics/SpriteSheet.hpp
type ng (line 8) | namespace ng {
class SpriteSheet (line 9) | class SpriteSheet {
method setTextureManager (line 11) | void setTextureManager(ResourceManager *pTextureManager) { m_pResour...
method getTexture (line 13) | [[nodiscard]] std::shared_ptr<ngf::Texture> getTexture() const { ret...
method getTextureName (line 14) | [[nodiscard]] std::string getTextureName() const { return m_textureN...
FILE: include/engge/Graphics/SpriteSheetItem.h
function namespace (line 6) | namespace ng {
FILE: include/engge/Graphics/Text.hpp
type ng (line 4) | namespace ng {
class Text (line 5) | class Text : public ngf::Text {
FILE: include/engge/Input/CommandManager.hpp
type ng (line 8) | namespace ng {
class CommandManager (line 9) | class CommandManager {
FILE: include/engge/Input/InputConstants.hpp
type ng (line 4) | namespace ng {
type InputConstants (line 6) | enum class InputConstants {
type MetaKeys (line 86) | enum class MetaKeys {
type Input (line 94) | struct Input {
method Input (line 96) | Input(MetaKeys metaKey, InputConstants input) {
method Input (line 101) | Input(InputConstants input) {
type InputHash (line 114) | struct InputHash {
FILE: include/engge/Input/InputMappings.hpp
type ng (line 3) | namespace ng {
class InputMappings (line 4) | class InputMappings {
FILE: include/engge/Parsers/GGPackBufferStream.hpp
class GGPackBufferStream (line 6) | class GGPackBufferStream : public GGPackStream {
method GGPackBufferStream (line 8) | GGPackBufferStream() = default;
FILE: include/engge/Parsers/GGPackStream.hpp
class GGPackStream (line 4) | class GGPackStream {
FILE: include/engge/Parsers/Lip.hpp
type ng (line 8) | namespace ng {
type NGLipData (line 9) | struct NGLipData {
class Lip (line 15) | class Lip {
method getData (line 21) | [[nodiscard]] std::vector<NGLipData> getData() const { return m_data; }
method getPath (line 22) | [[nodiscard]] std::string getPath() const { return m_path; }
FILE: include/engge/Parsers/SavegameManager.hpp
type ng (line 7) | namespace ng {
class SavegameManager (line 8) | class SavegameManager {
FILE: include/engge/Parsers/YackParser.hpp
type ng (line 9) | namespace ng {
type Ast (line 10) | namespace Ast {
class AstVisitor (line 11) | class AstVisitor
class Node (line 13) | class Node {
method Node (line 15) | Node() = default;
class Expression (line 25) | class Expression : public Node {
method Expression (line 27) | Expression() = default;
class Condition (line 33) | class Condition : public Node {
method getLine (line 38) | int32_t getLine() const { return m_line; }
class CodeCondition (line 43) | class CodeCondition : public Condition {
class OnceCondition (line 53) | class OnceCondition : public Condition {
class ShowOnceCondition (line 61) | class ShowOnceCondition : public Condition {
class OnceEverCondition (line 69) | class OnceEverCondition : public Condition {
class TempOnceCondition (line 77) | class TempOnceCondition : public Condition {
class Statement (line 85) | class Statement : public Node {
method Statement (line 87) | Statement() = default;
class Goto (line 96) | class Goto : public Expression {
method Goto (line 98) | Goto() = default;
class Code (line 105) | class Code : public Expression {
method Code (line 107) | Code() = default;
class Choice (line 114) | class Choice : public Expression {
method Choice (line 116) | Choice() = default;
class Say (line 125) | class Say : public Expression {
method Say (line 127) | Say() = default;
class Pause (line 135) | class Pause : public Expression {
method Pause (line 137) | Pause() = default;
class Parrot (line 144) | class Parrot : public Expression {
method Parrot (line 146) | Parrot() = default;
class Dialog (line 153) | class Dialog : public Expression {
method Dialog (line 155) | Dialog() = default;
class Override (line 162) | class Override : public Expression {
method Override (line 164) | Override() = default;
class Shutup (line 171) | class Shutup : public Expression {
method Shutup (line 173) | Shutup() = default;
class AllowObjects (line 179) | class AllowObjects : public Expression {
method AllowObjects (line 181) | AllowObjects() = default;
class Limit (line 189) | class Limit : public Expression {
method Limit (line 191) | Limit() = default;
class WaitWhile (line 199) | class WaitWhile : public Expression {
method WaitWhile (line 201) | WaitWhile() = default;
class WaitFor (line 209) | class WaitFor : public Expression {
method WaitFor (line 211) | WaitFor() = default;
class Label (line 218) | class Label : public Node {
method Label (line 220) | Label() = default;
class CompilationUnit (line 228) | class CompilationUnit {
method CompilationUnit (line 230) | CompilationUnit() = default;
class AstVisitor (line 236) | class AstVisitor {
class YackParser (line 263) | class YackParser {
FILE: include/engge/Parsers/YackTokenReader.hpp
type ng (line 9) | namespace ng {
type TokenId (line 10) | enum class TokenId {
type Token (line 28) | struct Token {
class YackTokenReader (line 39) | class YackTokenReader {
class Iterator (line 41) | class Iterator {
FILE: include/engge/Room/Room.hpp
type ngf (line 11) | namespace ngf {
class Walkbox (line 12) | class Walkbox
class Graph (line 13) | class Graph
type ng (line 16) | namespace ng {
class Entity (line 17) | class Entity
class Light (line 18) | class Light
class Object (line 19) | class Object
class RoomScaling (line 20) | class RoomScaling
class ResourceManager (line 21) | class ResourceManager
class TextObject (line 22) | class TextObject
class ThreadBase (line 23) | class ThreadBase
type RoomEffectConstants (line 29) | namespace RoomEffectConstants {
class Room (line 38) | class Room : public ScriptObject {
type Impl (line 106) | struct Impl
FILE: include/engge/Room/RoomLayer.hpp
type ng (line 7) | namespace ng {
class RoomLayer (line 9) | class RoomLayer {
method setRoomSizeY (line 15) | void setRoomSizeY(int roomSizeY) { m_roomSizeY = roomSizeY; }
method setOffsetY (line 16) | void setOffsetY(int offsetY) { m_offsetY = offsetY; }
method setParallax (line 20) | void setParallax(const glm::vec2 ¶llax) { m_parallax = parallax; }
method setZOrder (line 23) | void setZOrder(int zsort) { m_zsort = zsort; }
method getZOrder (line 24) | [[nodiscard]] int getZOrder() const { return m_zsort; }
method setEnabled (line 29) | void setEnabled(bool enabled) { m_enabled = enabled; }
method isEnabled (line 30) | [[nodiscard]] bool isEnabled() const { return m_enabled; }
FILE: include/engge/Room/RoomScaling.hpp
type ng (line 5) | namespace ng {
type Scaling (line 6) | struct Scaling {
class RoomScaling (line 11) | class RoomScaling {
method RoomScaling (line 13) | RoomScaling() = default;
FILE: include/engge/Scripting/ScriptEngine.hpp
type ng (line 13) | namespace ng {
class Pack (line 14) | class Pack {
class ScriptEngine (line 19) | class ScriptEngine {
method HSQUIRRELVM (line 32) | static HSQUIRRELVM getVm() { return m_vm; }
method registerErrorCallback (line 99) | static void registerErrorCallback(const PrintCallback &callback) {
method registerPrintCallback (line 103) | static void registerPrintCallback(const PrintCallback &callback) {
FILE: include/engge/Scripting/ScriptExecute.hpp
type ng (line 4) | namespace ng {
class SoundDefinition (line 5) | class SoundDefinition
class ScriptExecute (line 6) | class ScriptExecute {
FILE: include/engge/Scripting/ScriptObject.hpp
type ng (line 3) | namespace ng {
class ScriptObject (line 4) | class ScriptObject {
method getId (line 8) | [[nodiscard]] int getId() const { return m_id; }
FILE: include/engge/Scripting/VerbExecute.hpp
type ng (line 3) | namespace ng {
class Entity (line 4) | class Entity
type Verb (line 5) | struct Verb
class VerbExecute (line 7) | class VerbExecute {
FILE: include/engge/System/Locator.hpp
type ng (line 4) | namespace ng {
class Logger (line 5) | class Logger
class EntityManager (line 6) | class EntityManager
type Locator (line 9) | struct Locator {
method Locator (line 10) | Locator() = delete;
method set (line 13) | inline static void set(std::shared_ptr<TService> pService) {
method TService (line 18) | inline static TService &create(_Args &&...__args) {
method TService (line 23) | inline static TService &get() {
method reset (line 27) | static void reset() {
FILE: include/engge/System/Logger.hpp
type ng (line 7) | namespace ng {
class Logger (line 13) | class Logger {
function trace (line 59) | static void trace(string_view_t message, const Args &... args) {
function info (line 64) | static void info(string_view_t message, const Args &... args) {
function warn (line 69) | static void warn(string_view_t message, const Args &... args) {
function error (line 74) | static void error(string_view_t message, const Args &... args) {
function critical (line 79) | static void critical(string_view_t message, const Args &... args) {
FILE: include/engge/System/NonCopyable.hpp
type ng (line 3) | namespace ng {
class NonCopyable (line 4) | class NonCopyable {
method NonCopyable (line 6) | NonCopyable() = default;
method NonCopyable (line 11) | NonCopyable(const NonCopyable &) = delete;
method NonCopyable (line 12) | NonCopyable &operator=(const NonCopyable &) = delete;
FILE: include/engge/System/Services.hpp
type ng (line 13) | namespace ng {
class Services (line 14) | class Services final {
method init (line 16) | static void init() {
FILE: include/engge/UI/OptionsDialog.hpp
type ng (line 4) | namespace ng {
class OptionsDialog (line 5) | class OptionsDialog final : public ngf::Drawable {
type Impl (line 22) | struct Impl
FILE: include/engge/UI/QuitDialog.hpp
type ng (line 3) | namespace ng {
class QuitDialog (line 4) | class QuitDialog final : public ngf::Drawable {
type Impl (line 19) | struct Impl
FILE: include/engge/UI/SaveLoadDialog.hpp
type ng (line 8) | namespace ng {
class Engine (line 10) | class Engine
class SaveLoadDialog (line 12) | class SaveLoadDialog final : public ngf::Drawable {
type Impl (line 31) | struct Impl
FILE: include/engge/UI/StartScreenDialog.hpp
type ng (line 4) | namespace ng {
class StartScreenDialog (line 6) | class StartScreenDialog final : public ngf::Drawable {
type Impl (line 21) | struct Impl
FILE: include/engge/Util/BTEACrypto.hpp
type ng (line 4) | namespace ng {
class BTEACrypto (line 5) | class BTEACrypto {
FILE: include/engge/Util/RandomNumberGenerator.hpp
type ng (line 3) | namespace ng {
class RandomNumberGenerator (line 4) | class RandomNumberGenerator {
FILE: src/Audio/SoundDefinition.cpp
type ng (line 8) | namespace ng {
FILE: src/Audio/SoundId.cpp
type ng (line 10) | namespace ng {
FILE: src/Audio/SoundManager.cpp
type ng (line 13) | namespace ng {
FILE: src/Audio/SoundTrigger.cpp
type ng (line 7) | namespace ng {
FILE: src/Dialog/Ast.cpp
type ng::Ast (line 3) | namespace ng::Ast {
FILE: src/Dialog/AstDump.hpp
type ng (line 4) | namespace ng {
class AstDump (line 5) | class AstDump : public Ast::AstVisitor {
method dump (line 7) | static void dump(const std::string &filename) {
method visit (line 26) | void visit(const Ast::Statement &node) override {
method visit (line 32) | void visit(const Ast::Pause &node) override {
method visit (line 35) | void visit(const Ast::WaitFor &node) override {
method visit (line 38) | void visit(const Ast::Parrot &node) override {
method visit (line 41) | void visit(const Ast::Dialog &node) override {
method visit (line 44) | void visit(const Ast::Shutup &) override {
method visit (line 47) | void visit(const Ast::Override &node) override {
method visit (line 50) | void visit(const Ast::Label &node) override {
method visit (line 56) | void visit(const Ast::Say &node) override {
method visit (line 59) | void visit(const Ast::Choice &node) override {
method visit (line 62) | void visit(const Ast::Code &node) override {
method visit (line 65) | void visit(const Ast::Goto &node) override {
method visit (line 68) | void visit(const Ast::OnceCondition & node) override {
method visit (line 71) | void visit(const Ast::ShowOnceCondition &node) override {
method visit (line 74) | void visit(const Ast::CodeCondition &node) override {
method visit (line 77) | void visit(const Ast::TempOnceCondition &node) override {
FILE: src/Dialog/ConditionVisitor.cpp
type ng (line 5) | namespace ng {
FILE: src/Dialog/DialogManager.cpp
type ng (line 11) | namespace ng {
function getGlobalBounds (line 17) | ngf::frect getGlobalBounds(const ngf::Text &text) {
FILE: src/Dialog/DialogPlayer.cpp
type ng (line 8) | namespace ng {
type DialogSelectMode (line 10) | enum class DialogSelectMode {
class ConditionStateVisitor (line 15) | class ConditionStateVisitor : public Ast::AstVisitor {
method getState (line 19) | [[nodiscard]] std::optional<DialogConditionState> getState() const {...
function DialogManagerState (line 143) | DialogManagerState DialogPlayer::getState() const {
FILE: src/Dialog/EngineDialogScript.cpp
type ng (line 8) | namespace ng {
FILE: src/Dialog/ExpressionVisitor.cpp
type ng (line 4) | namespace ng {
FILE: src/EnggeApplication.cpp
function toKey (line 8) | ng::InputConstants toKey(ngf::Scancode key) {
function toMetaKeys (line 42) | ng::MetaKeys toMetaKeys(const ngf::KeyModifiers &modifiers) {
type ng (line 55) | namespace ng {
FILE: src/Engine/AchievementManager.cpp
function toString (line 14) | std::string toString(const ngf::GGPackValue &value) {
type ng (line 31) | namespace ng {
FILE: src/Engine/AchievementManager.hpp
type ng (line 7) | namespace ng {
class AchievementManager (line 8) | class AchievementManager final {
method setPrivatePreference (line 14) | void setPrivatePreference(const std::string &name, T value) {
FILE: src/Engine/ActorIcons.cpp
type ng (line 11) | namespace ng {
FILE: src/Engine/Callback.cpp
type ng (line 16) | namespace ng {
FILE: src/Engine/Camera.cpp
type ng (line 6) | namespace ng {
type Camera::Impl (line 7) | struct Camera::Impl {
FILE: src/Engine/Cutscene.cpp
type ng (line 8) | namespace ng {
function HSQUIRRELVM (line 38) | HSQUIRRELVM Cutscene::getThread() const {
FILE: src/Engine/DebugFeatures.hpp
type ng (line 3) | namespace ng {
type DebugFeatures (line 5) | struct DebugFeatures {
FILE: src/Engine/Engine.cpp
type ng (line 46) | namespace ng {
function ResourceManager (line 102) | ResourceManager &Engine::getResourceManager() { return m_pImpl->m_reso...
function Room (line 104) | Room *Engine::getRoom() { return m_pImpl->m_pRoom; }
function Actor (line 138) | Actor *Engine::getCurrentActor() { return m_pImpl->m_pCurrentActor; }
function VerbUiColors (line 140) | const VerbUiColors *Engine::getVerbUiColors(const std::string &name) c...
function Actor (line 207) | const Actor *Engine::getFollowActor() const {
function Preferences (line 239) | Preferences &Engine::getPreferences() { return m_pImpl->m_preferences; }
function SoundManager (line 241) | SoundManager &Engine::getSoundManager() { return m_pImpl->m_soundManag...
function DialogManager (line 243) | DialogManager &Engine::getDialogManager() { return m_pImpl->m_dialogMa...
function Camera (line 245) | Camera &Engine::getCamera() { return m_pImpl->m_camera; }
function SQInteger (line 249) | SQInteger Engine::setRoom(Room *pRoom) {
function SQInteger (line 270) | SQInteger Engine::enterRoomFromDoor(Object *pDoor) {
function WalkboxesFlags (line 676) | WalkboxesFlags Engine::getWalkboxesFlags() const { return m_pImpl->m_s...
function SoundDefinition (line 687) | SoundDefinition *Engine::getSoundDefinition(const std::string &name) {
function ActorSlotSelectableMode (line 720) | ActorSlotSelectableMode Engine::getActorSlotSelectable() const { retur...
function Cutscene (line 740) | Cutscene *Engine::getCutscene() const { return m_pImpl->m_pCutscene; }
function HSQOBJECT (line 744) | HSQOBJECT &Engine::getDefaultObject() { return m_pImpl->m_pDefaultObje...
function Verb (line 748) | const Verb *Engine::getActiveVerb() const { return m_pImpl->m_hud.getC...
function FadeEffectParameters (line 759) | FadeEffectParameters &Engine::getFadeParameters() {
function Inventory (line 830) | Inventory &Engine::getInventory() { return m_pImpl->m_hud.getInventory...
function Hud (line 831) | Hud &Engine::getHud() { return m_pImpl->m_hud; }
function Entity (line 855) | Entity *Engine::getEntity(const std::string &name) {
FILE: src/Engine/EngineImpl.cpp
type ng (line 7) | namespace ng {
function toColor (line 8) | ngf::Color toColor(const ObjectType &type) {
function CursorDirection (line 23) | CursorDirection operator|=(CursorDirection &lhs, CursorDirection rhs) {
function SQInteger (line 168) | SQInteger Engine::Impl::exitRoom(Object *pObject) {
function SQInteger (line 227) | SQInteger Engine::Impl::enterRoom(Room *pRoom, Object *pObject) const {
function Entity (line 358) | Entity *Engine::Impl::getHoveredEntity(const glm::vec2 &mousPos) {
function Entity (line 459) | Entity *Engine::Impl::getEntity(Entity *pEntity) const {
function Verb (line 519) | const Verb *Engine::Impl::getHoveredVerb() const {
function InputConstants (line 582) | InputConstants Engine::Impl::toKey(const std::string &keyText) {
class ArrowShape (line 725) | class ArrowShape final : public ngf::Drawable {
method ArrowShape (line 727) | ArrowShape(UseDirection dir, const ngf::Color &color) : m_dir(dir), ...
method draw (line 729) | void draw(ngf::RenderTarget &target, ngf::RenderStates s) const final {
class CrossShape (line 769) | class CrossShape final : public ngf::Drawable {
method CrossShape (line 771) | explicit CrossShape(const ngf::Color &color) : m_color(color) {}
method draw (line 773) | void draw(ngf::RenderTarget &target, ngf::RenderStates s) const final {
function Verb (line 1025) | const Verb *Engine::Impl::overrideVerb(const Verb *pVerb) const {
FILE: src/Engine/EngineImpl.hpp
type ng (line 68) | namespace ng {
type CursorDirection (line 76) | enum class CursorDirection : unsigned int {
type EngineState (line 85) | enum class EngineState {
type Engine::Impl (line 89) | struct Engine::Impl {
class SaveGameSystem (line 90) | class SaveGameSystem {
method SaveGameSystem (line 92) | explicit SaveGameSystem(Engine::Impl *pImpl) : m_pImpl(pImpl) {}
method saveGame (line 94) | void saveGame(const std::filesystem::path &path) {
method loadGame (line 134) | void loadGame(const std::string &path) {
method getSlotPath (line 144) | static std::filesystem::path getSlotPath(int slot) {
method getSlot (line 152) | static void getSlot(SavegameSlot &slot) {
method getValue (line 160) | static std::string getValue(const ngf::GGPackValue &property) {
method SQObjectPtr (line 172) | SQObjectPtr toSquirrel(const ngf::GGPackValue &value) {
method loadGameScene (line 234) | void loadGameScene(const ngf::GGPackValue &hash) {
method loadDialog (line 251) | void loadDialog(const ngf::GGPackValue &hash) {
method DialogConditionState (line 271) | [[nodiscard]] static DialogConditionState parseState(const std::st...
method loadCallbacks (line 304) | void loadCallbacks(const ngf::GGPackValue &hash) {
method loadActors (line 317) | void loadActors(const ngf::GGPackValue &hash) {
method loadActor (line 327) | void loadActor(Actor *pActor, const ngf::GGPackValue &actorHash) {
method loadInventory (line 409) | void loadInventory(const ngf::GGPackValue &hash) {
method loadObjects (line 431) | void loadObjects(const ngf::GGPackValue &hash) {
method getValue (line 446) | static void getValue(const ngf::GGPackValue &hash, const std::stri...
method getValue (line 452) | static void getValue(const ngf::GGPackValue &hash, const std::stri...
method getValue (line 458) | static void getValue(const ngf::GGPackValue &hash, const std::stri...
method getValue (line 464) | static void getValue(const ngf::GGPackValue &hash, const std::stri...
method getValue (line 470) | static void getValue(const ngf::GGPackValue &hash, const std::stri...
method getValue (line 476) | static void getValue(const ngf::GGPackValue &hash, const std::stri...
method loadObject (line 482) | void loadObject(Object *pObj, const ngf::GGPackValue &hash) {
method loadPseudoObjects (line 506) | void loadPseudoObjects(Room *pRoom, const ngf::GGPackValue &hash) {
method loadRooms (line 517) | void loadRooms(const ngf::GGPackValue &hash) {
method loadGame (line 547) | void loadGame(const ngf::GGPackValue &hash) {
method setActor (line 576) | void setActor(const std::string &name) {
method Actor (line 581) | Actor *getActor(const std::string &name) {
method Room (line 585) | Room *getRoom(const std::string &name) {
method Object (line 593) | static Object *getInventoryObject(const std::string &name) {
method Object (line 606) | Object *getObject(const std::string &name) {
method Object (line 616) | static Object *getObject(Room *pRoom, const std::string &name) {
method setCurrentRoom (line 624) | void setCurrentRoom(const std::string &name) {
method saveActors (line 628) | [[nodiscard]] ngf::GGPackValue saveActors() const {
method saveGlobals (line 672) | [[nodiscard]] static ngf::GGPackValue saveGlobals() {
method saveDialogs (line 686) | [[nodiscard]] ngf::GGPackValue saveDialogs() const {
method saveGameScene (line 709) | [[nodiscard]] ngf::GGPackValue saveGameScene() const {
method saveInventory (line 740) | [[nodiscard]] ngf::GGPackValue saveInventory() const {
method saveObjects (line 776) | [[nodiscard]] ngf::GGPackValue saveObjects() const {
method savePseudoObjects (line 791) | static ngf::GGPackValue savePseudoObjects(const Room *pRoom) {
method saveObject (line 799) | static ngf::GGPackValue saveObject(const Object *pObject) {
method saveRooms (line 814) | [[nodiscard]] ngf::GGPackValue saveRooms() const {
method saveCallbacks (line 826) | [[nodiscard]] ngf::GGPackValue saveCallbacks() const {
method loadGlobals (line 851) | void loadGlobals(const ngf::GGPackValue &hash) {
method toString (line 861) | static std::string toString(const glm::vec2 &pos) {
method toString (line 867) | static std::string toString(const glm::ivec2 &pos) {
FILE: src/Engine/EngineSettings.cpp
function throwEntryNotFound (line 11) | void throwEntryNotFound(const std::string &name) {
type ng (line 18) | namespace ng {
FILE: src/Engine/EntityManager.cpp
type ng (line 14) | namespace ng {
function Actor (line 15) | Actor *EntityManager::getActorFromId(int id) {
function Object (line 26) | Object *EntityManager::getObjectFromId(int id) {
function Room (line 45) | Room *EntityManager::getRoomFromId(int id) {
function Sound (line 55) | Sound *EntityManager::getSoundFromId(int id) {
function ThreadBase (line 71) | ThreadBase *EntityManager::getThreadFromId(int id) {
function ThreadBase (line 85) | ThreadBase *EntityManager::getThreadFromVm(HSQUIRRELVM v) {
function Entity (line 101) | Entity *EntityManager::getEntity(HSQUIRRELVM v, SQInteger index) {
function Object (line 105) | Object *EntityManager::getObject(HSQUIRRELVM v, SQInteger index) {
function Room (line 109) | Room *EntityManager::getRoom(HSQUIRRELVM v, SQInteger index) { return ...
function Actor (line 111) | Actor *EntityManager::getActor(HSQUIRRELVM v, SQInteger index) {
function SoundId (line 116) | SoundId *EntityManager::getSound(HSQUIRRELVM v, SQInteger index) {
FILE: src/Engine/Hud.cpp
type ng (line 10) | namespace ng {
function VerbSlot (line 38) | [[nodiscard]] const VerbSlot &Hud::getVerbSlot(int characterSlot) const {
function VerbUiColors (line 46) | [[nodiscard]] const VerbUiColors &Hud::getVerbUiColors(int characterSl...
function Verb (line 138) | const Verb *Hud::getVerb(int id) const {
function Verb (line 166) | const Verb *Hud::getHoveredVerb() const {
FILE: src/Engine/Inventory.cpp
type ng (line 13) | namespace ng {
FILE: src/Engine/Light.cpp
type ng (line 5) | namespace ng {
FILE: src/Engine/Preferences.cpp
type ng (line 4) | namespace ng {
FILE: src/Engine/Sentence.cpp
type ng (line 3) | namespace ng {
function Sentence (line 4) | Sentence &Sentence::push_back(std::unique_ptr<Function> func) {
FILE: src/Engine/Shaders.cpp
type ng (line 3) | namespace ng {
FILE: src/Engine/Shaders.hpp
type ng (line 3) | namespace ng {
type Shaders (line 4) | struct Shaders {
FILE: src/Engine/TextDatabase.cpp
type ng (line 7) | namespace ng {
FILE: src/Engine/Thread.cpp
type ng (line 7) | namespace ng {
function HSQUIRRELVM (line 32) | HSQUIRRELVM Thread::getThread() const { return m_threadObj._unVal.pThr...
FILE: src/Engine/ThreadBase.cpp
type ng (line 6) | namespace ng {
FILE: src/Engine/TimeFunction.cpp
type ng (line 3) | namespace ng {
FILE: src/Engine/Trigger.cpp
type ng (line 3) | namespace ng {
FILE: src/Entities/Actor.cpp
type ng (line 15) | namespace ng {
function frameContains (line 18) | bool frameContains(const SpriteSheetItem &frame, const glm::vec2 &pos) {
function animContains (line 28) | bool animContains(const Animation &anim, const glm::vec2 &pos) {
type Actor::Impl (line 40) | struct Actor::Impl {
method Impl (line 41) | explicit Impl(Engine &engine)
method setActor (line 45) | void setActor(Actor *pActor) {
function Costume (line 85) | Costume &Actor::getCostume() { return m_pImpl->_costume; }
function Costume (line 87) | Costume &Actor::getCostume() const { return m_pImpl->_costume; }
function Room (line 89) | Room *Actor::getRoom() { return m_pImpl->_pRoom; }
function HSQOBJECT (line 165) | HSQOBJECT &Actor::getTable() { return m_pImpl->_table; }
function HSQOBJECT (line 166) | HSQOBJECT &Actor::getTable() const { return m_pImpl->_table; }
function Room (line 177) | const Room *Actor::getRoom() const { return m_pImpl->_pRoom; }
FILE: src/Entities/AnimationLoader.cpp
type ng (line 9) | namespace ng {
function toBool (line 12) | bool toBool(const ngf::GGPackValue &gValue) {
function parseIVec2 (line 16) | glm::ivec2 parseIVec2(std::string_view value) {
function Animation (line 23) | Animation parseAnimation(Entity &entity,
FILE: src/Entities/BlinkState.cpp
type ng (line 6) | namespace ng {
FILE: src/Entities/Costume.cpp
type ng (line 15) | namespace ng {
function Facing (line 45) | Facing Costume::getFacing() const {
FILE: src/Entities/Entity.cpp
type ng (line 14) | namespace ng {
type Motor (line 15) | struct Motor {
type Entity::Impl (line 20) | struct Entity::Impl {
method Impl (line 41) | Impl() : m_engine(ng::Locator<ng::Engine>::get()) {
method getDefaultVerb (line 45) | static std::optional<int> getDefaultVerb(const Entity *pEntity) {
function SoundTrigger (line 219) | SoundTrigger *Entity::createSoundTrigger(Engine &engine, const std::ve...
function Actor (line 379) | Actor *Entity::getActor(const Entity *pEntity) {
function Entity (line 391) | Entity *Entity::getParent() {
function Entity (line 395) | const Entity *Entity::getParent() const {
FILE: src/Entities/JiggleFunction.cpp
type ng (line 3) | namespace ng {
FILE: src/Entities/JiggleFunction.hpp
type ng (line 7) | namespace ng {
class JiggleFunction (line 8) | class JiggleFunction final : public Function {
FILE: src/Entities/LipAnimation.cpp
type ng (line 5) | namespace ng {
FILE: src/Entities/LipAnimation.hpp
type ng (line 5) | namespace ng {
class Actor (line 6) | class Actor
class LipAnimation (line 8) | class LipAnimation final {
FILE: src/Entities/Object.cpp
type ng (line 21) | namespace ng {
type Object::Impl (line 22) | struct Object::Impl {
method Impl (line 49) | Impl() {
method Impl (line 58) | explicit Impl(HSQOBJECT obj) {
function ObjectType (line 89) | ObjectType Object::getType() const { return pImpl->type; }
function Actor (line 146) | Actor *Object::getOwner() const { return pImpl->owner; }
function HSQOBJECT (line 148) | HSQOBJECT &Object::getTable() { return pImpl->table; }
function HSQOBJECT (line 149) | HSQOBJECT &Object::getTable() const { return pImpl->table; }
function Room (line 154) | Room *Object::getRoom() { return pImpl->pRoom; }
function Room (line 155) | const Room *Object::getRoom() const { return pImpl->pRoom; }
function Trigger (line 166) | Trigger *Object::getTrigger() { return pImpl->trigger.has_value() ? (*...
function Animation (line 227) | Animation *Object::getAnimation() { return pImpl->pAnim; }
function Animation (line 228) | const Animation *Object::getAnimation() const { return pImpl->pAnim; }
function AnimControl (line 230) | AnimControl &Object::getAnimControl() { return pImpl->animControl; }
function ScreenSpace (line 267) | ScreenSpace Object::getScreenSpace() const { return pImpl->screenSpace; }
FILE: src/Entities/ShakeFunction.cpp
type ng (line 3) | namespace ng {
FILE: src/Entities/ShakeFunction.hpp
type ng (line 7) | namespace ng {
class ShakeFunction (line 8) | class ShakeFunction final : public Function {
FILE: src/Entities/TalkingState.cpp
type ng (line 5) | namespace ng {
FILE: src/Entities/TalkingState.hpp
type ng (line 14) | namespace ng {
class TalkingState (line 15) | class TalkingState final : public ngf::Drawable {
method TalkingState (line 17) | TalkingState() = default;
FILE: src/Entities/TextObject.cpp
type ng (line 7) | namespace ng {
function toAnchor (line 15) | ngf::Anchor toAnchor(TextAlignment alignment) {
FILE: src/Entities/WalkingState.cpp
type ng (line 7) | namespace ng {
function Facing (line 30) | Facing WalkingState::getFacing() {
FILE: src/Entities/WalkingState.hpp
type ng (line 8) | namespace ng {
class Actor (line 9) | class Actor
class WalkingState (line 11) | class WalkingState final {
method isWalking (line 18) | [[nodiscard]] inline bool isWalking() const { return m_isWalking; }
FILE: src/Graphics/AnimControl.cpp
type ng (line 3) | namespace ng {
function Animation (line 9) | Animation *AnimControl::getAnimation() { return m_anim; }
function AnimState (line 35) | AnimState AnimControl::getState() const {
FILE: src/Graphics/AnimDrawable.cpp
type ng (line 9) | namespace ng {
FILE: src/Graphics/GGFont.cpp
type ng (line 8) | namespace ng {
FILE: src/Graphics/GraphDrawable.cpp
type ng (line 5) | namespace ng {
FILE: src/Graphics/GraphDrawable.hpp
type ngf (line 8) | namespace ngf {
class Graph (line 9) | class Graph
type ng (line 12) | namespace ng {
class GraphDrawable (line 14) | class GraphDrawable : public ngf::Drawable {
FILE: src/Graphics/LightingShader.cpp
type ng (line 3) | namespace ng {
FILE: src/Graphics/PathDrawable.cpp
type ng (line 4) | namespace ng {
FILE: src/Graphics/PathDrawable.hpp
type ng (line 9) | namespace ng {
class PathDrawable (line 10) | class PathDrawable final : public ngf::Drawable {
FILE: src/Graphics/ResourceManager.cpp
type ng (line 10) | namespace ng {
function GGFont (line 71) | GGFont &ResourceManager::getFont(const std::string &id) {
function SpriteSheet (line 89) | const SpriteSheet &ResourceManager::getSpriteSheet(const std::string &...
FILE: src/Graphics/SpriteSheet.cpp
type ng (line 7) | namespace ng {
function SpriteSheetItem (line 64) | [[nodiscard]] SpriteSheetItem SpriteSheet::getItem(const std::string &...
FILE: src/Graphics/Text.cpp
type ng (line 4) | namespace ng {
FILE: src/Graphics/WalkboxDrawable.cpp
type ng (line 3) | namespace ng {
FILE: src/Graphics/WalkboxDrawable.hpp
type ng (line 7) | namespace ng {
class WalkboxDrawable (line 9) | class WalkboxDrawable final : public ngf::Drawable {
FILE: src/Input/CommandManager.cpp
type ng (line 4) | namespace ng {
FILE: src/Input/InputMappings.cpp
type ng (line 9) | namespace ng {
function InputConstants (line 11) | static InputConstants toKey(const std::string &keyText) {
function InputConstants (line 19) | static InputConstants toKey(const std::string &name, T value) {
FILE: src/Parsers/GGPackBufferStream.cpp
function GGPackBufferStream (line 38) | GGPackBufferStream &GGPackBufferStream::ignore(std::streamsize n, int de...
FILE: src/Parsers/Lip.cpp
type ng (line 7) | namespace ng {
FILE: src/Parsers/SavegameManager.cpp
type ng (line 9) | namespace ng {
FILE: src/Parsers/YackParser.cpp
type ng (line 4) | namespace ng {
FILE: src/Parsers/YackTokenReader.cpp
type ng (line 6) | namespace ng {
function Token (line 49) | Token &YackTokenReader::Iterator::operator*() {
function Token (line 53) | const Token &YackTokenReader::Iterator::operator*() const {
function Token (line 57) | Token *YackTokenReader::Iterator::operator->() {
function TokenId (line 132) | TokenId YackTokenReader::readTokenId() {
function TokenId (line 175) | TokenId YackTokenReader::readCode() {
function TokenId (line 189) | TokenId YackTokenReader::readDollar() {
function TokenId (line 197) | TokenId YackTokenReader::readCondition() {
function TokenId (line 205) | TokenId YackTokenReader::readNumber() {
function TokenId (line 218) | TokenId YackTokenReader::readComment() {
function TokenId (line 224) | TokenId YackTokenReader::readString() {
function TokenId (line 229) | TokenId YackTokenReader::readIdentifier(char c) {
FILE: src/Room/Room.cpp
type ng (line 24) | namespace ng {
type CmpLayer (line 26) | struct CmpLayer {
type Room::Impl (line 30) | struct Room::Impl {
method Impl (line 57) | explicit Impl(HSQOBJECT roomTable)
method setEffect (line 66) | void setEffect(int effect) {
method setRoom (line 70) | void setRoom(Room *pRoom) { _pRoom = pRoom; }
method loadBackgrounds (line 72) | void loadBackgrounds(ngf::GGPackValue &jWimpy) {
method loadLayers (line 106) | void loadLayers(const ngf::GGPackValue &jWimpy) {
method loadObjects (line 134) | void loadObjects(const ngf::GGPackValue &jWimpy) {
method SQInteger (line 258) | static SQInteger createObjectsFromTable(Room *pRoom, std::unordered_...
method Scaling (line 321) | static Scaling parseScaling(std::string_view value) {
method loadScalings (line 328) | void loadScalings(const ngf::GGPackValue &jWimpy) {
method loadWalkboxes (line 362) | void loadWalkboxes(const ngf::GGPackValue &jWimpy) {
method updateGraph (line 378) | bool updateGraph(const glm::vec2 &start) {
method sortWalkboxes (line 387) | bool sortWalkboxes(const glm::vec2 &start) {
function HSQOBJECT (line 467) | HSQOBJECT &Room::getTable() { return m_pImpl->_roomTable; }
function TextObject (line 523) | TextObject &Room::createTextObject(const std::string &fontName) {
function Object (line 547) | Object &Room::createObject(const std::vector<std::string> &anims) { re...
function Object (line 549) | Object &Room::createObject(const std::string &sheet, const std::vector...
function Object (line 572) | Object &Room::createObject(const std::string &image) {
function Object (line 598) | Object &Room::createObject() {
function RoomScaling (line 670) | const RoomScaling &Room::getRoomScaling() const { return m_pImpl->_sca...
function Light (line 704) | Light *Room::createLight(ngf::Color color, glm::ivec2 pos) {
function LightingShader (line 713) | LightingShader& Room::getLightingShader() { return m_pImpl->_lightingS...
function SpriteSheet (line 736) | const SpriteSheet &Room::getSpriteSheet() const { return m_pImpl->_spr...
FILE: src/Room/RoomLayer.cpp
type ng (line 7) | namespace ng {
FILE: src/Room/RoomScaling.cpp
type ng (line 3) | namespace ng {
FILE: src/Room/RoomTrigger.cpp
type ng (line 9) | namespace ng {
function HSQUIRRELVM (line 53) | HSQUIRRELVM RoomTrigger::createThread() {
FILE: src/Room/RoomTrigger.hpp
type ng (line 7) | namespace ng {
class Engine (line 8) | class Engine
class Object (line 9) | class Object
class RoomTrigger (line 11) | class RoomTrigger : public Trigger {
method HSQOBJECT (line 16) | HSQOBJECT &getInside() { return m_inside; }
method HSQOBJECT (line 17) | HSQOBJECT &getOutside() { return m_outside; }
FILE: src/Room/RoomTriggerThread.cpp
type ng (line 4) | namespace ng {
function HSQUIRRELVM (line 14) | HSQUIRRELVM RoomTriggerThread::getThread() const {
FILE: src/Room/RoomTriggerThread.hpp
type ng (line 6) | namespace ng {
class RoomTriggerThread (line 7) | class RoomTriggerThread final : public ThreadBase {
FILE: src/Scripting/ActorPack.hpp
type ng (line 8) | namespace ng {
class ActorPack (line 9) | class ActorPack final : public Pack {
method registerPack (line 14) | void registerPack() const override {
method SQInteger (line 68) | static SQInteger actorAlpha(HSQUIRRELVM v) {
method SQInteger (line 83) | static SQInteger actorAnimationNames(HSQUIRRELVM v) {
method SQInteger (line 126) | static SQInteger actorAnimationFlags(HSQUIRRELVM v) {
method Facing (line 140) | static Facing _getFacing(SQInteger dir, Facing currentFacing) {
method SQInteger (line 160) | static SQInteger actorAt(HSQUIRRELVM v) {
method SQInteger (line 233) | static SQInteger flashSelectableActor(HSQUIRRELVM v) {
method SQInteger (line 242) | static SQInteger actorColor(HSQUIRRELVM v) {
method SQInteger (line 258) | static SQInteger actorCostume(HSQUIRRELVM v) {
method SQInteger (line 273) | static SQInteger actorDistanceTo(HSQUIRRELVM v) {
method SQInteger (line 294) | static SQInteger actorDistanceWithin(HSQUIRRELVM v) {
method _distance (line 333) | static float _distance(glm::vec2 p1, glm::vec2 p2) {
method SQInteger (line 338) | static SQInteger actorFace(HSQUIRRELVM v) {
method SQInteger (line 374) | static SQInteger actorHidden(HSQUIRRELVM v) {
method SQInteger (line 387) | static SQInteger actorShowHideLayer(HSQUIRRELVM v, bool isVisible) {
method SQInteger (line 400) | static SQInteger actorHideLayer(HSQUIRRELVM v) { return actorShowHid...
method SQInteger (line 402) | static SQInteger actorInTrigger(HSQUIRRELVM v) {
method SQInteger (line 416) | static SQInteger actorInWalkbox(HSQUIRRELVM v) {
method SQInteger (line 432) | static SQInteger actorLockFacing(HSQUIRRELVM v) {
method SQInteger (line 471) | static SQInteger actorBlinkRate(HSQUIRRELVM v) {
method SQInteger (line 488) | static SQInteger actorPlayAnimation(HSQUIRRELVM v) {
method SQInteger (line 505) | static SQInteger actorPosX(HSQUIRRELVM v) {
method SQInteger (line 514) | static SQInteger actorPosY(HSQUIRRELVM v) {
method SQInteger (line 523) | static SQInteger actorRenderOffset(HSQUIRRELVM v) {
method SQInteger (line 539) | static SQInteger actorRoom(HSQUIRRELVM v) {
method SQInteger (line 553) | static SQInteger actorStand(HSQUIRRELVM v) {
method SQInteger (line 562) | static SQInteger actorShowLayer(HSQUIRRELVM v) { return actorShowHid...
method SQInteger (line 564) | static SQInteger actorSlotSelectable(HSQUIRRELVM v) {
method SQInteger (line 608) | static SQInteger actorTalking(HSQUIRRELVM v) {
method SQInteger (line 622) | static SQInteger actorStopWalking(HSQUIRRELVM v) {
method SQInteger (line 631) | static SQInteger actorTalkColors(HSQUIRRELVM v) {
method SQInteger (line 644) | static SQInteger actorTalkOffset(HSQUIRRELVM v) {
method SQInteger (line 661) | static SQInteger actorTurnTo(HSQUIRRELVM v) {
method Facing (line 686) | static Facing _getFacingToFaceTo(Actor *pActor, Entity *pEntity) {
method Facing (line 697) | static Facing _flip(Facing facing) {
method SQInteger (line 707) | static SQInteger actorUsePos(HSQUIRRELVM v) {
method SQInteger (line 730) | static SQInteger actorUseWalkboxes(HSQUIRRELVM v) {
method SQInteger (line 742) | static SQInteger actorVolume(HSQUIRRELVM v) {
method SQInteger (line 755) | static SQInteger actorWalkForward(HSQUIRRELVM v) {
method SQInteger (line 779) | static SQInteger actorWalking(HSQUIRRELVM v) {
method SQInteger (line 794) | static SQInteger actorWalkSpeed(HSQUIRRELVM v) {
method SQInteger (line 810) | static SQInteger actorWalkTo(HSQUIRRELVM v) {
method SQInteger (line 848) | static SQInteger addSelectableActor(HSQUIRRELVM v) {
method SQInteger (line 858) | static SQInteger createActor(HSQUIRRELVM v) {
method SQInteger (line 880) | static SQInteger isActor(HSQUIRRELVM v) {
method SQInteger (line 886) | static SQInteger isActorSelectable(HSQUIRRELVM v) {
method SQInteger (line 893) | static SQInteger isActorOnScreen(HSQUIRRELVM v) {
method SQInteger (line 912) | static SQInteger masterActorArray(HSQUIRRELVM v) {
method SQInteger (line 922) | static SQInteger _sayLine(HSQUIRRELVM v, bool mumble = false) {
method SQInteger (line 961) | static SQInteger mumbleLine(HSQUIRRELVM v) { return _sayLine(v, true...
method SQInteger (line 963) | static SQInteger sayLine(HSQUIRRELVM v) {
method SQInteger (line 974) | static SQInteger sayLineAt(HSQUIRRELVM v) {
method SQInteger (line 1012) | static SQInteger selectActor(HSQUIRRELVM v) {
method SQInteger (line 1021) | static SQInteger stopTalking(HSQUIRRELVM v) {
method SQInteger (line 1040) | static SQInteger triggerActors(HSQUIRRELVM v) {
method SQInteger (line 1055) | static SQInteger readFieldInt(HSQUIRRELVM v, const SQChar *name, SQI...
method SQInteger (line 1069) | static SQInteger verbUIColors(HSQUIRRELVM v) {
FILE: src/Scripting/ActorWalk.cpp
type ng (line 11) | namespace ng {
function Facing (line 26) | Facing ActorWalk::getFacing(const Entity *pEntity) {
FILE: src/Scripting/ActorWalk.hpp
type ng (line 7) | namespace ng {
class Actor (line 8) | class Actor
class Engine (line 9) | class Engine
class Entity (line 10) | class Entity
class Sentence (line 11) | class Sentence
type Verb (line 12) | struct Verb
class ActorWalk (line 14) | class ActorWalk final : public Function {
FILE: src/Scripting/BnutPass.hpp
type ng (line 1) | namespace ng {
FILE: src/Scripting/DefaultScriptExecute.cpp
type ng (line 5) | namespace ng {
function SoundDefinition (line 60) | SoundDefinition *DefaultScriptExecute::getSoundDefinition(const std::s...
FILE: src/Scripting/DefaultScriptExecute.hpp
type ng (line 5) | namespace ng {
class DefaultScriptExecute (line 6) | class DefaultScriptExecute final : public ScriptExecute {
method DefaultScriptExecute (line 8) | explicit DefaultScriptExecute(HSQUIRRELVM vm) : m_vm(vm) {}
FILE: src/Scripting/DefaultVerbExecute.cpp
type ng (line 12) | namespace ng {
FILE: src/Scripting/DefaultVerbExecute.hpp
type ng (line 4) | namespace ng {
class Engine (line 5) | class Engine
class Entity (line 6) | class Entity
class DefaultVerbExecute (line 8) | class DefaultVerbExecute final : public VerbExecute {
FILE: src/Scripting/GeneralPack.hpp
type ng (line 12) | namespace ng {
class GeneralPack (line 13) | class GeneralPack final : public Pack {
method registerPack (line 19) | void registerPack() const override {
method SQInteger (line 67) | static SQInteger activeVerb(HSQUIRRELVM v) {
method _shuffle (line 78) | static void _shuffle(SQArray &array) {
method SQInteger (line 88) | static SQInteger arrayShuffle(HSQUIRRELVM v) {
method SQInteger (line 104) | static SQInteger assetExists(HSQUIRRELVM v) {
method SQInteger (line 113) | static SQInteger distance(HSQUIRRELVM v) {
method SQInteger (line 144) | static SQInteger findScreenPosition(HSQUIRRELVM v) {
method SQInteger (line 177) | static SQInteger frameCounter(HSQUIRRELVM v) {
method SQInteger (line 182) | static SQInteger in_array(HSQUIRRELVM v) {
method SQInteger (line 221) | static SQInteger incutscene(HSQUIRRELVM v) {
method SQInteger (line 226) | static SQInteger indialog(HSQUIRRELVM v) {
method SQInteger (line 231) | static SQInteger integer(HSQUIRRELVM v) {
method SQInteger (line 240) | static SQInteger is_array(HSQUIRRELVM v) {
method SQInteger (line 245) | static SQInteger is_function(HSQUIRRELVM v) {
method SQInteger (line 251) | static SQInteger loadArray(HSQUIRRELVM v) {
method SQInteger (line 277) | static SQInteger strsplit(HSQUIRRELVM v) {
method SQInteger (line 298) | static SQInteger cameraAt(HSQUIRRELVM v) {
method SQInteger (line 326) | static SQInteger cameraBounds(HSQUIRRELVM v) {
method SQInteger (line 344) | static SQInteger cameraFollow(HSQUIRRELVM v) {
method _cameraPanTo (line 350) | static void _cameraPanTo(glm::ivec2 pos, float timeInSeconds, int in...
method SQInteger (line 355) | static SQInteger cameraPanTo(HSQUIRRELVM v) {
method SQInteger (line 404) | static SQInteger cameraPos(HSQUIRRELVM v) {
method SQInteger (line 410) | static SQInteger cutscene(HSQUIRRELVM v) {
method SQInteger (line 450) | static SQInteger cutsceneOverride(HSQUIRRELVM) {
method SQInteger (line 455) | static SQInteger random(HSQUIRRELVM v) {
method SQInteger (line 476) | static SQInteger randomOdds(HSQUIRRELVM v) {
method SQInteger (line 487) | static SQInteger randomseed(HSQUIRRELVM v) {
method SQInteger (line 511) | static SQInteger randomFrom(HSQUIRRELVM v) {
method SQInteger (line 539) | static SQInteger refreshUI(HSQUIRRELVM) {
method SQInteger (line 544) | static SQInteger cameraInRoom(HSQUIRRELVM v) {
method SQInteger (line 556) | static SQInteger markAchievement(HSQUIRRELVM v) {
method SQInteger (line 582) | static SQInteger markProgress(HSQUIRRELVM) {
method SQInteger (line 587) | static SQInteger markStat(HSQUIRRELVM) {
method SQInteger (line 592) | static SQInteger screenSize(HSQUIRRELVM v) {
method SQInteger (line 598) | static SQInteger setVerb(HSQUIRRELVM v) {
method SQInteger (line 697) | static SQInteger startDialog(HSQUIRRELVM v) {
method SQInteger (line 711) | static SQInteger stopSentence(HSQUIRRELVM) {
method SQInteger (line 716) | static SQInteger strcount(HSQUIRRELVM v) {
method init_crc32 (line 734) | static void init_crc32() {
method crc32_update (line 743) | static unsigned int crc32_update(unsigned int x, char c) {
method SQInteger (line 747) | static SQInteger strcrc(HSQUIRRELVM v) {
method SQInteger (line 758) | static SQInteger strfind(HSQUIRRELVM v) {
method SQInteger (line 776) | static SQInteger strfirst(HSQUIRRELVM v) {
method SQInteger (line 790) | static SQInteger strlast(HSQUIRRELVM v) {
method SQInteger (line 805) | static SQInteger strlines(HSQUIRRELVM v) {
method SQInteger (line 820) | static SQInteger strreplace(HSQUIRRELVM v) {
method SQInteger (line 841) | static SQInteger translate(HSQUIRRELVM v) {
FILE: src/Scripting/ObjectPack.hpp
type ng (line 6) | namespace ng {
class ObjectPack (line 7) | class ObjectPack final : public Pack {
method registerPack (line 12) | void registerPack() const override {
method SQInteger (line 71) | static SQInteger findObjectAt(HSQUIRRELVM v) {
method SQInteger (line 101) | static SQInteger isInventoryOnScreen(HSQUIRRELVM v) {
method SQInteger (line 124) | static SQInteger isObject(HSQUIRRELVM v) {
method SQInteger (line 130) | static SQInteger jiggleInventory(HSQUIRRELVM v) {
method SQInteger (line 143) | static SQInteger jiggleObject(HSQUIRRELVM v) {
method SQInteger (line 159) | static SQInteger scale(HSQUIRRELVM v) {
method SQInteger (line 172) | static SQInteger objectAlpha(HSQUIRRELVM v) {
method SQInteger (line 190) | static SQInteger objectAlphaTo(HSQUIRRELVM v) {
method SQInteger (line 216) | static SQInteger objectBumperCycle(HSQUIRRELVM v) {
method SQInteger (line 229) | static SQInteger objectHotspot(HSQUIRRELVM v) {
method SQInteger (line 279) | static SQInteger objectOffset(HSQUIRRELVM v) {
method SQInteger (line 296) | static SQInteger objectScreenSpace(HSQUIRRELVM v) {
method SQInteger (line 309) | static SQInteger objectState(HSQUIRRELVM v) {
method SQInteger (line 329) | static SQInteger objectOffsetTo(HSQUIRRELVM v) {
method SQInteger (line 354) | static SQInteger objectMoveTo(HSQUIRRELVM v) {
method SQInteger (line 379) | static SQInteger loopObjectState(HSQUIRRELVM v) {
method SQInteger (line 392) | static SQInteger playObjectState(HSQUIRRELVM v) {
method SQInteger (line 419) | static SQInteger popInventory(HSQUIRRELVM v) {
method SQInteger (line 434) | static SQInteger removeInventory(HSQUIRRELVM v) {
method SQInteger (line 452) | static SQInteger objectAt(HSQUIRRELVM v) {
method SQInteger (line 480) | static SQInteger objectScale(HSQUIRRELVM v) {
method SQInteger (line 493) | static SQInteger objectScaleTo(HSQUIRRELVM v) {
method SQInteger (line 514) | static SQInteger objectPosX(HSQUIRRELVM v) {
method SQInteger (line 526) | static SQInteger objectPosY(HSQUIRRELVM v) {
method SQInteger (line 539) | static SQInteger objectRenderOffset(HSQUIRRELVM v) {
method SQInteger (line 556) | static SQInteger objectRoom(HSQUIRRELVM v) {
method SQInteger (line 570) | static SQInteger objectSort(HSQUIRRELVM v) {
method SQInteger (line 583) | static SQInteger objectRotate(HSQUIRRELVM v) {
method SQInteger (line 596) | static SQInteger objectRotateTo(HSQUIRRELVM v) {
method SQInteger (line 617) | static SQInteger objectParallaxLayer(HSQUIRRELVM v) {
method SQInteger (line 630) | static SQInteger objectParent(HSQUIRRELVM v) {
method SQInteger (line 643) | static SQInteger objectTouchable(HSQUIRRELVM v) {
method SQInteger (line 662) | static SQInteger objectLit(HSQUIRRELVM v) {
method SQInteger (line 675) | static SQInteger objectOwner(HSQUIRRELVM v) {
method SQInteger (line 691) | static SQInteger objectUsePos(HSQUIRRELVM v) {
method SQInteger (line 711) | static SQInteger objectUsePosX(HSQUIRRELVM v) {
method SQInteger (line 721) | static SQInteger objectUsePosY(HSQUIRRELVM v) {
method SQInteger (line 731) | static SQInteger objectCenter(HSQUIRRELVM v) {
method SQInteger (line 750) | static SQInteger objectColor(HSQUIRRELVM v) {
method SQInteger (line 763) | static SQInteger objectDependentOn(HSQUIRRELVM v) {
method SQInteger (line 780) | static SQInteger objectIcon(HSQUIRRELVM v) {
method SQInteger (line 816) | static SQInteger objectFPS(HSQUIRRELVM v) {
method SQInteger (line 829) | static SQInteger objectValidUsePos(HSQUIRRELVM v) {
method SQInteger (line 838) | static SQInteger objectValidVerb(HSQUIRRELVM v) {
method SQInteger (line 859) | static SQInteger objectShader(HSQUIRRELVM) {
method SQInteger (line 864) | static SQInteger objectHidden(HSQUIRRELVM v) {
method SQInteger (line 877) | static SQInteger pickupObject(HSQUIRRELVM v) {
method SQInteger (line 912) | static SQInteger pickupReplacementObject(HSQUIRRELVM v) {
method SQInteger (line 927) | static SQInteger createTextObject(HSQUIRRELVM v) {
method SQInteger (line 980) | static SQInteger setDefaultObject(HSQUIRRELVM v) {
method SQInteger (line 987) | static SQInteger shakeObject(HSQUIRRELVM v) {
method SQInteger (line 1003) | static SQInteger stopObjectMotors(HSQUIRRELVM v) {
method SQInteger (line 1012) | static SQInteger deleteObject(HSQUIRRELVM v) {
method _getArray (line 1022) | static void _getArray(HSQUIRRELVM v, SQInteger index, std::vector<st...
method SQInteger (line 1034) | static SQInteger createObject(HSQUIRRELVM v) {
FILE: src/Scripting/PostWalk.cpp
type ng (line 6) | namespace ng {
FILE: src/Scripting/PostWalk.hpp
type ng (line 4) | namespace ng {
class Entity (line 5) | class Entity
class Sentence (line 6) | class Sentence
class PostWalk (line 8) | class PostWalk final : public Function {
FILE: src/Scripting/ReachAnim.cpp
type ng (line 6) | namespace ng {
FILE: src/Scripting/ReachAnim.hpp
type ng (line 6) | namespace ng {
class Actor (line 7) | class Actor
class Entity (line 8) | class Entity
class ReachAnim (line 10) | class ReachAnim final : public Function {
FILE: src/Scripting/RoomPack.hpp
type ng (line 11) | namespace ng {
class ChangeColor (line 12) | class ChangeColor final : public TimeFunction {
method ChangeColor (line 14) | ChangeColor(Room *pRoom,
method isElapsed (line 43) | bool isElapsed() override {
method onElapsed (line 49) | void onElapsed() override {
method plusColor (line 54) | [[nodiscard]] ngf::Color plusColor(const ngf::Color &color1, float f...
class RoomPack (line 72) | class RoomPack final : public Pack {
method registerPack (line 77) | void registerPack() const override {
method SQInteger (line 107) | static SQInteger createLight(HSQUIRRELVM v) {
method SQInteger (line 129) | static SQInteger lightBrightness(HSQUIRRELVM v) {
method SQInteger (line 145) | static SQInteger lightConeDirection(HSQUIRRELVM v) {
method SQInteger (line 161) | static SQInteger lightConeAngle(HSQUIRRELVM v) {
method SQInteger (line 177) | static SQInteger lightConeFalloff(HSQUIRRELVM v) {
method SQInteger (line 193) | static SQInteger lightCutOffRadius(HSQUIRRELVM v) {
method SQInteger (line 209) | static SQInteger lightHalfRadius(HSQUIRRELVM v) {
method SQInteger (line 225) | static SQInteger lightTurnOn(HSQUIRRELVM v) {
method SQInteger (line 241) | static SQInteger lightZRange(HSQUIRRELVM v) {
method SQInteger (line 260) | static SQInteger masterRoomArray(HSQUIRRELVM v) {
method SQInteger (line 269) | static SQInteger roomRotateTo(HSQUIRRELVM v) {
method SQInteger (line 283) | static SQInteger roomSize(HSQUIRRELVM v) {
method SQInteger (line 293) | static SQInteger addTrigger(HSQUIRRELVM v) {
method SQInteger (line 318) | static SQInteger clampInWalkbox(HSQUIRRELVM v) {
method SQInteger (line 369) | static SQInteger enableTrigger(HSQUIRRELVM v) {
method SQInteger (line 382) | static SQInteger enterRoomFromDoor(HSQUIRRELVM v) {
method SQInteger (line 387) | static SQInteger roomEffect(HSQUIRRELVM v) {
method SQInteger (line 417) | static SQInteger findRoom(HSQUIRRELVM v) {
method SQInteger (line 433) | static SQInteger walkboxHidden(HSQUIRRELVM v) {
method SQInteger (line 444) | static SQInteger removeTrigger(HSQUIRRELVM v) {
method SQInteger (line 475) | static SQInteger roomActors(HSQUIRRELVM v) {
method SQInteger (line 490) | static SQInteger roomFade(HSQUIRRELVM v) {
method SQInteger (line 519) | static SQInteger roomOverlayColor(HSQUIRRELVM v) {
method SQInteger (line 547) | static SQInteger _defineRoom(HSQUIRRELVM v, HSQOBJECT roomTable, con...
method SQInteger (line 555) | static SQInteger defineRoom(HSQUIRRELVM v) {
method SQInteger (line 563) | static SQInteger definePseudoRoom(HSQUIRRELVM v) {
method SQInteger (line 579) | static SQInteger roomLayer(HSQUIRRELVM v) {
FILE: src/Scripting/ScriptEngine.cpp
type ng (line 37) | namespace ng {
type Platform (line 65) | enum class Platform : int {
function Platform (line 76) | static Platform _getPlatform() {
function Engine (line 270) | Engine &ScriptEngine::getEngine() { return *g_pEngine; }
function SQInteger (line 272) | SQInteger ScriptEngine::aux_printerror(HSQUIRRELVM v) {
function SQObjectPtr (line 433) | SQObjectPtr ScriptEngine::toSquirrel(const std::string &value) {
FILE: src/Scripting/SetDefaultVerb.cpp
type ng (line 4) | namespace ng {
FILE: src/Scripting/SetDefaultVerb.hpp
type ng (line 4) | namespace ng {
class Engine (line 5) | class Engine
class SetDefaultVerb (line 7) | class SetDefaultVerb final : public Function {
FILE: src/Scripting/SoundPack.hpp
type ng (line 7) | namespace ng {
class SoundPack (line 8) | class SoundPack final : public Pack {
method registerPack (line 13) | void registerPack() const override {
method _getArray (line 36) | static bool _getArray(HSQUIRRELVM v,
method _getArray (line 49) | static bool _getArray(HSQUIRRELVM v, SQInteger index, std::vector<st...
method SQInteger (line 69) | static SQInteger actorSound(HSQUIRRELVM v) {
method SQInteger (line 102) | static SQInteger loopMusic(HSQUIRRELVM v) {
method SQInteger (line 112) | static SQInteger masterSoundVolume(HSQUIRRELVM v) {
method SQInteger (line 121) | static SQInteger defineSound(HSQUIRRELVM v) {
method SQInteger (line 131) | static SQInteger loopObjectSound(HSQUIRRELVM v) {
method SQInteger (line 154) | static SQInteger loadSound(HSQUIRRELVM v) {
method SQInteger (line 163) | static SQInteger loopSound(HSQUIRRELVM v) {
method SQInteger (line 177) | static SQInteger fadeOutSound(HSQUIRRELVM v) {
method SQInteger (line 204) | static SQInteger isSoundPlaying(HSQUIRRELVM v) {
method SQInteger (line 227) | static SQInteger playObjectSound(HSQUIRRELVM v) {
method SQInteger (line 246) | static SQInteger playMusic(HSQUIRRELVM v) {
method SQInteger (line 257) | static SQInteger playSound(HSQUIRRELVM v) {
method SQInteger (line 268) | static SQInteger playSoundVolume(HSQUIRRELVM v) {
method SQInteger (line 285) | static SQInteger soundMixVolume(HSQUIRRELVM v) {
method SQInteger (line 294) | static SQInteger musicMixVolume(HSQUIRRELVM v) {
method SQInteger (line 303) | static SQInteger talkieMixVolume(HSQUIRRELVM v) {
method SQInteger (line 312) | static SQInteger soundVolume(HSQUIRRELVM v) {
method SQInteger (line 329) | static SQInteger stopAllSounds(HSQUIRRELVM) {
method SQInteger (line 334) | static SQInteger stopSound(HSQUIRRELVM v) {
FILE: src/Scripting/SystemPack.hpp
type ng (line 26) | namespace ng {
class BreakFunction (line 27) | class BreakFunction : public Function {
method BreakFunction (line 34) | explicit BreakFunction(Engine &engine, int id)
method getName (line 38) | [[nodiscard]] virtual std::string getName() const {
class BreakHereFunction (line 57) | class BreakHereFunction final : public BreakFunction {
method BreakHereFunction (line 59) | explicit BreakHereFunction(Engine &engine, int id, int numFrames)
method isElapsed (line 63) | bool isElapsed() override {
method getName (line 67) | [[nodiscard]] std::string getName() const override {
class BreakWhileAnimatingFunction (line 76) | class BreakWhileAnimatingFunction final : public BreakFunction {
method BreakWhileAnimatingFunction (line 83) | BreakWhileAnimatingFunction(Engine &engine, int id, Actor &actor)
method getName (line 88) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 92) | bool isElapsed() override {
class BreakWhileAnimatingObjectFunction (line 98) | class BreakWhileAnimatingObjectFunction final : public BreakFunction {
method BreakWhileAnimatingObjectFunction (line 104) | BreakWhileAnimatingObjectFunction(Engine &engine, int id, Object &ob...
method getName (line 108) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 112) | bool isElapsed() override {
class BreakWhileWalkingFunction (line 117) | class BreakWhileWalkingFunction final : public BreakFunction {
method BreakWhileWalkingFunction (line 122) | explicit BreakWhileWalkingFunction(Engine &engine, int id, Actor &ac...
method getName (line 126) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 130) | bool isElapsed() override {
class BreakWhileTalkingFunction (line 135) | class BreakWhileTalkingFunction final : public BreakFunction {
method BreakWhileTalkingFunction (line 140) | explicit BreakWhileTalkingFunction(Engine &engine, int id, Entity &e...
method getName (line 144) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 148) | bool isElapsed() override {
class BreakWhileAnyActorTalkingFunction (line 153) | class BreakWhileAnyActorTalkingFunction final : public BreakFunction {
method BreakWhileAnyActorTalkingFunction (line 155) | explicit BreakWhileAnyActorTalkingFunction(Engine &engine, int id)
method getName (line 159) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 163) | bool isElapsed() override {
class BreakWhileSoundFunction (line 172) | class BreakWhileSoundFunction final : public BreakFunction {
method BreakWhileSoundFunction (line 177) | BreakWhileSoundFunction(Engine &engine, int id, int soundId)
method getName (line 181) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 185) | bool isElapsed() override {
class BreakWhileRunningFunction (line 191) | class BreakWhileRunningFunction final : public Function {
method BreakWhileRunningFunction (line 197) | BreakWhileRunningFunction(int currentThreadId, int threadId)
method isElapsed (line 215) | bool isElapsed() override {
class BreakWhileDialogFunction (line 220) | class BreakWhileDialogFunction final : public BreakFunction {
method BreakWhileDialogFunction (line 222) | BreakWhileDialogFunction(Engine &engine, int id)
method getName (line 226) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 230) | bool isElapsed() override {
class BreakWhileCutsceneFunction (line 235) | class BreakWhileCutsceneFunction final : public BreakFunction {
method BreakWhileCutsceneFunction (line 237) | BreakWhileCutsceneFunction(Engine &engine, int id)
method getName (line 241) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 245) | bool isElapsed() override {
class BreakWhileCameraFunction (line 250) | class BreakWhileCameraFunction final : public BreakFunction {
method BreakWhileCameraFunction (line 252) | BreakWhileCameraFunction(Engine &engine, int id)
method getName (line 256) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 260) | bool isElapsed() override {
class BreakWhileInputOffFunction (line 265) | class BreakWhileInputOffFunction final : public BreakFunction {
method BreakWhileInputOffFunction (line 267) | BreakWhileInputOffFunction(Engine &engine, int id)
method getName (line 271) | [[nodiscard]] std::string getName() const override {
method isElapsed (line 275) | bool isElapsed() override {
class BreakTimeFunction (line 280) | class BreakTimeFunction final : public TimeFunction {
method BreakTimeFunction (line 285) | BreakTimeFunction(int id, const ngf::TimeSpan &time)
class SystemPack (line 303) | class SystemPack final : public Pack {
method registerPack (line 308) | void registerPack() const override {
method SQInteger (line 362) | static SQInteger activeController(HSQUIRRELVM v) {
method SQInteger (line 369) | static SQInteger addCallback(HSQUIRRELVM v) {
method SQInteger (line 402) | static SQInteger addFolder(HSQUIRRELVM) {
method SQInteger (line 407) | static SQInteger breakhere(HSQUIRRELVM v) {
method SQInteger (line 419) | static SQInteger breakwhileanimating(HSQUIRRELVM v) {
method SQInteger (line 444) | static SQInteger breakwhilecamera(HSQUIRRELVM v) {
method SQInteger (line 452) | static SQInteger breakwhilecutscene(HSQUIRRELVM v) {
method SQInteger (line 460) | static SQInteger breakwhileinputoff(HSQUIRRELVM v) {
method SQInteger (line 468) | static SQInteger breakwhilesound(HSQUIRRELVM v) {
method SQInteger (line 479) | static SQInteger breakwhiledialog(HSQUIRRELVM v) {
method SQInteger (line 487) | static SQInteger breakwhilewalking(HSQUIRRELVM v) {
method SQInteger (line 500) | static SQInteger breakwhiletalking(HSQUIRRELVM v) {
method SQInteger (line 520) | static SQInteger breakwhilerunning(HSQUIRRELVM v) {
method SQInteger (line 543) | static SQInteger chr(HSQUIRRELVM v) {
method SQInteger (line 554) | static SQInteger cursorPosX(HSQUIRRELVM v) {
method SQInteger (line 562) | static SQInteger cursorPosY(HSQUIRRELVM v) {
method SQInteger (line 571) | static SQInteger dumpvar(HSQUIRRELVM v) {
method SQInteger (line 610) | static SQInteger dumprt(HSQUIRRELVM v) {
method SQInteger (line 624) | static SQInteger exCommand(HSQUIRRELVM v) {
method SQInteger (line 702) | static SQInteger gameTime(HSQUIRRELVM v) {
method SQInteger (line 707) | static SQInteger logEvent(HSQUIRRELVM v) {
method SQInteger (line 721) | static SQInteger logInfo(HSQUIRRELVM v) {
method SQInteger (line 729) | static SQInteger logWarning(HSQUIRRELVM v) {
method SQInteger (line 737) | static SQInteger microTime(HSQUIRRELVM v) {
method SQInteger (line 742) | static SQInteger moveCursorTo(HSQUIRRELVM v) {
method SQInteger (line 763) | static SQInteger pushSentence(HSQUIRRELVM v) {
method SQInteger (line 797) | static SQInteger stopthread(HSQUIRRELVM v) {
method SQInteger (line 824) | static SQInteger startglobalthread(HSQUIRRELVM v) {
method SQInteger (line 828) | static SQInteger startthread(HSQUIRRELVM v) {
method SQInteger (line 832) | static SQInteger startthread(HSQUIRRELVM v, bool global) {
method SQInteger (line 895) | static SQInteger breaktime(HSQUIRRELVM v) {
method SQInteger (line 912) | static SQInteger setPrivatePref(HSQUIRRELVM v) {
method HSQOBJECT (line 947) | static HSQOBJECT toSquirrel(HSQUIRRELVM v, const ngf::GGPackValue &v...
method SQInteger (line 965) | static SQInteger getPrivatePref(HSQUIRRELVM v) {
method SQInteger (line 989) | static SQInteger getUserPref(HSQUIRRELVM v) {
method SQInteger (line 994) | static SQInteger _getPref(HSQUIRRELVM v,
method SQInteger (line 1038) | static SQInteger removeCallback(HSQUIRRELVM v) {
method SQInteger (line 1047) | static SQInteger setAmbientLight(HSQUIRRELVM v) {
method SQInteger (line 1057) | static SQInteger setUserPref(HSQUIRRELVM v) {
method SQInteger (line 1064) | static SQInteger _setPref(HSQUIRRELVM v,
method SQInteger (line 1103) | static SQInteger include(HSQUIRRELVM v) {
method SQInteger (line 1113) | static SQInteger inputHUD(HSQUIRRELVM v) {
method SQInteger (line 1122) | static SQInteger inputOff(HSQUIRRELVM) {
method SQInteger (line 1127) | static SQInteger inputOn(HSQUIRRELVM) {
method SQInteger (line 1132) | static SQInteger inputSilentOff(HSQUIRRELVM) {
method SQInteger (line 1137) | static SQInteger isInputOn(HSQUIRRELVM v) {
method SQInteger (line 1143) | static SQInteger inputState(HSQUIRRELVM v) {
method SQInteger (line 1161) | static SQInteger inputController(HSQUIRRELVM) {
method SQInteger (line 1166) | static SQInteger inputVerbs(HSQUIRRELVM v) {
method SQInteger (line 1175) | static SQInteger is_table(HSQUIRRELVM v) {
method SQInteger (line 1180) | static SQInteger ord(HSQUIRRELVM v) {
method SQInteger (line 1189) | static SQInteger is_string(HSQUIRRELVM v) {
method SQInteger (line 1194) | static SQInteger threadid(HSQUIRRELVM v) {
method SQInteger (line 1200) | static SQInteger threadpauseable(HSQUIRRELVM v) {
FILE: src/Scripting/VerbExecuteFunction.cpp
type ng (line 7) | namespace ng {
FILE: src/Scripting/VerbExecuteFunction.hpp
type ng (line 5) | namespace ng {
class Actor (line 6) | class Actor
class Engine (line 7) | class Engine
class Entity (line 8) | class Entity
type Verb (line 9) | struct Verb
class VerbExecuteFunction (line 11) | class VerbExecuteFunction : public Function {
FILE: src/System/DebugTools/ActorTools.cpp
type ng (line 10) | namespace ng {
function Facing (line 300) | Facing ActorTools::intToFacing(int facing) {
function UseDirection (line 320) | UseDirection ActorTools::intToDirection(int dir) {
FILE: src/System/DebugTools/ActorTools.hpp
type ng (line 8) | namespace ng {
class Actor (line 9) | class Actor
class Engine (line 10) | class Engine
class ActorTools (line 12) | class ActorTools final {
FILE: src/System/DebugTools/CameraTools.cpp
type ng (line 6) | namespace ng {
FILE: src/System/DebugTools/CameraTools.hpp
type ng (line 4) | namespace ng {
class Engine (line 5) | class Engine
class CameraTools (line 7) | class CameraTools final {
FILE: src/System/DebugTools/Console.cpp
type ng (line 8) | namespace ng {
FILE: src/System/DebugTools/Console.hpp
type ng (line 4) | namespace ng {
class Engine (line 5) | class Engine
type Console (line 7) | struct Console {
FILE: src/System/DebugTools/ConsoleTools.cpp
type ng (line 4) | namespace ng {
FILE: src/System/DebugTools/ConsoleTools.hpp
type ng (line 4) | namespace ng {
class Engine (line 5) | class Engine
class ConsoleTools (line 7) | class ConsoleTools final {
FILE: src/System/DebugTools/DebugControls.cpp
type ng (line 9) | namespace ng {
FILE: src/System/DebugTools/DebugControls.hpp
type ng (line 4) | namespace ng {
class DebugControls (line 5) | class DebugControls final {
FILE: src/System/DebugTools/DebugTools.cpp
type ng (line 16) | namespace ng {
FILE: src/System/DebugTools/DebugTools.hpp
type ng (line 16) | namespace ng {
class Engine (line 17) | class Engine
class DebugTools (line 19) | class DebugTools final {
type Plot (line 26) | struct Plot {
FILE: src/System/DebugTools/GeneralTools.cpp
type ng (line 18) | namespace ng {
FILE: src/System/DebugTools/GeneralTools.hpp
type ng (line 5) | namespace ng {
class Engine (line 6) | class Engine
class GeneralTools (line 8) | class GeneralTools final {
FILE: src/System/DebugTools/ObjectTools.cpp
type ng (line 13) | namespace ng {
function getName (line 15) | std::string getName(Object *object) {
function getType (line 32) | std::string getType(Object *object) {
function showHorizontalTextAlignment (line 42) | bool showHorizontalTextAlignment(TextAlignment *alignment) {
function showVerticalTextAlignment (line 64) | bool showVerticalTextAlignment(TextAlignment *alignment) {
FILE: src/System/DebugTools/ObjectTools.hpp
type ng (line 4) | namespace ng {
type Animation (line 5) | struct Animation
class Engine (line 6) | class Engine
class Object (line 7) | class Object
class ObjectTools (line 9) | class ObjectTools final {
FILE: src/System/DebugTools/PreferencesTools.cpp
type ng (line 7) | namespace ng {
FILE: src/System/DebugTools/PreferencesTools.hpp
type ng (line 3) | namespace ng {
class Engine (line 4) | class Engine
class PreferencesTools (line 6) | class PreferencesTools final {
FILE: src/System/DebugTools/RoomTools.cpp
type ng (line 10) | namespace ng {
FILE: src/System/DebugTools/RoomTools.hpp
type ng (line 5) | namespace ng {
class Engine (line 6) | class Engine
class Room (line 7) | class Room
class RoomTools (line 9) | class RoomTools final {
FILE: src/System/DebugTools/SoundTools.cpp
type ng (line 7) | namespace ng {
function getName (line 9) | std::string getName(SoundId *soundId) {
function getLoopTimes (line 16) | std::string getLoopTimes(SoundId *soundId) {
function getCategory (line 25) | std::string getCategory(SoundId *soundId) {
function getCategoryColor (line 37) | ngf::Color getCategoryColor(SoundId *soundId) {
function getStatus (line 48) | std::string getStatus(SoundId *soundId) {
FILE: src/System/DebugTools/SoundTools.hpp
type ng (line 3) | namespace ng {
class Engine (line 4) | class Engine
class SoundTools (line 6) | class SoundTools final {
FILE: src/System/DebugTools/TextureTools.cpp
type ng (line 6) | namespace ng {
FILE: src/System/DebugTools/TextureTools.hpp
type ng (line 4) | namespace ng {
class TextureTools (line 5) | class TextureTools final {
FILE: src/System/DebugTools/ThreadTools.cpp
type ng (line 7) | namespace ng {
function getType (line 9) | std::string getType(ThreadBase *thread) {
function getState (line 13) | std::string getState(ThreadBase *thread) {
function showControls (line 21) | void showControls(ThreadBase *thread) {
FILE: src/System/DebugTools/ThreadTools.hpp
type ng (line 3) | namespace ng {
class Engine (line 4) | class Engine
class ThreadTools (line 6) | class ThreadTools final {
FILE: src/System/Logger.cpp
type ng (line 7) | namespace ng {
FILE: src/UI/Button.cpp
type ng (line 11) | namespace ng {
FILE: src/UI/Button.hpp
type ng (line 9) | namespace ng {
class Engine (line 10) | class Engine
class Button (line 12) | class Button final : public Control {
type Size (line 15) | enum class Size { Large, Medium }
FILE: src/UI/Checkbox.cpp
type ng (line 8) | namespace ng {
FILE: src/UI/Checkbox.hpp
type ng (line 8) | namespace ng {
class Engine (line 9) | class Engine
class SpriteSheet (line 10) | class SpriteSheet
class Checkbox (line 12) | class Checkbox final : public Control {
FILE: src/UI/Control.cpp
type ng (line 7) | namespace ng {
FILE: src/UI/Control.hpp
type ng (line 8) | namespace ng {
type ControlState (line 10) | enum class ControlState {
class Engine (line 16) | class Engine
class Control (line 18) | class Control : public ngf::Drawable {
method onClick (line 29) | virtual void onClick() {}
method onStateChanged (line 30) | virtual void onStateChanged() {}
method onEngineSet (line 31) | virtual void onEngineSet() {}
FILE: src/UI/ControlConstants.hpp
type ng (line 5) | namespace ng {
type ControlConstants (line 6) | struct ControlConstants {
FILE: src/UI/HelpDialog.cpp
type ng (line 13) | namespace ng {
class HelpButton (line 15) | class HelpButton final : public Control {
type Size (line 18) | enum class Size { Large, Medium }
method HelpButton (line 20) | HelpButton(int id, glm::vec2 pos = {0, 0}, Callback callback = nullp...
method draw (line 27) | void draw(ngf::RenderTarget &target, ngf::RenderStates states) const...
method update (line 33) | void update(const ngf::TimeSpan &elapsed, glm::vec2 pos) final {
method setCallback (line 38) | void setCallback(Callback callback) { m_callback = callback; }
method setVisible (line 40) | void setVisible(bool visible) { m_isVisible = visible; }
method isVisible (line 41) | bool isVisible() const { return m_isVisible; }
method setPosition (line 43) | void setPosition(const glm::vec2 &pos) { m_pos = pos; }
method getPosition (line 44) | glm::vec2 getPosition() const { return m_pos; }
method setAnchor (line 46) | void setAnchor(ngf::Anchor anchor) {
method contains (line 51) | bool contains(glm::vec2 pos) const final {
method onStateChanged (line 58) | void onStateChanged() final {
method onEngineSet (line 71) | void onEngineSet() final {
method onClick (line 79) | void onClick() final {
type HelpDialog::Impl (line 94) | struct HelpDialog::Impl {
type Ids (line 95) | struct Ids {
method Impl (line 110) | Impl()
method nextPage (line 118) | void nextPage() {
method prevPage (line 122) | void prevPage() {
method init (line 126) | void init(Engine *pEngine, Callback exitCallback, std::initializer_l...
method displayPage (line 147) | void displayPage(int index) {
method draw (line 165) | void draw(ng
Condensed preview — 470 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,284K chars).
[
{
"path": ".gitattributes",
"chars": 66,
"preview": "# Auto detect text files and perform LF normalization\n* text=auto\n"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 621,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the b"
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.md",
"chars": 595,
"preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Is your fea"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 1251,
"preview": "# Pull Request Template\n\n## Description\n\nPlease include a summary of the change and which issue is fixed. Please also in"
},
{
"path": ".github/workflows/Build.yml",
"chars": 4410,
"preview": "name: Build\n\non:\n push:\n pull_request:\n\nenv:\n BUILD_TYPE: Release\n\njobs:\n linux:\n runs-on: ubuntu-20.04\n name:"
},
{
"path": ".gitignore",
"chars": 448,
"preview": "# Prerequisites\n*.d\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic"
},
{
"path": ".gitmodules",
"chars": 95,
"preview": "[submodule \"extlibs/ngf\"]\n\tpath = extlibs/ngf\n\turl = https://github.com/scemino/EnggeFramework\n"
},
{
"path": "CMakeLists.txt",
"chars": 2031,
"preview": "cmake_minimum_required(VERSION 3.5)\n\ninclude(appInfo.cmake)\n\nproject(\"${appName}\" LANGUAGES CXX)\n\n# Compiler flags\nset ("
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3351,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "CONTRIBUTING.md",
"chars": 630,
"preview": "# Contributing\n\nI really appreciate every contribution and suggestion, it can be code, documentation.\nBy the way, if any"
},
{
"path": "LICENSE",
"chars": 1063,
"preview": "MIT License\n\nCopyright (c) 2018 scemino\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "README.MD",
"chars": 2333,
"preview": "# engge\n\n[](https://github.com/scemino/engge/actions"
},
{
"path": "appInfo.cmake",
"chars": 214,
"preview": "set(appName \"engge\")\nset(appVersionMajor 0)\nset(appVersionMinor 8)\nset(appVersionPatch 0)\nset(appVersionSuffix \"beta\")\ns"
},
{
"path": "extlibs/spdlog/include/spdlog/async.h",
"chars": 3332,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/async_logger-inl.h",
"chars": 2668,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/async_logger.h",
"chars": 2252,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/common-inl.h",
"chars": 1385,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/common.h",
"chars": 5867,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/circular_q.h",
"chars": 1551,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/console_globals.h",
"chars": 609,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/file_helper-inl.h",
"chars": 3335,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/file_helper.h",
"chars": 1672,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/fmt_helper.h",
"chars": 3565,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/log_msg-inl.h",
"chars": 867,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/log_msg.h",
"chars": 940,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/mpmc_blocking_q.h",
"chars": 3457,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/null_mutex.h",
"chars": 703,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/os-inl.h",
"chars": 11763,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/os.h",
"chars": 2553,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/pattern_formatter-inl.h",
"chars": 39630,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/pattern_formatter.h",
"chars": 2642,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/periodic_worker-inl.h",
"chars": 1230,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/periodic_worker.h",
"chars": 1118,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/registry-inl.h",
"chars": 7169,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/registry.h",
"chars": 3235,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/synchronous_factory.h",
"chars": 753,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/thread_pool-inl.h",
"chars": 3184,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/details/thread_pool.h",
"chars": 4427,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bin_to_hex.h",
"chars": 4355,
"preview": "//\n// Copyright(c) 2015 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#prag"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/LICENSE.rst",
"chars": 1310,
"preview": "Copyright (c) 2012 - 2016, Victor Zverovich\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, wi"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/chrono.h",
"chars": 13279,
"preview": "// Formatting library for C++ - chrono support\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserv"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/color.h",
"chars": 21968,
"preview": "// Formatting library for C++ - color support\n//\n// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors\n"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/core.h",
"chars": 47459,
"preview": "// Formatting library for C++ - the core API\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/format-inl.h",
"chars": 32309,
"preview": "// Formatting library for C++\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the li"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/format.h",
"chars": 109393,
"preview": "/*\n Formatting library for C++\n\n Copyright (c) 2012 - present, Victor Zverovich\n All rights reserved.\n\n Redistribution a"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/locale.h",
"chars": 2782,
"preview": "// Formatting library for C++ - std::locale support\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights r"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/ostream.h",
"chars": 4771,
"preview": "// Formatting library for C++ - std::ostream support\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights "
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/posix.h",
"chars": 8820,
"preview": "// A C++ interface to POSIX functions.\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// F"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/printf.h",
"chars": 25813,
"preview": "// Formatting library for C++\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the li"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/ranges.h",
"chars": 9069,
"preview": "// Formatting library for C++ - the core API\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/bundled/time.h",
"chars": 4311,
"preview": "// Formatting library for C++ - time formatting\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reser"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/fmt.h",
"chars": 604,
"preview": "//\n// Copyright(c) 2016-2018 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n"
},
{
"path": "extlibs/spdlog/include/spdlog/fmt/ostr.h",
"chars": 371,
"preview": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#prag"
},
{
"path": "extlibs/spdlog/include/spdlog/formatter.h",
"chars": 461,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/logger-inl.h",
"chars": 5777,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/logger.h",
"chars": 10476,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/android_sink.h",
"chars": 3386,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h",
"chars": 4210,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/ansicolor_sink.h",
"chars": 3818,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/base_sink-inl.h",
"chars": 1782,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/base_sink.h",
"chars": 1423,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/basic_file_sink-inl.h",
"chars": 1026,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/basic_file_sink.h",
"chars": 1643,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/daily_file_sink.h",
"chars": 4467,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/dist_sink.h",
"chars": 2237,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/dup_filter_sink.h",
"chars": 2969,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/msvc_sink.h",
"chars": 988,
"preview": "// Copyright(c) 2016 Alexander Dalshov.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#prag"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/null_sink.h",
"chars": 1229,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/ostream_sink.h",
"chars": 1256,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h",
"chars": 4162,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/rotating_file_sink.h",
"chars": 2455,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/sink-inl.h",
"chars": 721,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/sink.h",
"chars": 876,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h",
"chars": 1209,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/stdout_color_sinks.h",
"chars": 1614,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/stdout_sinks-inl.h",
"chars": 2753,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/stdout_sinks.h",
"chars": 2168,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/syslog_sink.h",
"chars": 3605,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/systemd_sink.h",
"chars": 3070,
"preview": "// Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com\n// Distributed under the MIT License (http://opensource.org/licenses/MI"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/wincolor_sink-inl.h",
"chars": 5804,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/sinks/wincolor_sink.h",
"chars": 3016,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/spdlog-inl.h",
"chars": 2580,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/spdlog.h",
"chars": 10461,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/tweakme.h",
"chars": 6200,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/include/spdlog/version.h",
"chars": 330,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/spdlog/src/spdlog.cpp",
"chars": 7533,
"preview": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource"
},
{
"path": "extlibs/squirrel/.gitignore",
"chars": 101,
"preview": "# Folders created at compilation\nbin/\nlib/\n\n# Folders created at documentation generation\ndoc/build/\n"
},
{
"path": "extlibs/squirrel/.travis.yml",
"chars": 337,
"preview": "language: cpp\ncompiler:\n - gcc\n - clang\n\n# Travis VMs are 64-bit but we compile both for 32 and 64 bit. To enable the\n"
},
{
"path": "extlibs/squirrel/CMakeLists.txt",
"chars": 2116,
"preview": "if(MSVC)\n cmake_minimum_required(VERSION 3.4)\nelse()\n cmake_minimum_required(VERSION 2.8)\nendif()\n\noption(DISABLE_STAT"
},
{
"path": "extlibs/squirrel/COMPILE",
"chars": 2664,
"preview": "Squirrel 3.1 stable\n--------------------------------------------------------\nWhat is in this distribution?\n\nsquirrel\n "
},
{
"path": "extlibs/squirrel/COPYRIGHT",
"chars": 1138,
"preview": "Copyright (c) 2003-2017 Alberto Demichelis\n\nPermission is hereby granted, free of charge, to any person obtaining a copy"
},
{
"path": "extlibs/squirrel/HISTORY",
"chars": 22249,
"preview": "***version 3.1.1 stable***\n-sq_gettypetag doesn't set last error(it's treated as SQBool function but keeps a SQRESULT fo"
},
{
"path": "extlibs/squirrel/Makefile",
"chars": 323,
"preview": "\nSQUIRREL=.\nMAKE=make\n\nsq32: folders\n\tcd squirrel; $(MAKE)\n\tcd sqstdlib; $(MAKE)\n\tcd sq; $(MAKE)\n\nsqprof: folders\n\tcd sq"
},
{
"path": "extlibs/squirrel/README",
"chars": 947,
"preview": "The programming language SQUIRREL 3.1 stable\n\n--------------------------------------------------\nThis project has succes"
},
{
"path": "extlibs/squirrel/appveyor.yml",
"chars": 617,
"preview": "version: 0.0.{build}\n\nplatform:\n - x86\n - x64\n\nconfiguration:\n - Debug\n - Release\n\nclone_folder: c:\\sq\n\nbefore_build:\n -"
},
{
"path": "extlibs/squirrel/doc/Makefile",
"chars": 7693,
"preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHINXBUILD "
},
{
"path": "extlibs/squirrel/doc/make.bat",
"chars": 7474,
"preview": "@ECHO OFF\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n set SPHINXBUILD=sphinx-build\n)\nset "
},
{
"path": "extlibs/squirrel/doc/source/conf.py",
"chars": 9407,
"preview": "# -*- coding: utf-8 -*-\n#\n# Squirrel documentation build configuration file, created by\n# sphinx-quickstart on Sun Jan 3"
},
{
"path": "extlibs/squirrel/doc/source/index.rst",
"chars": 448,
"preview": ".. Squirrel documentation master file, created by\n sphinx-quickstart on Sun Jan 31 00:26:52 2016.\n You can adapt thi"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/bytecode_serialization.rst",
"chars": 1174,
"preview": ".. _api_ref_bytecode_serialization:\n\n======================\nBytecode serialization\n======================\n\n.. _sq_readcl"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/calls.rst",
"chars": 4404,
"preview": ".. _api_ref_calls:\n\n=====\nCalls\n=====\n\n.. _sq_call:\n\n.. c:function:: SQRESULT sq_call(HSQUIRRELVM v, SQInteger params, S"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/compiler.rst",
"chars": 3338,
"preview": ".. _api_ref_compiler:\n\n========\nCompiler\n========\n\n.. _sq_compile:\n\n.. c:function:: SQRESULT sq_compile(HSQUIRRELVM v, H"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/debug_interface.rst",
"chars": 2535,
"preview": ".. _api_ref_debug_interface:\n\n===============\nDebug interface\n===============\n\n.. _sq_getfunctioninfo:\n\n.. c:function:: "
},
{
"path": "extlibs/squirrel/doc/source/reference/api/garbage_collector.rst",
"chars": 862,
"preview": ".. _api_ref_garbage_collector:\n\n=================\nGarbage Collector\n=================\n\n.. _sq_collectgarbage:\n\n.. c:func"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/object_creation_and_handling.rst",
"chars": 21535,
"preview": ".. _api_ref_object_creation_and_handling:\n\n============================\nObject creation and handling\n==================="
},
{
"path": "extlibs/squirrel/doc/source/reference/api/object_manipulation.rst",
"chars": 13977,
"preview": ".. _api_ref_object_manipulation:\n\n====================\nObject manipulation\n====================\n\n.. _sq_arrayappend:\n\n.."
},
{
"path": "extlibs/squirrel/doc/source/reference/api/raw_object_handling.rst",
"chars": 3737,
"preview": ".. _api_ref_raw_object_handling:\n\n===================\nRaw object handling\n===================\n\n.. _sq_addref:\n\n.. c:func"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/stack_operations.rst",
"chars": 2200,
"preview": ".. _api_ref_stack_operations:\n\n================\nStack Operations\n================\n\n.. _sq_cmp:\n\n.. c:function:: SQIntege"
},
{
"path": "extlibs/squirrel/doc/source/reference/api/virtual_machine.rst",
"chars": 8621,
"preview": ".. _api_ref_virtual_machine:\n\n===============\nVirtual Machine\n===============\n\n\n.. _sq_close:\n\n.. c:function:: void sq_c"
},
{
"path": "extlibs/squirrel/doc/source/reference/api_reference.rst",
"chars": 361,
"preview": ".. _api_reference:\n\n\n*************\nAPI Reference\n*************\n\n.. toctree::\n api/virtual_machine.rst\n api/compiler."
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/build_configuration.rst",
"chars": 2027,
"preview": ".. _embedding_build_configuration:\n\n========================\nBuild Configuration\n========================\n\n.. _unicode:\n"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/calling_a_function.rst",
"chars": 878,
"preview": ".. _embedding_calling_a_function:\n\n==================\nCalling a function\n==================\n\nTo call a squirrel function"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/compiling_a_script.rst",
"chars": 1869,
"preview": ".. embedding_compiling_a_script:\n\n==================\nCompiling a script\n==================\n\nYou can compile a Squirrel s"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/creating_a_c_function.rst",
"chars": 3695,
"preview": ".. _embedding_creating_a_c_function:\n\n===================\nCreate a C function\n===================\n\nA native C function m"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/debug_interface.rst",
"chars": 2371,
"preview": ".. _embedding_debug_interface:\n\n===============\nDebug Interface\n===============\n\nThe squirrel VM exposes a very simple d"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/error_conventions.rst",
"chars": 432,
"preview": ".. _embedding_error_convetions:\n\n\n========================\nError Conventions\n========================\n\n.. index::\n si"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/memory_management.rst",
"chars": 1328,
"preview": ".. _embedding_memory_management:\n\n========================\nMemory Management\n========================\n\n.. index:: single"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/references_from_c.rst",
"chars": 875,
"preview": ".. embedding_references_from_c:\n\n========================================================\nMantaining references to Squir"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/runtime_error_handling.rst",
"chars": 749,
"preview": ".. _embedding_runtime_error_handling:\n\n======================\nRuntime error handling\n======================\n\nWhen an exc"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/tables_and_arrays_manipulation.rst",
"chars": 1974,
"preview": ".. _embedding_tables_and_arrays_manipulation:\n\n==============================\nTables and arrays manipulation\n==========="
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/the_registry_table.rst",
"chars": 542,
"preview": ".. _embedding_the_registry_table:\n\n==================\nThe registry table\n==================\n\nThe registry table is an hi"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/the_stack.rst",
"chars": 3856,
"preview": ".. _embedding_the_stack:\n\n\n==========\nThe Stack\n==========\n\nSquirrel exchanges values with the virtual machine through a"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/userdata_and_userpointers.rst",
"chars": 1637,
"preview": ".. _embedding_userdata_and_userpointers:\n\n=========================\nUserdata and UserPointers\n=========================\n"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding/vm_initialization.rst",
"chars": 647,
"preview": ".. _embedding_vm_initialization:\n\n==============================\nVirtual Machine Initialization\n========================"
},
{
"path": "extlibs/squirrel/doc/source/reference/embedding_squirrel.rst",
"chars": 1133,
"preview": ".. _embedding_squirrel:\n\n***************************\n Embedding Squirrel\n***************************\n\n*This section des"
},
{
"path": "extlibs/squirrel/doc/source/reference/index.rst",
"chars": 1312,
"preview": ".. _reference:\n\n#################################\n Squirrel 3.1 Reference Manual\n#################################\n\nCop"
},
{
"path": "extlibs/squirrel/doc/source/reference/introduction.rst",
"chars": 554,
"preview": ".. _introduction:\n\n************\nIntroduction\n************\n\n.. index::\n single: introduction\n\nSquirrel is a high-level"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/arrays.rst",
"chars": 522,
"preview": ".. _arrays:\n\n\n=================\nArrays\n=================\n\n.. index::\n single: Arrays\n\nAn array is a sequence of value"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/builtin_functions.rst",
"chars": 19148,
"preview": ".. _builtin_functions:\n\n\n==================\nBuilt-in Functions\n==================\n\n.. index::\n single: Built-in Funct"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/classes.rst",
"chars": 12407,
"preview": ".. _classes:\n\n\n=================\nClasses\n=================\n\n.. index::\n single: Classes\n\nSquirrel implements a class "
},
{
"path": "extlibs/squirrel/doc/source/reference/language/constants_and_enumerations.rst",
"chars": 3278,
"preview": ".. _constants_and_enumerations:\n\n\n========================\nConstants & Enumerations\n========================\n\n.. index::"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/datatypes.rst",
"chars": 4113,
"preview": ".. _datatypes_and_values:\n\n=====================\nValues and Data types\n=====================\n\nWhile Squirrel is a dynami"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/delegation.rst",
"chars": 879,
"preview": ".. _delegation:\n\n\n========================\nDelegation\n========================\n\n.. index::\n single: Delegation\n\nSquir"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/execution_context.rst",
"chars": 2824,
"preview": ".. _executioncontext:\n\n=======================\nExecution Context\n=======================\n\n.. index::\n single: executi"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/expressions.rst",
"chars": 8527,
"preview": ".. _expressions:\n\n\n=================\nExpressions\n=================\n\n.. index::\n single: Expressions\n\n----------------"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/functions.rst",
"chars": 7411,
"preview": ".. _functions:\n\n\n=================\nFunctions\n=================\n\n.. index::\n single: Functions\n\nFunctions are first cl"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/generators.rst",
"chars": 1608,
"preview": ".. _generators:\n\n\n=================\nGenerators\n=================\n\n.. index::\n single: Generators\n\nA function that con"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/lexical_structure.rst",
"chars": 6468,
"preview": ".. _lexical_structure:\n\n\n=================\nLexical Structure\n=================\n\n.. index:: single: lexical structure\n\n--"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/metamethods.rst",
"chars": 5254,
"preview": ".. _metamethods:\n\n-----------\nMetamethods\n-----------\n\nMetamethods are a mechanism that allows the customization of cert"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/statements.rst",
"chars": 7623,
"preview": ".. _statements:\n\n\n=================\nStatements\n=================\n\n.. index::\n single: statements\n\nA squirrel program "
},
{
"path": "extlibs/squirrel/doc/source/reference/language/tables.rst",
"chars": 1534,
"preview": ".. _tables:\n\n\n=================\nTables\n=================\n\n.. index::\n single: Tables\n\nTables are associative containe"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/threads.rst",
"chars": 3459,
"preview": ".. _threads:\n\n\n========================\nThreads\n========================\n\n.. index::\n single: Threads\n\nSquirrel suppo"
},
{
"path": "extlibs/squirrel/doc/source/reference/language/weak_references.rst",
"chars": 2232,
"preview": ".. _weak_references:\n\n\n========================\nWeak References\n========================\n\n.. index::\n single: Weak Re"
},
{
"path": "extlibs/squirrel/doc/source/reference/language.rst",
"chars": 563,
"preview": ".. _thelanguage:\n\n***************************\n The language\n***************************\n\n.. toctree::\n language/lexic"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/index.rst",
"chars": 1357,
"preview": ".. _stdlib:\n\n#################################\n Squirrel Standard Library 3.1\n#################################\n\nCopyri"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/introduction.rst",
"chars": 835,
"preview": ".. _stdlib_introduction:\n\n============\nIntroduction\n============\n\nThe squirrel standard libraries consist in a set of mo"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/stdauxlib.rst",
"chars": 800,
"preview": ".. _stdlib_stdauxlib:\n\n===============\nThe Aux library\n===============\n\nThe aux library implements default handlers for "
},
{
"path": "extlibs/squirrel/doc/source/stdlib/stdbloblib.rst",
"chars": 8963,
"preview": ".. _stdlib_stdbloblib:\n\n==================\nThe Blob library\n==================\nThe blob library implements binary data m"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/stdiolib.rst",
"chars": 12183,
"preview": ".. _stdlib_stdiolib:\n\n========================\nThe Input/Output library\n========================\n\nthe i/o library implem"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/stdmathlib.rst",
"chars": 2217,
"preview": ".. _stdlib_stdmathlib:\n\n================\nThe Math library\n================\n\nthe math lib provides basic mathematic routi"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/stdstringlib.rst",
"chars": 13973,
"preview": ".. _stdlib_stdstringlib:\n\n==================\nThe String library\n==================\n\nthe string lib implements string for"
},
{
"path": "extlibs/squirrel/doc/source/stdlib/stdsystemlib.rst",
"chars": 2613,
"preview": ".. _stdlib_stdsystemlib:\n\n==================\nThe System library\n==================\n\nThe system library exposes operating"
},
{
"path": "extlibs/squirrel/etc/minimal.c",
"chars": 2069,
"preview": "#include <stdarg.h>\n#include <stdio.h>\n\n#include <squirrel.h>\n#include <sqstdio.h>\n#include <sqstdaux.h>\n\n#ifdef _MSC_VE"
},
{
"path": "extlibs/squirrel/etc/test.nut",
"chars": 84,
"preview": "function foo(i, f, s)\n{\n print(\"Called foo(), i=\"+i+\", f=\"+f+\", s='\"+s+\"'\\n\");\n}\n"
},
{
"path": "extlibs/squirrel/include/sqconfig.h",
"chars": 3251,
"preview": "\n#ifdef _SQ64\n\n#ifdef _MSC_VER\ntypedef __int64 SQInteger;\ntypedef unsigned __int64 SQUnsignedInteger;\ntypedef unsigned _"
},
{
"path": "extlibs/squirrel/include/sqstdaux.h",
"chars": 320,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTD_AUXLIB_H_\n#define _SQSTD_AUXLIB_H_\n\n#ifdef __cplusplus\nextern \""
},
{
"path": "extlibs/squirrel/include/sqstdblob.h",
"chars": 492,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTDBLOB_H_\n#define _SQSTDBLOB_H_\n\n#ifdef __cplusplus\nextern \"C\" {\n#"
},
{
"path": "extlibs/squirrel/include/sqstdio.h",
"chars": 1734,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTDIO_H_\n#define _SQSTDIO_H_\n\n#ifdef __cplusplus\n\n#define SQSTD_STR"
},
{
"path": "extlibs/squirrel/include/sqstdmath.h",
"chars": 261,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTD_MATH_H_\n#define _SQSTD_MATH_H_\n\n#ifdef __cplusplus\nextern \"C\" {"
},
{
"path": "extlibs/squirrel/include/sqstdstring.h",
"chars": 1135,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTD_STRING_H_\n#define _SQSTD_STRING_H_\n\n#ifdef __cplusplus\nextern \""
},
{
"path": "extlibs/squirrel/include/sqstdsystem.h",
"chars": 281,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTD_SYSTEMLIB_H_\n#define _SQSTD_SYSTEMLIB_H_\n\n#ifdef __cplusplus\nex"
},
{
"path": "extlibs/squirrel/include/squirrel.h",
"chars": 18439,
"preview": "/*\nCopyright (c) 2003-2017 Alberto Demichelis\n\nPermission is hereby granted, free of charge, to any person obtaining a c"
},
{
"path": "extlibs/squirrel/samples/ackermann.nut",
"chars": 394,
"preview": "/*\n*\n* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)\n*\n*/\n\nfunction Ack(M, N) {\n "
},
{
"path": "extlibs/squirrel/samples/array.nut",
"chars": 439,
"preview": "/*\n*\n* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)\n*\n*/\nlocal n, i, k;\n\nif(vargv."
},
{
"path": "extlibs/squirrel/samples/class.nut",
"chars": 971,
"preview": "//////////////////////////////////////////////////////////////////////////////////\n/////////////////////////////////////"
},
{
"path": "extlibs/squirrel/samples/classattributes.nut",
"chars": 677,
"preview": "class Foo {\n //constructor\n constructor(a)\n {\n testy = [\"stuff\",1,2,3];\n }\n //attributes of PrintT"
},
{
"path": "extlibs/squirrel/samples/coroutines.nut",
"chars": 635,
"preview": "function coroutine_test(a,b)\n{\n ::print(a+\" \"+b+\"\\n\");\n local ret = ::suspend(\"suspend 1\");\n ::print(\"the corou"
},
{
"path": "extlibs/squirrel/samples/delegation.nut",
"chars": 915,
"preview": "\nPEntity <- {\n name=\"noname\"\n pos={x=0,y=0,z=0}\n type=\"entity\"\n //methamethod\n _typeof=function()\n {\n "
},
{
"path": "extlibs/squirrel/samples/fibonacci.nut",
"chars": 240,
"preview": "/*\n*\n* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)\n*\n*/\n\nfunction fib(n)\n{\n if"
},
{
"path": "extlibs/squirrel/samples/flow.nut",
"chars": 614,
"preview": "function min(x,y)\n return x<y?x:y;\n\nfunction max(x,y)\n return x>y?x:y;\n\nif(min(100,200)>max(50,20))\n print(\"I'm"
},
{
"path": "extlibs/squirrel/samples/generators.nut",
"chars": 721,
"preview": "/*\n*Random number function from The Great Computer Language shootout\n*converted to a generator func\n*/\n\nfunction gen_ran"
},
{
"path": "extlibs/squirrel/samples/hello.nut",
"chars": 22,
"preview": "print(\"Hello World!\")\n"
},
{
"path": "extlibs/squirrel/samples/list.nut",
"chars": 710,
"preview": "/*translation of the list test from The Great Computer Language Shootout\n*/\n\nfunction compare_arr(a1,a2)\n{\n foreach(i"
},
{
"path": "extlibs/squirrel/samples/loops.nut",
"chars": 444,
"preview": "local arr=[\"one\",\"two\",\"three\"]\n\n::print(\"FOREACH\\n\");\n\nforeach(i,val in arr)\n{\n ::print(\"index [\"+i+\"]=\"+val+\"\\n\");\n"
},
{
"path": "extlibs/squirrel/samples/matrix.nut",
"chars": 892,
"preview": "/*\n*\n* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)\n*\n*/\nlocal SIZE=30;\n\nfunction "
},
{
"path": "extlibs/squirrel/samples/metamethods.nut",
"chars": 1675,
"preview": "\nlocal base_vec={\n function _add(n)\n {\n return {\n x=x+n.x,\n y=y+n.y,\n z=z+"
},
{
"path": "extlibs/squirrel/samples/methcall.nut",
"chars": 1134,
"preview": "/*translation of the methcall test from The Great Computer Language Shootout\n*/\n\nclass Toggle {\n bool=null\n}\n\nfunctio"
},
{
"path": "extlibs/squirrel/samples/regex.nut",
"chars": 352,
"preview": "local ex = regexp(\"[a-zA-Z]+\");\nlocal string = \"123 Test; strlen(str);\";\nlocal res = ex.search(string);\nprint(string.sli"
},
{
"path": "extlibs/squirrel/samples/tailstate.nut",
"chars": 356,
"preview": "function state1()\n{\n ::suspend(\"state1\");\n return state2();\n}\n\nfunction state2()\n{\n ::suspend(\"state2\");\n re"
},
{
"path": "extlibs/squirrel/sq/CMakeLists.txt",
"chars": 1071,
"preview": "if(NOT DISABLE_DYNAMIC)\n if(CMAKE_COMPILER_IS_GNUCXX)\n set_source_files_properties(sq.c PROPERTIES COMPILE_FLAGS -st"
},
{
"path": "extlibs/squirrel/sq/Makefile",
"chars": 453,
"preview": "SQUIRREL= ..\n\n\nOUT= $(SQUIRREL)/bin/sq\nINCZ= -I$(SQUIRREL)/include -I. -I$(SQUIRREL)/sqlibs\nLIBZ= -L$(SQUIRREL)/lib\nLIB="
},
{
"path": "extlibs/squirrel/sq/sq.c",
"chars": 9458,
"preview": "/* see copyright notice in squirrel.h */\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <stdarg.h"
},
{
"path": "extlibs/squirrel/sq/sq.dsp",
"chars": 3793,
"preview": "# Microsoft Developer Studio Project File - Name=\"sq\" - Package Owner=<4>\n# Microsoft Developer Studio Generated Build F"
},
{
"path": "extlibs/squirrel/sqstdlib/CMakeLists.txt",
"chars": 1078,
"preview": "set(SQSTDLIB_SRC sqstdaux.cpp\n sqstdblob.cpp\n sqstdio.cpp\n sqstdmath.cpp"
},
{
"path": "extlibs/squirrel/sqstdlib/Makefile",
"chars": 815,
"preview": "SQUIRREL= ..\n\n\nCC?= gcc\nOUT?= $(SQUIRREL)/lib/libsqstdlib.a\nINCZ?= -I$(SQUIRREL)/include -I. -Iinclude\nDEFS= $(CC_EXTRA_"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdaux.cpp",
"chars": 4216,
"preview": "/* see copyright notice in squirrel.h */\n#include <squirrel.h>\n#include <sqstdaux.h>\n#include <assert.h>\n\nvoid sqstd_pri"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdblob.cpp",
"chars": 7543,
"preview": "/* see copyright notice in squirrel.h */\n#include <new>\n#include <squirrel.h>\n#include <sqstdio.h>\n#include <string.h>\n#"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdblobimpl.h",
"chars": 2965,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTD_BLOBIMPL_H_\n#define _SQSTD_BLOBIMPL_H_\n\nstruct SQBlob : public "
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdio.cpp",
"chars": 13671,
"preview": "/* see copyright notice in squirrel.h */\n#include <new>\n#include <stdio.h>\n#include <squirrel.h>\n#include <sqstdio.h>\n#i"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdlib.dsp",
"chars": 3388,
"preview": "# Microsoft Developer Studio Project File - Name=\"sqstdlib\" - Package Owner=<4>\n# Microsoft Developer Studio Generated B"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdmath.cpp",
"chars": 2792,
"preview": "/* see copyright notice in squirrel.h */\n#include <squirrel.h>\n#include <math.h>\n#include <stdlib.h>\n#include <sqstdmath"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdrex.cpp",
"chars": 21963,
"preview": "/* see copyright notice in squirrel.h */\n#include <squirrel.h>\n#include <string.h>\n#include <ctype.h>\n#include <setjmp.h"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdstream.cpp",
"chars": 8751,
"preview": "/* see copyright notice in squirrel.h */\n#include <new>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#incl"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdstream.h",
"chars": 785,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQSTD_STREAM_H_\n#define _SQSTD_STREAM_H_\n\nSQInteger _stream_readblob("
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdstring.cpp",
"chars": 14443,
"preview": "/* see copyright notice in squirrel.h */\n#include <squirrel.h>\n#include <sqstdstring.h>\n#include <string.h>\n#include <st"
},
{
"path": "extlibs/squirrel/sqstdlib/sqstdsystem.cpp",
"chars": 3551,
"preview": "/* see copyright notice in squirrel.h */\n#include <squirrel.h>\n#include <time.h>\n#include <stdlib.h>\n#include <stdio.h>\n"
},
{
"path": "extlibs/squirrel/squirrel/CMakeLists.txt",
"chars": 1128,
"preview": "set(SQUIRREL_SRC sqapi.cpp\n sqbaselib.cpp\n sqclass.cpp\n sqcompiler.cpp\n "
},
{
"path": "extlibs/squirrel/squirrel/Makefile",
"chars": 898,
"preview": "SQUIRREL= ..\n\n\nCC?= gcc\nOUT?= $(SQUIRREL)/lib/libsquirrel.a\nINCZ?= -I$(SQUIRREL)/include -I. -Iinclude\nDEFS= $(CC_EXTRA_"
},
{
"path": "extlibs/squirrel/squirrel/sqapi.cpp",
"chars": 42695,
"preview": "/*\n see copyright notice in squirrel.h\n*/\n#include \"sqpcheader.h\"\n#include \"sqvm.h\"\n#include \"sqstring.h\"\n#include \"s"
},
{
"path": "extlibs/squirrel/squirrel/sqarray.h",
"chars": 2929,
"preview": "/* see copyright notice in squirrel.h */\n#ifndef _SQARRAY_H_\n#define _SQARRAY_H_\n\nstruct SQArray : public CHAINABLE_OBJ"
}
]
// ... and 270 more files (download for full content)
About this extraction
This page contains the full source code of the scemino/engge GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 470 files (2.1 MB), approximately 565.9k tokens, and a symbol index with 2593 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.